Ci sono effetti collaterali di ritorno da una dichiarazione using()?

Question

restituendo un valore metodo dal all'interno un'istruzione using che ottiene un DataContext sembra funzionare sempre bene, in questo modo:

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; 
    } 
} 

Ma mi sento sempre come dovrei essere chiusura qualcosa prima che io rompo fuori dalle parentesi, ad es definendo la transazione prima dell' l'istruzione using, si ottiene il valore all'interno di tra parentesi e quindi restituendo dopo le parentesi il.

Definire e restituire la variabile al di fuori delle parentesi usando è migliore pratica o risparmiare risorse in alcun modo?

Answer 1

No, penso che sia più chiaro in questo modo. Non preoccuparti, Dispose verrà ancora chiamato "in uscita" - e solo dopo il il valore restituito viene valutato completamente. Se viene lanciata un'eccezione in qualsiasi momento (inclusa la valutazione del valore di ritorno) verrà ancora chiamato anche Dispose.

Mentre è certamente possibile prendere il percorso più lungo, sono due linee extra che aggiungono solo cruft e contesto aggiuntivo per tenere traccia di (mentalmente). In realtà, non hai davvero bisogno della variabile locale extra - sebbene possa essere utile in termini di debugging. Si potrebbe semplicemente avere:

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(); 
    } 
} 

Anzi, potrei anche essere tentati di usare la notazione del punto, e mettere la condizione Where all'interno 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

Date un'occhiata a questo

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

Ci sono no effetti collaterali di ritorno dall'interno di una dichiarazione using().

Se rende il codice più leggibile è un'altra discussione.

Answer 4

Penso che sia lo stesso. Non c'è niente di male nel codice. Il framework .NET non si preoccupa di dove viene creato l'oggetto. La cosa che conta è se sia referenziata o meno.

Answer 5

Sì, può esserci un effetto collaterale. Ad esempio, se si utilizza la stessa tecnica in modo ASP.NET MVC azione, si otterrà il seguente errore: "L'istanza ObjectContext è stato eliminato e non è più possibile essere utilizzato per le operazioni che richiedono una connessione"

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); 
    } 
}