Accès aux fichiers de manière asynchrone avec C#

le 16 novembre 2022

L’asynchronisme permet d’améliorer la réactivité d’une application. En effet, lors de l’exécution du traitement asynchrone le thread principal de notre application n’est pas bloqué. On peut ainsi lancer plusieurs traitements en parallèle. On peut par exemple écrire/lire dans un fichier , faire des requêtes http, des appels d’API, accéder à une base de donnée sans faire attendre le thread principal.
C’est particulièrement utile dans les applications avec une IHM. Un traitement peut s’effectuer en arrière plan sans « figer » notre application.

Dans cet article, je vous explique comment lire ou écrire dans des fichiers de manière asynchrone en C#.

Lecture asynchrone

Les méthodes ReadAsync permettent de lire une séquence d’octet dans un fichier de manière asynchrone. Ces méthodes récupèrent les données dans le fichier sans bloquer le thread principal.
Elles renvoient le nombre total d’octets lu. ReadAsync lit une séquences d’octets du flux courant et avance dans le flux.

using System.IO;

string url = "https://osdn.net/frs/redir.php?m=nchc&f=android-x86%2F69704%2Fandroid-x86-8.1-r6.iso";

const int BUFFER_SIZE = 1024;
string outputFileName = @"D:\out.iso";
long currentNbBytes = 0;

HttpClient client = new HttpClient();

using (FileStream dest = File.Open(outputFileName, FileMode.OpenOrCreate))
using (var source = client.GetStreamAsync(url))
{
    var buffer = new byte[BUFFER_SIZE];
    int nbBytesRead;

    while ((nbBytesRead = await source.Result.ReadAsync(buffer, 0, buffer.Length)) > 0)
    {
        dest.Write(buffer, 0, nbBytesRead);
        currentNbBytes += nbBytesRead;

        Console.WriteLine($"{currentNbBytes} bytes read");
    }
}

Dans le code ci-dessus, on lit un fichier à partir d’une adresse http en utilisant ReadAsync et on l’écrit dans un fichier local.

Ecriture asynchrone

WriteAsync permet d’écrire une séquence d’octets de manière asynchrone dans un flux. Avec ces méthodes, l’écriture dans un fichier ne bloque pas le thread principal.

string myLongText = @"jkhjkdsjskndlvjdknflvs,ndjdnkvlmdbj,kdsnbjsdbvsdbsdbnsdjsqhuhctzzopaksn,kx,kajkclafjhifggfiaejufeyfuebfhabejcnajebvahjebjvbehvhagevbevbehbvebvjebvhaz
zevueihgjehgfahzgiorjenhkqojbkfhvgqzehiorzjgkrlmeklhoituqzrhzeygzuzhazdzjvenk,ev,rknjbrnkrejhehjeigoaezkgzep^lbrgkrlbe;rlbnkjrnbkrbjzeioap^zpelvm:m;lv;anbchavfvazjfbea
hazfzjgbhazbgjzgkuzegizrgnzjiehgzljgnkrgnzr gkrznghzj rkgjkrzbghbeklgjzjkgbklgjlzekgnjeghezeg";

byte[] bytes = Encoding.ASCII.GetBytes(myLongText);

string filePath = @"d:\file.txt";

int currentPos = 0;
int BUFFERLENGHT = 8;

using(FileStream file = File.Open(filePath, FileMode.OpenOrCreate))    
{
    while(currentPos < bytes.Length)
    {
            file.Seek(currentPos,SeekOrigin.Begin);            

            file.WriteAsync(bytes);

        currentPos+=BUFFERLENGHT;

        Console.WriteLine($"{currentPos}/{bytes.Length}");
    }
}

Dans le code ci-dessus, on écrit un texte défini dans un fichier local en utilisant WriteAsync.

Autres méthodes

.NET propose d’autres méthodes de gestion de fichier avec C#: CopyToAsync, WriteAllTextAsync, ReadAllTextAsync…
On a par exemple CopyToAsync qui permet de copier un fichier vers un dossier de destination de manière asynchrone.

 using(FileStream sourceStream = File.Open(@"d:\mytext.txt", FileMode.Open))
{
    using(FileStream destinationStream = File.Create(@"d:\mytext_copy.txt"))
    {
        await sourceStream.CopyToAsync(destinationStream);
    }
}

WriteAllTextAsync permet d’écrire un texte dans un fichier.

static async Task Main(string[] args)
{
            string filePath = @"d:\mytext.txt";
            string text = $"Hello World";

            await File.WriteAllTextAsync(filePath, text);
}

ReadAllTextAsync permet de lire un texte d’un fichier.

string filePath = @"d:\mytext.txt";
string text = await File.ReadAllTextAsync(filePath);

Console.WriteLine(text);

Ces quelques exemples de code démontre qu’on peut facilement manipuler des fichiers de manière asynchrone avec C#.
Nos programmes pourront ainsi accéder aux fichiers et lancer d’autres tâches en parallèle.