Cosa succede se ritorni prima della fine dell'istruzione using? Sarà chiamato lo smaltimento?

Ho il seguente codice

using(MemoryStream ms = new MemoryStream())
{
     //code
     return 0;
}

Il dispose()metodo viene chiamato alla fine delle usingparentesi graffe dell'istruzione, }giusto? Dato che io returnprima della fine della usingdichiarazione, l' MemoryStreamoggetto verrà smaltito correttamente? Che succede qui?

Sì, Disposeverrà chiamato. Viene chiamata non appena l'esecuzione lascia l'ambito del usingblocco, indipendentemente dal mezzo impiegato per abbandonare il blocco, che si tratti della fine dell'esecuzione del blocco, di returnun'istruzione o di un'eccezione.

Come sottolinea correttamente @Noldorin, l'utilizzo di un usingblocco nel codice viene compilato in try/ finally, con Disposeessere chiamato nel finallyblocco. Ad esempio il codice seguente:

using(MemoryStream ms = new MemoryStream())
{
     //code
     return 0;
}

diventa effettivamente:

MemoryStream ms = new MemoryStream();
try
{
    // code
    return 0;
}
finally
{
    ms.Dispose();
}

Quindi, poiché finallyè garantita l'esecuzione dopo che il tryblocco ha terminato l'esecuzione, indipendentemente dal suo percorso di esecuzione, Disposeè garantito che venga chiamato, non importa cosa.

Per ulteriori informazioni, vedere questo articolo di MSDN .

Addendum:
Solo un piccolo avvertimento da aggiungere: poiché Disposeè garantito che venga chiamato, è quasi sempre una buona idea assicurarsi che Disposenon generi mai un'eccezione quando si implementa IDisposable. Purtroppo, ci sono alcune classi nella libreria di base che fanno un tiro in determinate circostanze, quando Disposeviene chiamato - Sto guardando voi, WCF Service Reference / Proxy Client! - e quando ciò accade può essere molto difficile rintracciare l'eccezione originale se è Disposestata chiamata durante uno svolgimento dello stack di eccezioni, poiché l'eccezione originale viene inghiottita a favore della nuova eccezione generata dalla Disposechiamata. Può essere frustrante in modo esasperante. O è frustrantemente esasperante? Uno dei due. Forse entrambi.

usingle istruzioni si comportano esattamente come i try ... finallyblocchi, quindi verranno sempre eseguite su qualsiasi percorso di uscita del codice. Tuttavia, credo che siano soggetti alle pochissime e rare situazioni in cui i finallyblocchi non vengono chiamati. Un esempio che posso ricordare è se il thread in primo piano esce mentre i thread in background sono attivi: tutti i thread tranne il GC vengono sospesi, il che significa che i finallyblocchi non vengono eseguiti.

Modifica ovvia: si comportano allo stesso modo a parte la logica che consente loro di gestire oggetti IDisposable, d'oh.

Contenuto bonus: possono essere impilati (dove i tipi differiscono):

using (SqlConnection conn = new SqlConnection("string"))
using (SqlCommand comm = new SqlCommand("", conn))
{

}

E anche delimitato da virgole (dove i tipi sono gli stessi):

using (SqlCommand comm = new SqlCommand("", conn), 
       SqlCommand comm2 = new SqlCommand("", conn))
{

}

Il tuo oggetto MemoryStream verrà smaltito correttamente, non devi preoccuparti di questo.

Con l' usingistruzione, l'oggetto verrà eliminato indipendentemente dal percorso di completamento.

Ulteriore lettura ...

• http://aspadvice.com/blogs/name/archive/2008/05/22/Return-Within-a-C_2300_-Using-Statement.aspx
• http://csharpfeeds.com/post/8451/Return_Within_a_Csharp_Using_Statement.aspx

Dai un'occhiata al tuo codice in reflector dopo averlo compilato. Scoprirai che il compilatore refactoring del codice per garantire che dispose venga chiamato nello stream.