Using, instruction (Visual Basic)Using Statement (Visual Basic)

Déclare le début d’un bloc Using et acquiert éventuellement les ressources système que le bloc contrôle.Declares the beginning of a Using block and optionally acquires the system resources that the block controls.

SyntaxeSyntax

Using { resourcelist | resourceexpression }
    [ statements ]
End Using

ComposantsParts

TermeTerm DéfinitionDefinition
resourcelist Obligatoire si vous ne fournissez pas de resourceexpression.Required if you do not supply resourceexpression. Liste d’une ou plusieurs ressources système que ce Using bloquer les contrôles, séparés par des virgules.List of one or more system resources that this Using block controls, separated by commas.
resourceexpression Obligatoire si vous ne fournissez pas de resourcelist.Required if you do not supply resourcelist. Variable ou expression de référence faisant référence à une ressource système pour être contrôlée par ce bloc de Using.Reference variable or expression referring to a system resource to be controlled by this Using block.
statements Ce paramètre est facultatif.Optional. Bloc d’instructions exécutées par le bloc Using.Block of statements that the Using block runs.
End Using Requis.Required. Met fin à la définition du bloc Using et supprime toutes les ressources qu’il contrôle.Terminates the definition of the Using block and disposes of all the resources that it controls.

Chaque ressource de la partie resourcelist possède la syntaxe et les éléments suivants :Each resource in the resourcelist part has the following syntax and parts:

resourcename As New resourcetype [ ( [ arglist ] ) ]

-ou--or-

resourcename As resourcetype = resourceexpression

Composants ResourceListresourcelist Parts

TermeTerm DéfinitionDefinition
resourcename Requis.Required. Variable de référence qui fait référence à une ressource système que le Using bloquer.Reference variable that refers to a system resource that the Using block controls.
New Obligatoire si l’instruction Using acquiert la ressource.Required if the Using statement acquires the resource. Si vous avez déjà acquis la ressource, utilisez la deuxième syntaxe.If you have already acquired the resource, use the second syntax alternative.
resourcetype Requis.Required. Classe de la ressource.The class of the resource. La classe doit implémenter l’interface IDisposable.The class must implement the IDisposable interface.
arglist Ce paramètre est facultatif.Optional. Liste des arguments que vous passez au constructeur pour créer une instance de resourcetype.List of arguments you are passing to the constructor to create an instance of resourcetype. Consultez la liste des paramètres.See Parameter List.
resourceexpression Requis.Required. Variable ou expression faisant référence à une ressource système répondant aux exigences de resourcetype.Variable or expression referring to a system resource satisfying the requirements of resourcetype. Si vous utilisez la deuxième syntaxe, vous devez acquérir la ressource avant de passer le contrôle à l’instruction Using.If you use the second syntax alternative, you must acquire the resource before passing control to the Using statement.

NotesRemarks

Parfois, votre code requiert une ressource non managée, telle qu’un descripteur de fichier, un wrapper COM ou une connexion SQL.Sometimes your code requires an unmanaged resource, such as a file handle, a COM wrapper, or a SQL connection. Un bloc de Using garantit la suppression d’une ou de plusieurs de ces ressources lorsque votre code est terminé.A Using block guarantees the disposal of one or more such resources when your code is finished with them. Cela les rend disponibles pour le code à utiliser.This makes them available for other code to use.

Les ressources managées sont supprimées par le garbage collector .NET Framework (GC) sans codage supplémentaire de votre part.Managed resources are disposed of by the .NET Framework garbage collector (GC) without any extra coding on your part. Vous n’avez pas besoin d’un bloc de Using pour les ressources managées.You do not need a Using block for managed resources. Toutefois, vous pouvez toujours utiliser un bloc de Using pour forcer la suppression d’une ressource managée au lieu d’attendre le garbage collector.However, you can still use a Using block to force the disposal of a managed resource instead of waiting for the garbage collector.

Un bloc de Using comporte trois parties : l’acquisition, l’utilisation et la suppression.A Using block has three parts: acquisition, usage, and disposal.

  • L' acquisition consiste à créer une variable et à l’initialiser pour faire référence à la ressource système.Acquisition means creating a variable and initializing it to refer to the system resource. L’instruction Using peut acquérir une ou plusieurs ressources, ou vous pouvez acquérir une seule ressource avant d’entrer dans le bloc et la fournir à l’instruction Using.The Using statement can acquire one or more resources, or you can acquire exactly one resource before entering the block and supply it to the Using statement. Si vous fournissez resourceexpression, vous devez acquérir la ressource avant de passer le contrôle à l’instruction Using.If you supply resourceexpression, you must acquire the resource before passing control to the Using statement.

  • L’utilisation consiste à accéder aux ressources et à effectuer des actions avec eux.Usage means accessing the resources and performing actions with them. Les instructions entre Using et End Using représentent l’utilisation des ressources.The statements between Using and End Using represent the usage of the resources.

  • La suppression consiste à appeler la méthode Dispose sur l’objet dans resourcename.Disposal means calling the Dispose method on the object in resourcename. Cela permet à l’objet de terminer correctement ses ressources.This allows the object to cleanly terminate its resources. L’instruction End Using supprime les ressources sous le contrôle du bloc Using.The End Using statement disposes of the resources under the Using block's control.

ComportementBehavior

Un bloc Using se comporte comme une construction Try...Finally dans laquelle le bloc Try utilise les ressources et le bloc Finally les supprime.A Using block behaves like a Try...Finally construction in which the Try block uses the resources and the Finally block disposes of them. C’est la raison pour laquelle le bloc Using garantit la suppression des ressources, quel que soit le mode de sortie du bloc.Because of this, the Using block guarantees disposal of the resources, no matter how you exit the block. Cela est vrai même dans le cas d’une exception non gérée, à l’exception d’un StackOverflowException.This is true even in the case of an unhandled exception, except for a StackOverflowException.

La portée de chaque variable de ressource acquise par l’instruction Using est limitée au bloc Using.The scope of every resource variable acquired by the Using statement is limited to the Using block.

Si vous spécifiez plusieurs ressources système dans l’instruction Using, l’effet est le même que si vous imbriquez des Using des blocs dans un autre.If you specify more than one system resource in the Using statement, the effect is the same as if you nested Using blocks one within another.

Si resourcename est Nothing, aucun appel à Dispose n’est effectué et aucune exception n’est levée.If resourcename is Nothing, no call to Dispose is made, and no exception is thrown.

Gestion structurée des exceptions dans un bloc usingStructured Exception Handling Within a Using Block

Si vous devez gérer une exception qui peut se produire dans le bloc Using, vous pouvez ajouter une construction Try...Finally complète.If you need to handle an exception that might occur within the Using block, you can add a complete Try...Finally construction to it. Si vous devez gérer le cas où l’instruction Using ne parvient pas à acquérir une ressource, vous pouvez effectuer un test pour voir si resourcename est Nothing.If you need to handle the case where the Using statement is not successful in acquiring a resource, you can test to see if resourcename is Nothing.

Gestion structurée des exceptions à la place d’un bloc usingStructured Exception Handling Instead of a Using Block

Si vous avez besoin d’un contrôle plus fin sur l’acquisition des ressources ou si vous avez besoin de code supplémentaire dans le bloc Finally, vous pouvez réécrire le bloc Using en tant que construction Try...Finally.If you need finer control over the acquisition of the resources, or you need additional code in the Finally block, you can rewrite the Using block as a Try...Finally construction. L’exemple suivant montre le squelette Try et Using constructions qui sont équivalentes à l’acquisition et à la suppression de resource.The following example shows skeleton Try and Using constructions that are equivalent in the acquisition and disposal of resource.

Using resource As New resourceType
    ' Insert code to work with resource.
End Using

' For the acquisition and disposal of resource, the following  
' Try construction is equivalent to the Using block.
Dim resource As New resourceType
Try
    ' Insert code to work with resource.
Finally
    If resource IsNot Nothing Then
        resource.Dispose()
    End If
End Try

Notes

Le code à l’intérieur du bloc Using ne doit pas assigner l’objet dans resourcename à une autre variable.The code inside the Using block should not assign the object in resourcename to another variable. Lorsque vous quittez le bloc Using, la ressource est supprimée et l’autre variable ne peut pas accéder à la ressource vers laquelle elle pointe.When you exit the Using block, the resource is disposed, and the other variable cannot access the resource to which it points.

ExempleExample

L’exemple suivant crée un fichier nommé log. txt et écrit deux lignes de texte dans le fichier.The following example creates a file that is named log.txt and writes two lines of text to the file. L’exemple lit également le même fichier et affiche les lignes de texte :The example also reads that same file and displays the lines of text:

Étant donné que les classes TextWriter et TextReader implémentent l’interface IDisposable, le code peut utiliser des instructions Using pour s’assurer que le fichier est fermé correctement après les opérations d’écriture et de lecture.Because the TextWriter and TextReader classes implement the IDisposable interface, the code can use Using statements to ensure that the file is correctly closed after the write and read operations.

Private Sub WriteFile()
    Using writer As System.IO.TextWriter = System.IO.File.CreateText("log.txt")
        writer.WriteLine("This is line one.")
        writer.WriteLine("This is line two.")
    End Using
End Sub

Private Sub ReadFile()
    Using reader As System.IO.TextReader = System.IO.File.OpenText("log.txt")
        Dim line As String

        line = reader.ReadLine()
        Do Until line Is Nothing
            Console.WriteLine(line)
            line = reader.ReadLine()
        Loop
    End Using
End Sub

Voir aussiSee also