Delen via

Async gebruiken voor Bestandstoegang (Visual Basic)

  • Artikel

U kunt de functie Async gebruiken om toegang te krijgen tot bestanden. Met behulp van de functie Async kunt u asynchrone methoden aanroepen zonder callbacks te gebruiken of uw code over meerdere methoden of lambda-expressies te splitsen. Als u synchrone code asynchroon wilt maken, roept u een asynchrone methode aan in plaats van een synchrone methode en voegt u enkele trefwoorden toe aan de code.

U kunt de volgende redenen overwegen om asynchroon toe te voegen aan aan aanroepen voor bestandstoegang:

  • Asynchrony maakt UI-toepassingen responsiefer omdat de UI-thread waarmee de bewerking wordt gestart, ander werk kan uitvoeren. Als de UI-thread code moet uitvoeren die lang duurt (bijvoorbeeld meer dan 50 milliseconden), kan de gebruikersinterface blokkeren totdat de I/O is voltooid en kan de UI-thread opnieuw toetsenbord- en muisinvoer en andere gebeurtenissen verwerken.

  • Asynchroon verbetert de schaalbaarheid van ASP.NET en andere servertoepassingen door de noodzaak van threads te verminderen. Als de toepassing een toegewezen thread per antwoord gebruikt en duizend aanvragen tegelijkertijd worden verwerkt, zijn er duizend threads nodig. Asynchrone bewerkingen hoeven vaak geen thread te gebruiken tijdens de wachttijd. Ze gebruiken de bestaande I/O-voltooiingsthread kort aan het einde.

  • De latentie van een bestandstoegangsbewerking kan erg laag zijn onder de huidige omstandigheden, maar de latentie kan in de toekomst aanzienlijk toenemen. Een bestand kan bijvoorbeeld worden verplaatst naar een server die zich over de hele wereld bevindt.

  • De extra overhead voor het gebruik van de Async-functie is klein.

  • Asynchrone taken kunnen eenvoudig parallel worden uitgevoerd.

De voorbeelden uitvoeren

Als u de voorbeelden in dit onderwerp wilt uitvoeren, kunt u een WPF-toepassing of een Windows Forms-toepassing maken en vervolgens een knop toevoegen. Voeg in de gebeurtenis van Click de knop een aanroep toe aan de eerste methode in elk voorbeeld.

Neem in de volgende voorbeelden de volgende Imports instructies op.

Imports System  
Imports System.Collections.Generic  
Imports System.Diagnostics  
Imports System.IO  
Imports System.Text  
Imports System.Threading.Tasks

Gebruik van de FileStream-klasse

In de voorbeelden in dit onderwerp wordt de FileStream klasse gebruikt, die een optie heeft die ervoor zorgt dat asynchrone I/O op besturingssysteemniveau plaatsvindt. Met deze optie kunt u voorkomen dat een ThreadPool-thread in veel gevallen wordt geblokkeerd. Als u deze optie wilt inschakelen, geeft u het useAsync=true of options=FileOptions.Asynchronous argument op in de constructor-aanroep.

U kunt deze optie niet gebruiken en StreamReaderStreamWriter als u ze rechtstreeks opent door een bestandspad op te geven. U kunt deze optie echter gebruiken als u deze Stream opgeeft dat de klasse is FileStream geopend. Houd er rekening mee dat asynchrone aanroepen sneller zijn in UI-apps, zelfs als een ThreadPool-thread is geblokkeerd, omdat de UI-thread niet wordt geblokkeerd tijdens de wachttijd.

Tekst schrijven

In het volgende voorbeeld wordt tekst naar een bestand geschreven. Bij elke await-instructie wordt de methode onmiddellijk afgesloten. Wanneer de bestands-I/O is voltooid, wordt de methode hervat bij de instructie die volgt op de await-instructie. Houd er rekening mee dat de asynchrone wijzigingsfunctie de definitie bevat van methoden die gebruikmaken van de await-instructie.

Public Async Sub ProcessWrite()  
    Dim filePath = "temp2.txt"  
    Dim text = "Hello World" & ControlChars.CrLf  
  
    Await WriteTextAsync(filePath, text)  
End Sub  
  
Private Async Function WriteTextAsync(filePath As String, text As String) As Task  
    Dim encodedText As Byte() = Encoding.Unicode.GetBytes(text)  
  
    Using sourceStream As New FileStream(filePath,  
        FileMode.Append, FileAccess.Write, FileShare.None,  
        bufferSize:=4096, useAsync:=True)  
  
        Await sourceStream.WriteAsync(encodedText, 0, encodedText.Length)  
    End Using  
End Function

Het oorspronkelijke voorbeeld heeft de instructie Await sourceStream.WriteAsync(encodedText, 0, encodedText.Length), een samentrekking van de volgende twee instructies:

Dim theTask As Task = sourceStream.WriteAsync(encodedText, 0, encodedText.Length)  
Await theTask

De eerste instructie retourneert een taak en zorgt ervoor dat bestandsverwerking wordt gestart. De tweede instructie met de wacht zorgt ervoor dat de methode onmiddellijk wordt afgesloten en een andere taak wordt geretourneerd. Wanneer de bestandsverwerking later is voltooid, keert de uitvoering terug naar de instructie die volgt op de wacht. Zie Controlestroom in Async-programma's (Visual Basic) voor meer informatie.

Tekst lezen

In het volgende voorbeeld wordt tekst uit een bestand gelezen. De tekst wordt gebufferd en in dit geval in een StringBuilder. In tegenstelling tot in het vorige voorbeeld produceert de evaluatie van de wacht een waarde. De ReadAsync methode retourneert eenInt32<>Task , zodat de evaluatie van de wacht een Int32 waarde (numRead) produceert nadat de bewerking is voltooid. Zie Asynchrone retourtypen (Visual Basic) voor meer informatie.

Public Async Sub ProcessRead()  
    Dim filePath = "temp2.txt"  
  
    If File.Exists(filePath) = False Then  
        Debug.WriteLine("file not found: " & filePath)  
    Else  
        Try  
            Dim text As String = Await ReadTextAsync(filePath)  
            Debug.WriteLine(text)  
        Catch ex As Exception  
            Debug.WriteLine(ex.Message)  
        End Try  
    End If  
End Sub  
  
Private Async Function ReadTextAsync(filePath As String) As Task(Of String)  
  
    Using sourceStream As New FileStream(filePath,  
        FileMode.Open, FileAccess.Read, FileShare.Read,  
        bufferSize:=4096, useAsync:=True)  
  
        Dim sb As New StringBuilder  
  
        Dim buffer As Byte() = New Byte(&H1000) {}  
        Dim numRead As Integer  
        numRead = Await sourceStream.ReadAsync(buffer, 0, buffer.Length)  
        While numRead <> 0  
            Dim text As String = Encoding.Unicode.GetString(buffer, 0, numRead)  
            sb.Append(text)  
  
            numRead = Await sourceStream.ReadAsync(buffer, 0, buffer.Length)  
        End While  
  
        Return sb.ToString  
    End Using  
End Function

Parallelle Asynchrone I/O

In het volgende voorbeeld ziet u parallelle verwerking door 10 tekstbestanden te schrijven. Voor elk bestand retourneert de WriteAsync methode een taak die vervolgens wordt toegevoegd aan een lijst met taken. De Await Task.WhenAll(tasks) instructie sluit de methode af en hervat binnen de methode wanneer bestandsverwerking is voltooid voor alle taken.

In het voorbeeld worden alle FileStream exemplaren in een Finally blok gesloten nadat de taken zijn voltooid. Als elk FileStream in plaats daarvan in een Imports instructie is gemaakt, kan het FileStream worden verwijderd voordat de taak is voltooid.

Houd er rekening mee dat een prestatieverbeteringen bijna volledig afkomstig zijn van de parallelle verwerking en niet van de asynchrone verwerking. De voordelen van asynchroon zijn dat het geen meerdere threads koppelt en dat de gebruikersinterfacethread niet wordt gekoppeld.

Public Async Sub ProcessWriteMult()  
    Dim folder = "tempfolder\"  
    Dim tasks As New List(Of Task)  
    Dim sourceStreams As New List(Of FileStream)  
  
    Try  
        For index = 1 To 10  
            Dim text = "In file " & index.ToString & ControlChars.CrLf  
  
            Dim fileName = "thefile" & index.ToString("00") & ".txt"  
            Dim filePath = folder & fileName  
  
            Dim encodedText As Byte() = Encoding.Unicode.GetBytes(text)  
  
            Dim sourceStream As New FileStream(filePath,  
                FileMode.Append, FileAccess.Write, FileShare.None,  
                bufferSize:=4096, useAsync:=True)  
  
            Dim theTask As Task = sourceStream.WriteAsync(encodedText, 0, encodedText.Length)  
            sourceStreams.Add(sourceStream)  
  
            tasks.Add(theTask)  
        Next  
  
        Await Task.WhenAll(tasks)  
    Finally  
        For Each sourceStream As FileStream In sourceStreams  
            sourceStream.Close()  
        Next  
    End Try  
End Sub

Wanneer u de WriteAsync en ReadAsync methoden gebruikt, kunt u een CancellationToken, die u kunt gebruiken om de bewerking mid-stream te annuleren opgeven. Zie Uw asynchrone toepassing (Visual Basic) en annulering in Beheerde threads verfijnen voor meer informatie.

Zie ook