Quel est le moyen le plus rapide de lire un fichier texte ligne par ligne ?

Question

Je veux lire un fichier texte ligne par ligne. Je voulais savoir si je le faisais aussi efficacement que possible dans le cadre de .NET C#.

C'est ce que j'ai essayé jusqu'à présent :

var filestream = new System.IO.FileStream(textFilePath,
                                          System.IO.FileMode.Open,
                                          System.IO.FileAccess.Read,
                                          System.IO.FileShare.ReadWrite);
var file = new System.IO.StreamReader(filestream, System.Text.Encoding.UTF8, true, 128);

while ((lineOfText = file.ReadLine()) != null)
{
    //Do something with the lineOfText
}

Answer 1

Pour trouver le moyen le plus rapide de lire un fichier ligne par ligne, vous devrez procéder à une analyse comparative. J'ai fait quelques petits tests sur mon ordinateur mais vous ne pouvez pas vous attendre à ce que mes résultats s'appliquent à votre environnement.

Utilisation de StreamReader.ReadLine

C'est en gros votre méthode. Pour une raison quelconque, vous avez fixé la taille du tampon à la plus petite valeur possible (128). Augmenter cette valeur permet en général d'améliorer les performances. La taille par défaut est de 1 024 et d'autres bons choix sont 512 (la taille du secteur dans Windows) ou 4 096 (la taille du cluster dans NTFS). Vous devrez exécuter un benchmark pour déterminer la taille optimale de la mémoire tampon. Un tampon plus grand est, sinon plus rapide, du moins moins moins lent qu'un tampon plus petit.

const Int32 BufferSize = 128;
using (var fileStream = File.OpenRead(fileName))
  using (var streamReader = new StreamReader(fileStream, Encoding.UTF8, true, BufferSize)) {
    String line;
    while ((line = streamReader.ReadLine()) != null)
      // Process line
  }

Le site FileStream vous permet de spécifier Options de fichier . Par exemple, si vous lisez un fichier volumineux de manière séquentielle du début à la fin, vous pouvez bénéficier des avantages suivants FileOptions.SequentialScan . Encore une fois, l'analyse comparative est la meilleure chose que vous puissiez faire.

Utilisation de File.ReadLines

Cette solution est très proche de la vôtre, sauf qu'elle est mise en œuvre à l'aide d'une StreamReader avec une taille de tampon fixe de 1 024. Sur mon ordinateur, les performances sont légèrement meilleures que celles de votre code avec une taille de tampon de 128. Cependant, vous pouvez obtenir la même augmentation des performances en utilisant une taille de tampon plus importante. Cette méthode est mise en œuvre en utilisant un bloc d'itérateurs et ne consomme pas de mémoire pour toutes les lignes.

var lines = File.ReadLines(fileName);
foreach (var line in lines)
  // Process line

Utilisation de File.ReadAllLines

Cette méthode ressemble beaucoup à la précédente, sauf qu'elle développe une liste de chaînes de caractères utilisée pour créer le tableau de lignes retourné, ce qui nécessite plus de mémoire. Cependant, elle renvoie String[] et non un IEnumerable<String> vous permettant d'accéder aux lignes de manière aléatoire.

var lines = File.ReadAllLines(fileName);
for (var i = 0; i < lines.Length; i += 1) {
  var line = lines[i];
  // Process line
}

Utilisation de String.Split

Cette méthode est considérablement plus lente, du moins pour les gros fichiers (testée sur un fichier de 511 Ko), probablement en raison de la façon dont les fichiers sont traités. String.Split est mis en œuvre. Il alloue également un tableau pour toutes les lignes, ce qui augmente la mémoire requise par rapport à votre solution.

using (var streamReader = File.OpenText(fileName)) {
  var lines = streamReader.ReadToEnd().Split("\r\n".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
  foreach (var line in lines)
    // Process line
}

Ma suggestion est d'utiliser File.ReadLines parce qu'il est propre et efficace. Si vous avez besoin d'options de partage spéciales (par exemple vous utilisez FileShare.ReadWrite ), vous pouvez utiliser votre propre code mais vous devez augmenter la taille du tampon.

Answer 2

Si vous utilisez .NET 4, utilisez simplement File.ReadLines qui fait tout pour vous. Je pense que c'est beaucoup le même que le vôtre, sauf qu'il peut aussi utiliser FileOptions.SequentialScan et un tampon plus grand (128 semble très petit).

Answer 3

Alors que File.ReadAllLines() est l'une des façons les plus simples de lire un fichier, c'est aussi l'une des plus lentes.

Si vous voulez juste lire des lignes dans un fichier sans faire grand-chose, selon ces critères de référence Pour lire un fichier, le moyen le plus rapide est la vieille méthode :

using (StreamReader sr = File.OpenText(fileName))
{
        string s = String.Empty;
        while ((s = sr.ReadLine()) != null)
        {
               //do minimal amount of work here
        }
}

Cependant, si vous devez faire beaucoup de choses avec chaque ligne, alors cet article conclut que la meilleure méthode est la suivante (et il est plus rapide de pré-allouer une chaîne[] si vous savez combien de lignes vous allez lire) :

AllLines = new string[MAX]; //only allocate memory here

using (StreamReader sr = File.OpenText(fileName))
{
        int x = 0;
        while (!sr.EndOfStream)
        {
               AllLines[x] = sr.ReadLine();
               x += 1;
        }
} //Finished. Close the file

//Now parallel process each line in the file
Parallel.For(0, AllLines.Length, x =>
{
    DoYourStuff(AllLines[x]); //do your work here
});

Answer 4

Si vous disposez de suffisamment de mémoire, j'ai constaté des gains de performance en lisant le fichier entier dans un fichier de type flux de mémoire et ensuite ouvrir un lecteur de flux sur celui-ci pour lire les lignes. Tant que vous prévoyez de lire l'ensemble du fichier, cela peut apporter quelques améliorations.

Answer 5

Si vous visez la vitesse d'exécution, oui, vous le faites. Le code pourrait être plus court en utilisant le constructeur de StreamReader.