c# - validar - ¿Es un buen método para devolver el retorno utilizando el enunciado{}?

validar rut en mvc

Question

Solo quiero saber si es un método seguro / bueno para return llamadas dentro de un bloque de using .

Por ej.

using(var scope = new TransactionScope())
{
  // my core logic
  return true; // if condition met else
  return false;
  scope.Complete();
}

Sabemos que a la última dispose() llaves dispose() se cancelará. Pero lo que será en el caso anterior, ya que el return salta el control del alcance dado (AFAIK) ...

1. ¿Se scope.Complete() mi scope.Complete() ?
2. Y para el método dispose() scope.

Answer 1

En el ejemplo que ha proporcionado, hay un problema; scope.Complete() nunca se llama. En segundo lugar, no es una buena práctica usar la declaración de return dentro de las instrucciones de using . Consulte lo siguiente:

using(var scope = new TransactionScope())
{
    //have some logic here
    return scope;      
}

En este simple ejemplo, el punto es que; el valor del scope será nulo cuando se haya terminado de usar la instrucción.

Entonces es mejor no volver adentro usando declaraciones.

Answer 2

En este ejemplo, scope.Complete () nunca se ejecutará. Sin embargo, el comando de retorno limpiará todo lo que está asignado en la pila. El GC se encargará de todo lo que no esté referenciado. Entonces, a menos que haya un objeto que no pueda ser recogido por el GC, no hay problema.

Answer 3

En general, es un buen enfoque. Pero en su caso, si vuelve antes de llamar al scope.Complete() , simplemente destruirá el TransactionScope. Depende de tu diseño

Por lo tanto, en este ejemplo, no se llama a Complete () y se descarta el alcance, suponiendo que hereda la interfaz IDisposable.

Answer 4

Es perfectamente seguro llamar a return dentro de tu bloque de using , ya que un bloque de uso es solo un bloque try/finally .

En su ejemplo anterior después de devolver true , se eliminará el alcance y se devolverá el valor. return false , y scope.Complete() no se llamará. Dispose sin embargo, se llamará independientemente ya que reside dentro del bloque finally.

Su código es esencialmente el mismo (si eso lo hace más fácil de entender):

var scope = new TransactionScope())
try
{
  // my core logic
  return true; // if condition met else
  return false;
  scope.Complete();
}
finally
{
  if( scope != null) 
    ((IDisposable)scope).Dispose();
}

Tenga en cuenta que su transacción nunca se comprometerá ya que no hay forma de llegar a scope.Complete() para confirmar la transacción.

Answer 5

Eso está bien: las cláusulas finally (que es lo que hace el corchete de cierre de la cláusula de using bajo el capó) siempre se ejecutan cuando se deja el alcance, sin importar cómo.

Sin embargo, esto solo es cierto para las instrucciones que se encuentran en el bloque finally (que no se pueden establecer explícitamente cuando se using ). Por lo tanto, en su ejemplo, scope.Complete() nunca se llamará (sin embargo, espero que el compilador le advierta sobre el código inalcanzable).

Answer 6

Para asegurarse de que se scope.Complete() al scope.Complete() , envuélvalo con try/finally . Se llama al dispose porque lo ha envuelto con el using que es un bloque try/finally alternativo.

using(var scope = new TransactionScope())
{
  try
  {
  // my core logic
  return true; // if condition met else
  return false;
  }
  finally
  {
   scope.Complete();
  }
}

Answer 7

scope.Complete definitivamente debe llamarse antes del return . El compilador mostrará una advertencia y nunca se invocará este código.

Con respecto al return sí mismo, sí, es seguro llamarlo adentro using declaración. El uso se traduce para intentar finalmente bloquear detrás de la escena y, finalmente, el bloqueo se debe ejecutar.