¿Hay algún efecto secundario de regresar desde el interior de una instrucción using()?

Question

Volviendo un valor método de dentro una instrucción using que consigue un DataContext parece funcionar siempre bien, así:

public static Transaction GetMostRecentTransaction(int singleId) 
{ 
    using (var db = new DataClasses1DataContext()) 
    { 
     var transaction = (from t in db.Transactions 
           orderby t.WhenCreated descending 
           where t.Id == singleId 
           select t).SingleOrDefault(); 
     return transaction; 
    } 
} 

Pero siempre me siento como si debiera ser cerrar algo antes de romper fuera de los soportes de uso, por ejemplo definiendo la transacción antes de la declaración que usa, obtenga su valor dentro de los corchetes, y luego devuelva después de los corchetes.

¿Definir y devolver la variable fuera de los corchetes de uso sería una mejor práctica o conservaría los recursos de alguna manera?

Answer 1

No, creo que es más claro de esta manera. No se preocupe, Dispose se seguirá llamando "a la salida", y solo después de, el valor de retorno se evaluará por completo. Si se lanza una excepción en cualquier punto (incluida la evaluación del valor de retorno) también se llamará al Dispose.

Aunque es cierto que podría tomar la ruta más larga, se trata de dos líneas adicionales que acaba de agregar costra y el contexto extra para no perder de vista (mental). De hecho, realmente no necesita la variable local adicional, aunque puede ser útil en términos de depuración. Usted podría acaba de tener:

public static Transaction GetMostRecentTransaction(int singleId) 
{ 
    using (var db = new DataClasses1DataContext()) 
    { 
     return (from t in db.Transactions 
       orderby t.WhenCreated descending 
       where t.Id == singleId 
       select t).SingleOrDefault(); 
    } 
} 

De hecho, incluso podría tener la tentación de utilizar la notación de puntos, y poner la enfermedad Where dentro del SingleOrDefault:

public static Transaction GetMostRecentTransaction(int singleId) 
{ 
    using (var db = new DataClasses1DataContext()) 
    { 
     return db.Transactions.OrderByDescending(t => t.WhenCreated) 
           .SingleOrDefault(t => t.Id == singleId); 
    } 
} 

Answer 2

un vistazo a este

The CLR converts your code into MSIL. And the using statement gets translated into a try and finally block. This is how the using statement is represented in IL. A using statement is translated into three parts: acquisition, usage, and disposal. The resource is first acquired, then the usage is enclosed in a try statement with a finally clause. The object then gets disposed in the finally clause.

Answer 3

Hay no efectos secundarios de regresar de una declaración using().

Si hace que el código más legible sea otra discusión.

Answer 4

Creo que es todo lo mismo. No hay nada malo en el código. Al .NET framework no le importaría dónde se crea el objeto. Lo que importa es si se hace referencia o no.

Answer 5

Sí, puede haber un efecto secundario. Por ejemplo, si se utiliza la misma técnica en el método ASP.NET MVC Acción, obtendrá el siguiente error: "La instancia de ObjectContext se ha dispuesto y ya no se puede utilizar para las operaciones que requieren una conexión"

public ActionResult GetMostRecentTransaction(int singleId) 
{ 
    using (var db = new DataClasses1DataContext()) 
    { 
     var transaction = (from t in db.Transactions 
           orderby t.WhenCreated descending 
           where t.Id == singleId 
           select t).SingleOrDefault(); 
     return PartialView("_transactionPartial", transaction); 
    } 
}