Implementieren asynchroner Dateieingabe und -ausgabe

Abgeschlossen

Dateieingabe- und Ausgabevorgänge sind für viele Anwendungen unerlässlich, sodass sie von dateien auf der Festplatte lesen und schreiben können. In C# können Dateieingaben und -ausgabe (Datei-E/A) synchron oder asynchron ausgeführt werden. Die asynchrone Datei-E/A ist besonders nützlich, um die Anwendungsleistung und Reaktionsfähigkeit zu verbessern, insbesondere in Szenarien, in denen Dateivorgänge eine erhebliche Zeit in Anspruch nehmen können, z. B. das Lesen großer Dateien oder das Schreiben von Daten auf die Festplatte.

Erstellen asynchroner Methoden zum Lesen und Schreiben von Dateien

Die async- und await-Schlüsselwörter in C# ermöglichen es Ihnen, asynchrone Methoden zu erstellen, die Datei-E/A-Vorgänge ausführen können, ohne den Hauptthread zu blockieren. Dies ist besonders bei Anwendungen mit einer Benutzeroberfläche hilfreich, bei denen das Blockieren des Hauptthreads zu einer fixierten oder nicht reagierenden Benutzeroberfläche führen kann. Die Namespaces System.IO und System.Text.Json stellen Klassen und Methoden zum asynchronen Ausführen von Datei-E/A-Vorgängen bereit.

Beispielsweise stellt die File Klasse im System.IO Namespace Methoden zum asynchronen Lesen und Schreiben von Dateien bereit. Die File.ReadAllTextAsync Methode liest den Inhalt einer Datei asynchron, während die File.WriteAllTextAsync Methode Text asynchron in eine Datei schreibt. Diese Methoden geben einen Task<string> oder Task zurück, der den asynchronen Vorgang darstellt, sodass Sie das await Schlüsselwort verwenden können, um auf den Abschluss zu warten, ohne den aufrufenden Thread zu blockieren.

System.Text.Json Im Namespace stellt die JsonSerializer Klasse asynchrone Methoden zum Serialisieren und Deserialisieren von JSON-Daten bereit. Die JsonSerializer.SerializeAsync Methode serialisiert ein Objekt asynchron in eine JSON-Zeichenfolge, während die JsonSerializer.DeserializeAsync Methode eine JSON-Zeichenfolge asynchron in ein Objekt deserialisiert. Diese Methoden geben auch einen Task , der den asynchronen Vorgang darstellt.

Im folgenden Codebeispiel wird veranschaulicht, wie asynchrone Methoden erstellt werden, die ein C#-Objekt serialisieren, die JSON-Zeichenfolge in eine Datei schreiben, den Dateiinhalt in eine Zeichenfolge lesen und die JSON-Zeichenfolge wieder in ein C#-Objekt deserialisieren:

using System;
using System.IO;
using System.Text.Json;
using System.Threading.Tasks;

public class Account
{
    public string Name { get; set; }
    public decimal Balance { get; set; }
}

public class Program
{
    public static async Task Main()
    {
        // Combine a directory and file name, then create the directory if it doesn't exist
        string directoryPath = @"C:\TempDir";
        if (!Directory.Exists(directoryPath))
        {
            Directory.CreateDirectory(directoryPath);
        }

        string fileName = "account.json";
        string filePath = Path.Combine(directoryPath, fileName);

        Account account = new Account { Name = "Elize Harmsen", Balance = 1000.00m };

        // Save account data to a file asynchronously
        await SaveAccountDataAsync(filePath, account);

        // Load account data from the file asynchronously
        Account loadedAccount = await LoadAccountDataAsync(filePath);
        Console.WriteLine($"Name: {loadedAccount.Name}, Balance: {loadedAccount.Balance}");
    }

    public static async Task SaveAccountDataAsync(string filePath, Account account)
    {
        string jsonString = JsonSerializer.Serialize(account);
        await File.WriteAllTextAsync(filePath, jsonString);
    }

    public static async Task<Account> LoadAccountDataAsync(string filePath)
    {
        string jsonString = await File.ReadAllTextAsync(filePath);
        return JsonSerializer.Deserialize<Account>(jsonString);
    }
}

In diesem Beispiel serialisiert die SaveAccountDataAsync Methode ein Account Objekt in eine JSON-Zeichenfolge und schreibt es asynchron in eine Datei. Die LoadAccountDataAsync Methode liest die JSON-Zeichenfolge aus der Datei und deserialisiert sie wieder in ein Account Objekt asynchron. Die Main Methode veranschaulicht, wie diese asynchronen Methoden mithilfe des await Schlüsselworts aufgerufen werden.

Dadurch kann die Anwendung Datei-E/A-Vorgänge ausführen, ohne den Hauptthread zu blockieren, die Leistung und Reaktionsfähigkeit zu verbessern. Die Directory.CreateDirectory Methode wird verwendet, um das Verzeichnis zu erstellen, wenn es nicht vorhanden ist, um sicherzustellen, dass die Datei erfolgreich geschrieben werden kann.

Zusammenfassung

In dieser Lektion haben Sie erfahren, wie Sie asynchrone Dateieingabe- und Ausgabevorgänge in C# implementieren. Sie haben die Verwendung der Schlüsselwörter async und await untersucht, um asynchrone Methoden zum Lesen und Schreiben von Dateien zu erstellen. Mithilfe dieser Techniken können Sie die Leistung und Reaktionsfähigkeit Ihrer Anwendungen verbessern, wenn Datei-E/A-Vorgänge ausgeführt werden.

Wichtige Punkte

• Dateieingabe- und Ausgabevorgänge können synchron oder asynchron in C# ausgeführt werden.
• Die asynchrone Datei-E/A verbessert die Anwendungsleistung und Reaktionsfähigkeit.
• Die Schlüsselwörter async und await werden verwendet, um asynchrone Methoden für Datei-E/A-Vorgänge zu erstellen.
• Die Namespaces System.IO und System.Text.Json stellen Klassen und Methoden zum asynchronen Ausführen von Datei-E/A-Vorgängen bereit.
• Die File Klasse und die JsonSerializer Klasse werden im bereitgestellten Beispiel verwendet, um asynchrone Datei-E/A-Vorgänge zu veranschaulichen.