Använda instruktion (Visual Basic)

Artikel
03/05/2024

Deklarerar början av ett Using block och hämtar eventuellt de systemresurser som blocket styr.

Syntax

Using { resourcelist | resourceexpression }
    [ statements ]
End Using

Delar

Period	Definition
`resourcelist`	Krävs om du inte anger `resourceexpression`. Lista över en eller flera systemresurser som det här `Using` blocket styr, avgränsade med kommatecken.
`resourceexpression`	Krävs om du inte anger `resourcelist`. Referensvariabel eller uttryck som refererar till en systemresurs som ska styras av det här `Using` blocket.
`statements`	Valfritt. Block med instruktioner som blocket körs på `Using` .
`End Using`	Obligatoriska. Avslutar definitionen av `Using` blocket och tar bort alla resurser som det styr.

Varje resurs i resourcelist delen har följande syntax och delar:

resourcename As New resourcetype [ ( [ arglist ] ) ]

-eller-

resourcename As resourcetype = resourceexpression

resourcelist-delar

Period	Definition
`resourcename`	Obligatoriska. Referensvariabel som refererar till en systemresurs som blockera styr `Using` .
`New`	Krävs om -instruktionen `Using` hämtar resursen. Om du redan har hämtat resursen använder du det andra syntaxalternativet.
`resourcetype`	Obligatoriska. Resursens klass. Klassen måste implementera IDisposable gränssnittet.
`arglist`	Valfritt. Lista med argument som du skickar till konstruktorn för att skapa en instans av `resourcetype`. Se Parameterlista.
`resourceexpression`	Obligatoriska. Variabel eller uttryck som refererar till en systemresurs som uppfyller kraven `resourcetype`i . Om du använder det andra syntaxalternativet måste du hämta resursen innan du skickar kontrollen till -instruktionen `Using` .

Kommentarer

Ibland kräver koden en ohanterad resurs, till exempel ett filhandtag, en COM-omslutning eller en SQL-anslutning. Ett Using block garanterar bortskaffande av en eller flera sådana resurser när koden är klar med dem. Detta gör dem tillgängliga för annan kod att använda.

Hanterade resurser tas bort av .NET Framework-skräpinsamlaren (GC) utan någon extra kodning från din sida. Du behöver inte ett Using block för hanterade resurser. Du kan dock fortfarande använda ett Using block för att tvinga bort en hanterad resurs i stället för att vänta på skräpinsamlaren.

Ett Using block har tre delar: förvärv, användning och bortskaffande.

Förvärv innebär att skapa en variabel och initiera den för att referera till systemresursen. -instruktionen Using kan hämta en eller flera resurser, eller så kan du hämta exakt en resurs innan du anger blocket och anger den i -instruktionen Using . Om du anger resourceexpressionmåste du hämta resursen innan du skickar kontrollen till -instruktionen Using .
Användning innebär att komma åt resurserna och utföra åtgärder med dem. Uttrycken mellan Using och End Using representerar användningen av resurserna.
Borttagning innebär att anropa Dispose -metoden för objektet i resourcename. På så sätt kan objektet avsluta sina resurser på ett korrekt sätt. Instruktionen End Using tar bort resurserna under Using blockets kontroll.

Funktionssätt

Ett Using block beter sig som en Try...Finally konstruktion där Try blocket använder resurserna och Finally blocket gör sig av med dem. På grund av detta Using garanterar blocket bortskaffande av resurser, oavsett hur du avslutar blocket. Detta gäller även om det gäller ett ohanterat undantag, förutom en StackOverflowException.

Omfattningen för varje resursvariabel som hämtas av -instruktionen Using är begränsad till Using blocket.

Om du anger mer än en systemresurs i -instruktionen Using är effekten densamma som om du kapslade Using block en inom en annan.

Om resourcename är Nothinggörs inget anrop till Dispose och inget undantag utlöses.

Strukturerad undantagshantering inom ett användningsblock

Om du behöver hantera ett undantag som kan inträffa i Using blocket kan du lägga till en fullständig Try...Finally konstruktion till det. Om du behöver hantera det fall där -instruktionen Using inte lyckas hämta en resurs kan du testa för att se om resourcename är Nothing.

Strukturerad undantagshantering i stället för ett användningsblock

Om du behöver finare kontroll över förvärvet av resurserna, eller om du behöver ytterligare kod i Finally blocket, kan du skriva om Using blocket som en Try...Finally konstruktion. I följande exempel visas skelett Try och Using konstruktioner som är likvärdiga vid förvärv och avyttring av 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

Kommentar

Koden i Using blocket bör inte tilldela objektet resourcename till en annan variabel. När du avslutar Using blocket tas resursen bort och den andra variabeln kan inte komma åt den resurs som den pekar på.

Exempel

I följande exempel skapas en fil med namnet log.txt och två textrader skrivs till filen. Exemplet läser också samma fil och visar textraderna:

TextWriter Eftersom klasserna och TextReader implementerar IDisposable gränssnittet kan koden använda Using instruktioner för att säkerställa att filen stängs korrekt efter skriv- och läsåtgärderna.

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

Dela via