Asynchroner Dateizugriff (C#)

Mithilfe des asynchronen Features für den Zugriff auf Dateien können Sie asynchrone Methoden aufrufen, ohne Rückrufe zu verwenden oder den Code auf mehrere Methoden oder Lambda-Ausdrücke aufzuteilen. Um synchronen Code asynchron zu machen, rufen Sie eine asynchrone Methode anstelle einer synchronen Methode auf, und fügen Sie dem Code einige Schlüsselwörter hinzu.

Erwägen Sie das Hinzufügen einer Asynchronität zu Dateizugriffsaufrufen aus folgenden Gründen:

Verwenden geeigneter Klassen

Die einfachen Beispiele in diesem Thema veranschaulichen File.WriteAllTextAsync und File.ReadAllTextAsync. Um die Datei-E/A-Vorgänge zu steuern, verwenden Sie die FileStream Klasse, die über eine Option verfügt, die bewirkt, dass asynchrone E/A-Vorgänge auf Betriebssystemebene auftreten. Mit dieser Option können Sie in vielen Fällen verhindern, dass ein Threadpoolthread blockiert wird. Um diese Option zu aktivieren, geben Sie das useAsync=true Oder-Argument options=FileOptions.Asynchronous im Konstruktoraufruf an.

Sie können diese Option nicht mit StreamReader und StreamWriter verwenden, wenn Sie sie direkt durch Angabe eines Dateipfads öffnen. Sie können diese Option jedoch verwenden, wenn Sie ihnen eine Stream bereitstellen, die die FileStream Klasse geöffnet hat. Asynchrone Aufrufe sind in UI-Apps schneller, selbst wenn ein Thread aus dem Threadpool blockiert ist, da der UI-Thread während des Wartens nicht blockiert wird.

Text schreiben

In den folgenden Beispielen wird Text in eine Datei geschrieben. Bei jeder await-Anweisung wird die Methode sofort beendet. Wenn die Datei-E/A abgeschlossen ist, wird die Methode an der Anweisung fortgesetzt, die auf die Await-Anweisung folgt. Der asynchrone Modifizierer befindet sich in der Definition von Methoden, die die Await-Anweisung verwenden.

Einfaches Beispiel

public async Task SimpleWriteAsync()
{
    string filePath = "simple.txt";
    string text = $"Hello World";

    await File.WriteAllTextAsync(filePath, text);
}

Beispiel für endliches Steuerelement

public async Task ProcessWriteAsync()
{
    string filePath = "temp.txt";
    string text = $"Hello World{Environment.NewLine}";

    await WriteTextAsync(filePath, text);
}

async Task WriteTextAsync(string filePath, string text)
{
    byte[] encodedText = Encoding.Unicode.GetBytes(text);

    using var sourceStream =
        new FileStream(
            filePath,
            FileMode.Create, FileAccess.Write, FileShare.None,
            bufferSize: 4096, useAsync: true);

    await sourceStream.WriteAsync(encodedText, 0, encodedText.Length);
}

Das ursprüngliche Beispiel weist die Anweisung await sourceStream.WriteAsync(encodedText, 0, encodedText.Length);auf, die eine Kontraktion der folgenden beiden Anweisungen ist:

Task theTask = sourceStream.WriteAsync(encodedText, 0, encodedText.Length);
await theTask;

Die erste Anweisung gibt eine Aufgabe zurück und bewirkt, dass die Dateiverarbeitung gestartet wird. Die zweite Anweisung mit dem Await bewirkt, dass die Methode sofort beendet wird und eine andere Aufgabe zurückgibt. Wenn die Dateiverarbeitung später abgeschlossen ist, kehrt die Ausführung zur Anweisung zurück, die dem await folgt.

Lesen von Text

In den folgenden Beispielen wird Text aus einer Datei gelesen.

Einfaches Beispiel

public async Task SimpleReadAsync()
{
    string filePath = "simple.txt";
    string text = await File.ReadAllTextAsync(filePath);

    Console.WriteLine(text);
}

Beispiel für endliches Steuerelement

Der gepufferte Text wird in diesem Fall in ein StringBuilder verschoben. Im Gegensatz zum vorherigen Beispiel erzeugt die Auswertung des Await einen Wert. Die ReadAsync Methode gibt eine Task<Int32>, sodass die Auswertung des Awaits nach Abschluss des Vorgangs einen Int32 Wert numRead erzeugt. Weitere Informationen finden Sie unter Async-Rückgabetypen (C#).

public async Task ProcessReadAsync()
{
    try
    {
        string filePath = "temp.txt";
        if (File.Exists(filePath) != false)
        {
            string text = await ReadTextAsync(filePath);
            Console.WriteLine(text);
        }
        else
        {
            Console.WriteLine($"file not found: {filePath}");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
}

async Task<string> ReadTextAsync(string filePath)
{
    using var sourceStream =
        new FileStream(
            filePath,
            FileMode.Open, FileAccess.Read, FileShare.Read,
            bufferSize: 4096, useAsync: true);

    var sb = new StringBuilder();

    byte[] buffer = new byte[0x1000];
    int numRead;
    while ((numRead = await sourceStream.ReadAsync(buffer, 0, buffer.Length)) != 0)
    {
        string text = Encoding.Unicode.GetString(buffer, 0, numRead);
        sb.Append(text);
    }

    return sb.ToString();
}

Mehrere asynchrone E/A-Vorgänge

In den folgenden Beispielen werden mehrere asynchrone Schreibvorgänge gestartet. Die Laufzeit reiht diese Vorgänge in Warteschlangen ein. Die zugrunde liegende Implementierung verwendet möglicherweise asynchrone E/A- oder Threadpool-Threads, je nach Plattform und Konfiguration. Die tatsächliche Parallelität hängt von der Betriebssystemplattform und der Hardware ab.

Einfaches Beispiel

public async Task SimpleParallelWriteAsync()
{
    string folder = Directory.CreateDirectory("tempfolder").Name;
    IList<Task> writeTaskList = new List<Task>();

    for (int index = 11; index <= 20; ++ index)
    {
        string fileName = $"file-{index:00}.txt";
        string filePath = $"{folder}/{fileName}";
        string text = $"In file {index}{Environment.NewLine}";

        writeTaskList.Add(File.WriteAllTextAsync(filePath, text));
    }

    await Task.WhenAll(writeTaskList);
}

Beispiel für endliches Steuerelement

Für jede Datei gibt die WriteAsync Methode eine Aufgabe zurück, die einer Aufgabenliste hinzugefügt wird. Die await Task.WhenAll(tasks); Anweisung beendet die Methode und wird innerhalb der Methode fortgesetzt, wenn die Dateiverarbeitung für alle Aufgaben abgeschlossen ist.

Im Beispiel werden alle FileStream Instanzen in einem finally Block geschlossen, nachdem die Aufgaben abgeschlossen wurden. Wenn jedes FileStream stattdessen in einer using-Anweisung erstellt wurde, könnte die FileStream möglicherweise freigegeben werden, bevor die Aufgabe abgeschlossen ist.

Der asynchrone Ansatz verhindert, dass der aufrufende Thread blockiert wird, während E/A aussteht. In vielen Fällen hängen Durchsatzverbesserungen vom Betriebssystem, der Hardware und auf einigen Plattformen vom .NET-Laufzeitverhalten ab, z. B. Threadpoolbeschränkungen und -planung.

public async Task ProcessMultipleWritesAsync()
{
    IList<FileStream> sourceStreams = new List<FileStream>();

    try
    {
        string folder = Directory.CreateDirectory("tempfolder").Name;
        IList<Task> writeTaskList = new List<Task>();

        for (int index = 1; index <= 10; ++ index)
        {
            string fileName = $"file-{index:00}.txt";
            string filePath = $"{folder}/{fileName}";

            string text = $"In file {index}{Environment.NewLine}";
            byte[] encodedText = Encoding.Unicode.GetBytes(text);

            var sourceStream =
                new FileStream(
                    filePath,
                    FileMode.Create, FileAccess.Write, FileShare.None,
                    bufferSize: 4096, useAsync: true);

            Task writeTask = sourceStream.WriteAsync(encodedText, 0, encodedText.Length);
            sourceStreams.Add(sourceStream);

            writeTaskList.Add(writeTask);
        }

        await Task.WhenAll(writeTaskList);
    }
    finally
    {
        foreach (FileStream sourceStream in sourceStreams)
        {
            sourceStream.Close();
        }
    }
}

Wenn Sie die WriteAsync und ReadAsync Methoden verwenden, können Sie einen CancellationToken zum Abbrechen des Vorgangs während des Ablaufs angeben. Weitere Informationen finden Sie unter "Abbruch" in verwalteten Threads.

Siehe auch

• Asynchrone Programmierung mit async und await (C#)
• Asynchrone Rückgabetypen (C#)