Istruzione Using (Visual Basic)Using Statement (Visual Basic)

Dichiara l'inizio di un blocco di Using e, facoltativamente, acquisisce le risorse di sistema controllate dal blocco.Declares the beginning of a Using block and optionally acquires the system resources that the block controls.

SintassiSyntax

Using { resourcelist | resourceexpression }
    [ statements ]
End Using

PartiParts

TermineTerm DefinizioneDefinition
resourcelist Obbligatorio se non si specifica resourceexpression.Required if you do not supply resourceexpression. Elenco di una o più risorse di sistema che questa Using blocca i controlli, separate da virgole.List of one or more system resources that this Using block controls, separated by commas.
resourceexpression Obbligatorio se non si specifica resourcelist.Required if you do not supply resourcelist. Una variabile di riferimento o un'espressione che fa riferimento a una risorsa di sistema che deve essere controllata da questo blocco Using.Reference variable or expression referring to a system resource to be controlled by this Using block.
statements Facoltativa.Optional. Blocco di istruzioni eseguite dal blocco Using.Block of statements that the Using block runs.
End Using Obbligatoria.Required. Termina la definizione del blocco Using ed Elimina tutte le risorse che controlla.Terminates the definition of the Using block and disposes of all the resources that it controls.

Ogni risorsa della parte resourcelist presenta la sintassi e le parti seguenti:Each resource in the resourcelist part has the following syntax and parts:

resourcename As New resourcetype [ ( [ arglist ] ) ]

-oppure--or-

resourcename As resourcetype = resourceexpression

Parti Resourcesresourcelist Parts

TermineTerm DefinizioneDefinition
resourcename Obbligatoria.Required. Variabile di riferimento che fa riferimento a una risorsa di sistema che la Using blocca i controlli.Reference variable that refers to a system resource that the Using block controls.
New Obbligatorio se l'istruzione Using acquisisce la risorsa.Required if the Using statement acquires the resource. Se la risorsa è già stata acquisita, utilizzare la seconda alternativa della sintassi.If you have already acquired the resource, use the second syntax alternative.
resourcetype Obbligatoria.Required. Classe della risorsa.The class of the resource. La classe deve implementare l'interfaccia IDisposable.The class must implement the IDisposable interface.
arglist Facoltativa.Optional. Elenco di argomenti passati al costruttore per creare un'istanza di resourcetype.List of arguments you are passing to the constructor to create an instance of resourcetype. Vedere elenco di parametri.See Parameter List.
resourceexpression Obbligatoria.Required. Variabile o espressione che fa riferimento a una risorsa di sistema che soddisfa i requisiti di resourcetype.Variable or expression referring to a system resource satisfying the requirements of resourcetype. Se si usa la seconda sintassi alternativa, è necessario acquisire la risorsa prima di passare il controllo all'istruzione Using.If you use the second syntax alternative, you must acquire the resource before passing control to the Using statement.

NoteRemarks

A volte il codice richiede una risorsa non gestita, ad esempio un handle di file, un wrapper COM o una connessione SQL.Sometimes your code requires an unmanaged resource, such as a file handle, a COM wrapper, or a SQL connection. Un blocco Using garantisce l'eliminazione di una o più risorse di questo tipo al termine del codice.A Using block guarantees the disposal of one or more such resources when your code is finished with them. In modo da renderli disponibili per l'utilizzo da altro codice.This makes them available for other code to use.

Le risorse gestite vengono eliminate dal .NET Framework Garbage Collector (GC) senza alcuna codifica aggiuntiva da parte dell'utente.Managed resources are disposed of by the .NET Framework garbage collector (GC) without any extra coding on your part. Non è necessario un blocco Using per le risorse gestite.You do not need a Using block for managed resources. Tuttavia, è comunque possibile usare un blocco Using per forzare l'eliminazione di una risorsa gestita anziché attendere il 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 blocco Using è costituito da tre parti: acquisizione, utilizzo e eliminazione.A Using block has three parts: acquisition, usage, and disposal.

  • L' acquisizione significa creare una variabile e inizializzarla per fare riferimento alla risorsa di sistema.Acquisition means creating a variable and initializing it to refer to the system resource. L'istruzione Using può acquisire una o più risorse oppure è possibile acquisire esattamente una risorsa prima di immettere il blocco e fornirla all'istruzione 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. Se si fornisce resourceexpression, è necessario acquisire la risorsa prima di passare il controllo all'istruzione Using.If you supply resourceexpression, you must acquire the resource before passing control to the Using statement.

  • L' utilizzo indica l'accesso alle risorse e l'esecuzione di azioni con loro.Usage means accessing the resources and performing actions with them. Le istruzioni tra Using e End Using rappresentano l'utilizzo delle risorse.The statements between Using and End Using represent the usage of the resources.

  • Per eliminazione si intende la chiamata al metodo Dispose sull'oggetto resourcename.Disposal means calling the Dispose method on the object in resourcename. Questo consente all'oggetto di terminare in modo corretto le risorse.This allows the object to cleanly terminate its resources. L'istruzione End Using Elimina le risorse sotto il controllo del blocco di Using.The End Using statement disposes of the resources under the Using block's control.

ComportamentoBehavior

Un blocco di Using si comporta come una costruzione di Try...Finally in cui il blocco Try usa le risorse e il Finally blocco ne comporta l'eliminazione.A Using block behaves like a Try...Finally construction in which the Try block uses the resources and the Finally block disposes of them. Per questo motivo, il blocco Using garantisce l'eliminazione delle risorse, indipendentemente dal modo in cui si esce dal blocco.Because of this, the Using block guarantees disposal of the resources, no matter how you exit the block. Questo vale anche nel caso di un'eccezione non gestita, ad eccezione di un StackOverflowException.This is true even in the case of an unhandled exception, except for a StackOverflowException.

L'ambito di ogni variabile di risorsa acquisita dall'istruzione Using è limitato al blocco di Using.The scope of every resource variable acquired by the Using statement is limited to the Using block.

Se si specifica più di una risorsa di sistema nell'istruzione Using, l'effetto è identico a quello che si annida Using blocca un oggetto all'interno di un altro.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.

Se resourcename è Nothing, non viene effettuata alcuna chiamata a Dispose e non viene generata alcuna eccezione.If resourcename is Nothing, no call to Dispose is made, and no exception is thrown.

Gestione strutturata delle eccezioni in un blocco usingStructured Exception Handling Within a Using Block

Se è necessario gestire un'eccezione che può verificarsi all'interno del blocco di Using, è possibile aggiungere una costruzione completa Try...Finally.If you need to handle an exception that might occur within the Using block, you can add a complete Try...Finally construction to it. Se è necessario gestire il caso in cui l'istruzione Using non riesce ad acquisire una risorsa, è possibile verificare se resourcename è 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.

Gestione strutturata delle eccezioni anziché un blocco usingStructured Exception Handling Instead of a Using Block

Se è necessario un controllo più accurato sull'acquisizione delle risorse o se è necessario codice aggiuntivo nel blocco Finally, è possibile riscrivere il blocco Using come una costruzione 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. Nell'esempio seguente vengono illustrate Try di ossatura e costruzioni Using equivalenti nell'acquisizione e nell'eliminazione di 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

Nota

Il codice all'interno del blocco Using non deve assegnare l'oggetto resourcename a un'altra variabile.The code inside the Using block should not assign the object in resourcename to another variable. Quando si esce dal blocco Using, la risorsa viene eliminata e l'altra variabile non può accedere alla risorsa a cui fa riferimento.When you exit the Using block, the resource is disposed, and the other variable cannot access the resource to which it points.

EsempioExample

Nell'esempio seguente viene creato un file denominato log. txt che scrive due righe di testo nel file.The following example creates a file that is named log.txt and writes two lines of text to the file. Nell'esempio viene inoltre letto lo stesso file e vengono visualizzate le righe di testo:The example also reads that same file and displays the lines of text:

Poiché le classi TextWriter e TextReader implementano l'interfaccia IDisposable, il codice può utilizzare Using istruzioni per garantire che il file venga chiuso correttamente dopo le operazioni di scrittura e lettura.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

Vedere ancheSee also