Utiliser la déclaration using en c #

La syntaxe using peut (devrait) être utilisée comme moyen de définir une scope pour tout ce qui implémente IDisposable . L’instruction using garantit que Dispose est appelé en cas d’exception.

//the comstackr will create a local variable //which will go out of scope outside this context using (FileStream fs = new FileStream(file, FileMode.Open)) { //do stuff } 

Sinon, vous pouvez simplement utiliser:

  FileStream fs; try{ fs = new FileStream(); //do Stuff } finally{ if(fs!=null) fs.Dispose(); } 

Lecture supplémentaire à partir de MSDN

C #, via le CLR (Common Language Runtime) .NET Framework, libère automatiquement la mémoire utilisée pour stocker les objects devenus inutiles. La libération de la mémoire est non déterministe; la mémoire est libérée à chaque fois que le CLR décide d’effectuer une récupération de place. Cependant, il est généralement préférable de libérer le plus rapidement possible les ressources limitées telles que les descripteurs de fichiers et les connexions réseau.

L’instruction using permet au programmeur de spécifier quand les objects utilisant des ressources doivent les libérer. L’object fourni à l’instruction using doit implémenter l’interface IDisposable. Cette interface fournit la méthode Dispose, qui devrait libérer les ressources de l’object.

Il est souvent utilisé lors de l’ouverture d’une connexion à un stream ou à une firebase database.

Il se comporte comme un bloc d’essai {…} enfin {…}. Après le bloc using , l’object IDisposable qui a été instancié entre parenthèses sera correctement fermé.

 using (Stream stream = new Stream(...)) { } 

Avec cet exemple, le stream est fermé correctement après le bloc.

utiliser est enfin essayer syntaxe suger pour tout ce qui a une IDisposable .. comme une connexion SQL. Son utilisation permet de s’assurer que quelque chose est éliminé après sa sortie de la scope de using(){} .

 using(SqlConnection conn = new SqlConnection(connSsortingng)) { //use connection } //shorter than SqlConnection conn = new SqlConnection(connSsortingng) try { //use connection } finally { conn.Dispose(); } 

L’instruction using garantit qu’un object est correctement éliminé dès qu’il n’est plus nécessaire. Cela vous évite d’écrire obj.Dispose (); et donne un guide visuel quant à la scope et à l’utilisation d’une variable.

Voir la page MSDN pour plus d’informations

Cette forme d’utilisation concerne la libération des ressources. Il ne peut être utilisé qu’en combinaison avec la classe qui implémente l’interface IDisposable.

Exemple:

 using(SqlConnection conn = new SqlConnection(someConnectionSsortingng)) { //Do some database stuff here } 

À la fin du bloc using, conn.Dispose est appelé, même si une exception a été générée à l’intérieur du bloc. Dans le cas d’un object SwqlConnection, cela signifie que la connexion est toujours fermée.

Un inconvénient de cette construction est qu’il existe maintenant un moyen de savoir ce qui s’est passé.

Espérons que cela aide à répondre à votre question?

Chaque fois que votre code crée un object qui implémente IDisposable, votre code doit effectuer la création dans un bloc using, comme indiqué ci-dessus.

Il y a une exception à cette règle. Une erreur dans la conception des classes proxy WCF empêche l’utilisation d’instructions d’être utile pour les classes proxy. En bref, la méthode Dispose sur une classe proxy peut générer une exception. L’équipe de la WCF n’a vu aucune raison de ne pas permettre cela.

Malheureusement, ne pas voir une raison ne signifie pas qu’il n’y en a pas:

 try { using (var svc = new ServiceReference.ServiceName()) { throw new Exception("Testing"); } } catch (Exception ex) { // What exception is caught here? } 

Si l’appel implicite Dispose lève une exception, le bloc catch interceptera cette exception au lieu de celle lancée dans le bloc using .