Que se passe-t-il si je retourne avant la fin de l'instruction d'utilisation? La disposition sera-t-elle appelée?

J'ai le code suivant

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

La dispose()méthode est appelée à la fin des usingaccolades, }non? Puisque j'ai returnavant la fin de la usingdéclaration, l' MemoryStreamobjet sera-t-il éliminé correctement? Que se passe t-il ici?

Oui, Disposesera appelé. Il est appelé dès que l'exécution quitte la portée du usingbloc, quels que soient les moyens nécessaires pour quitter le bloc, que ce soit la fin de l'exécution du bloc, une returninstruction ou une exception.

Comme @Noldorin le souligne correctement, l'utilisation d'un usingbloc dans le code est compilée dans try/ finally, avec Disposeun appel dans le finallybloc. Par exemple le code suivant:

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

devient effectivement:

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

Ainsi, parce qu'il finallyest garanti de s'exécuter après la tryfin de l'exécution du bloc, quel que soit son chemin d'exécution, il Disposeest garanti d'être appelé, quoi qu'il arrive.

Pour plus d'informations, consultez cet article MSDN .

Addendum:
Juste une petite mise en garde à ajouter: car il Disposeest garanti d'être appelé, c'est presque toujours une bonne idée de s'assurer que Disposene lève jamais d'exception lorsque vous implémentez IDisposable. Malheureusement, il y a des classes dans la bibliothèque de base qui font un jet dans certaines circonstances , lorsque l' Disposeon appelle - je vous regarde, WCF Service de référence / Client Proxy! - et lorsque cela se produit, il peut être très difficile de retrouver l'exception d'origine si elle a Disposeété appelée lors d'un déroulement de pile d'exceptions, puisque l'exception d'origine est avalée au profit de la nouvelle exception générée par l' Disposeappel. Cela peut être extrêmement frustrant. Ou est-ce frustrant? Un des deux. Peut-être les deux.

usingLes instructions se comportent exactement comme des try ... finallyblocs, donc s'exécuteront toujours sur tous les chemins de sortie de code. Cependant, je crois qu'ils sont soumis aux très rares et rares situations dans lesquelles les finallyblocs ne sont pas appelés. Un exemple dont je me souviens est si le thread de premier plan se termine alors que les threads d'arrière-plan sont actifs: tous les threads en dehors du GC sont mis en pause, ce qui signifie que les finallyblocs ne sont pas exécutés.

Edition évidente: ils se comportent de la même manière en dehors de la logique qui leur permet de gérer les objets IDisposables, d'oh.

Contenu bonus: ils peuvent être empilés (là où les types diffèrent):

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

}

Et aussi délimité par des virgules (où les types sont les mêmes):

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

}

Votre objet MemoryStream sera supprimé correctement, pas besoin de vous en soucier.

Avec l' usinginstruction, l'objet sera supprimé quel que soit le chemin d'achèvement.

Lectures complémentaires ...

• 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

Jetez un œil à votre code dans Reflector après l'avoir compilé. Vous constaterez que le compilateur refactorise le code pour s'assurer que dispose est appelé sur le flux.