Implémenter une entrée et une sortie de fichier asynchrones

Effectué

Les opérations d’entrée et de sortie de fichier sont essentielles pour de nombreuses applications, ce qui leur permet de lire et d’écrire dans des fichiers sur le disque dur. En C#, les entrées et sorties de fichier (E/S de fichier) peuvent être effectuées de manière synchrone ou asynchrone. Les E/S de fichiers asynchrones sont particulièrement utiles pour améliorer les performances et la réactivité des applications, en particulier dans les scénarios où les opérations de fichier peuvent prendre beaucoup de temps, telles que la lecture de fichiers volumineux ou l’écriture de données sur le disque dur.

Création de méthodes asynchrones pour la lecture et l’écriture de fichiers

Les mots clés async et await en C# vous permettent de créer des méthodes asynchrones qui peuvent effectuer des opérations d'E/S de fichier sans bloquer le thread principal. Cela est particulièrement utile dans les applications avec une interface utilisateur, où le blocage du thread principal peut entraîner une interface utilisateur figée ou non réponse. Les System.IO et System.Text.Json espaces de noms fournissent des classes et des méthodes pour effectuer des opérations d’E/S de fichier de manière asynchrone.

Par exemple, la File classe dans l’espace System.IO de noms fournit des méthodes pour lire et écrire des fichiers de manière asynchrone. La File.ReadAllTextAsync méthode lit le contenu d’un fichier de façon asynchrone, tandis que la File.WriteAllTextAsync méthode écrit du texte dans un fichier de manière asynchrone. Ces méthodes retournent un Task<string> ou Task qui représente l’opération asynchrone, ce qui vous permet d’utiliser le await mot clé pour attendre leur achèvement sans bloquer le thread appelant.

Dans l’espace System.Text.Json de noms, la JsonSerializer classe fournit des méthodes asynchrones pour sérialiser et désérialiser des données JSON. La JsonSerializer.SerializeAsync méthode sérialise un objet dans une chaîne JSON de manière asynchrone, tandis que la JsonSerializer.DeserializeAsync méthode désérialise une chaîne JSON sur un objet de façon asynchrone. Ces méthodes retournent également un Task qui représente l’opération asynchrone.

L’exemple de code suivant montre comment créer des méthodes asynchrones qui sérialisent un objet C#, écrire la chaîne JSON dans un fichier, lire le contenu du fichier dans une chaîne et désérialiser la chaîne JSON dans un objet C# :

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);
    }
}

Dans cet exemple, la SaveAccountDataAsync méthode sérialise un Account objet dans une chaîne JSON et l’écrit dans un fichier de manière asynchrone. La méthode LoadAccountDataAsync lit la chaîne JSON à partir du fichier et la désérialise en un objet Account de façon asynchrone. La Main méthode montre comment appeler ces méthodes asynchrones à l’aide du await mot clé.

Cela permet à l’application d’effectuer des opérations d’E/S de fichier sans bloquer le thread principal, améliorant ainsi les performances et la réactivité. La Directory.CreateDirectory méthode est utilisée pour créer le répertoire s’il n’existe pas, ce qui garantit que le fichier peut être écrit correctement.

Résumé

Dans cette unité, vous avez appris à implémenter des opérations d’entrée et de sortie de fichier asynchrones en C#. Vous avez exploré l'utilisation des mots clés async et await pour créer des méthodes asynchrones afin de lire et écrire des fichiers. En utilisant ces techniques, vous pouvez améliorer les performances et la réactivité de vos applications lors de l’exécution d’opérations d’E/S de fichier.

Points clés

• Les opérations d’entrée et de sortie de fichier peuvent être effectuées de manière synchrone ou asynchrone en C#.
• Les E/S de fichier asynchrones améliorent les performances et la réactivité des applications.
• Les mots clés async et await sont utilisés pour créer des méthodes asynchrones dans les opérations d'entrée/sortie de fichiers.
• Les System.IO et System.Text.Json espaces de noms fournissent des classes et des méthodes pour effectuer des opérations d’E/S de fichier de manière asynchrone.
• La File classe et la JsonSerializer classe sont utilisées dans l’exemple fourni pour illustrer les opérations d’E/S de fichier asynchrones.