¿Es un buen enfoque llamar a return inside usando la instrucción {}?

Solo quiero saber si es seguro / buen enfoque llamar returndentro de un usingbloque.

Por ej.

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

Sabemos dispose()que se cancelará la última llave más rizada . Pero lo que será en el caso anterior, ya que returnsalta el control fuera del alcance dado (AFAIK) ...

1. ¿Me scope.Complete()llaman?
2. Y así para el dispose()método del osciloscopio .

Es perfectamente seguro llamar returndentro de su usingbloque, ya que un bloque de uso es solo un try/finallybloque.

En su ejemplo anterior, después de la devolución true, el alcance se eliminará y se devolverá el valor. return falseY scope.Complete()se no ser llamado. Disposesin embargo, se llamará independientemente, ya que reside dentro del bloque finalmente.

Su código es esencialmente el mismo que este (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 confirmará, ya que no hay forma de llegar scope.Complete()a confirmar la transacción.

Eso está bien: las finallycláusulas (que es lo que hace la llave de cierre de la usingcláusula debajo del capó) siempre se ejecutan cuando se deja el alcance, sin importar cómo.

Sin embargo, esto solo es cierto para las declaraciones que están en el bloque finalmente (que no se puede establecer explícitamente cuando se usa using). Por lo tanto, en su ejemplo, scope.Complete()nunca se llamaría (aunque espero que el compilador le advierta sobre el código inalcanzable).

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

Entonces, en este ejemplo, no se llama a Complete () y se elimina el alcance, asumiendo que hereda la interfaz IDisposable.

Alcance Definitivamente se debe llamar a Complete antes return. El compilador mostrará una advertencia y este código nunca se llamará.

Con respecto a returnsí mismo, sí, es seguro llamarlo usingdeclaración interna . El uso se traduce en intentar, finalmente bloquear detrás de la escena y finalmente bloquear debe ejecutarse.

En el ejemplo que ha proporcionado, hay un problema; scope.Complete()nunca se llama. En segundo lugar, no es una buena práctica utilizar returndeclaraciones dentro de usingdeclaraciones. Consulte lo siguiente:

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

En este simple ejemplo, el punto es que; el valor de scopeserá nulo cuando finalice el uso de la instrucción.

Así que es mejor no volver al interior usando declaraciones.

Para asegurarse de que scope.Complete()se llamará, envuélvalo con try/finally. Se disposellama porque lo ha envuelto con el usingque es un try/finallybloque alternativo .

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

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