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

Je veux lire un fichier texte ligne par ligne. Je voulais savoir si je le fais le plus efficacement possible dans le cadre des choses .NET C #.

Voici ce que j'essaie 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
}

Pour trouver le moyen le plus rapide de lire un fichier ligne par ligne, vous devrez effectuer 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 fondamentalement votre méthode. Pour une raison quelconque, vous définissez la taille du tampon sur la plus petite valeur possible (128). Augmenter cela augmentera généralement les performances. La taille par défaut est 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 une taille de tampon optimale. Un tampon plus gros n'est - sinon plus rapide - du moins pas plus 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 FileStreamconstructeur vous permet de spécifier FileOptions . Par exemple, si vous lisez un gros fichier séquentiellement du début à la fin, vous pouvez en bénéficier FileOptions.SequentialScan. Encore une fois, l'analyse comparative est la meilleure chose que vous puissiez faire.

Utilisation de File.ReadLines

Cela ressemble beaucoup à votre propre solution, sauf qu'elle est implémentée à l'aide d'un StreamReaderavec une taille de tampon fixe de 1 024. Sur mon ordinateur, cela entraîne des performances légèrement meilleures par rapport à votre code avec une taille de tampon de 128. Cependant, vous pouvez obtenir la même augmentation de performances en utilisant une taille de tampon plus grande. Cette méthode est implémentée à l'aide d'un bloc itérateur 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

Cela ressemble beaucoup à la méthode précédente, sauf que cette méthode développe une liste de chaînes utilisées pour créer le tableau de lignes renvoyé, de sorte que les besoins en mémoire sont plus élevés. Cependant, il revient String[]et ne IEnumerable<String>vous permet pas d'accéder au hasard aux lignes.

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, au moins sur les gros fichiers (testée sur un fichier de 511 Ko), probablement en raison de la façon dont elle String.Splitest implémentée. Il alloue également un tableau pour toutes les lignes, augmentant 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.ReadLinescar il est propre et efficace. Si vous avez besoin d'options de partage spéciales (par exemple que vous utilisez FileShare.ReadWrite), vous pouvez utiliser votre propre code mais vous devez augmenter la taille du tampon.

Si vous utilisez .NET 4, utilisez simplement File.ReadLinesqui fait tout pour vous. Je soupçonne qu'il est à peu près le même que le vôtre, sauf qu'il peut également utiliser FileOptions.SequentialScanet un tampon plus grand (128 semble très petit).

Bien que ce File.ReadAllLines()soit l'un des moyens les plus simples de lire un fichier, c'est aussi l'un des plus lents.

Si vous souhaitez simplement lire des lignes dans un fichier sans faire grand-chose, selon ces repères , le moyen le plus rapide de lire un fichier est la méthode séculaire de:

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 avec chaque ligne, cet article conclut que la meilleure façon 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
});

Utilisez le code suivant:

foreach (string line in File.ReadAllLines(fileName))

C'était une énorme différence dans les performances de lecture.

Cela se fait au détriment de la consommation de mémoire, mais ça vaut vraiment le coup!

Il y a un bon sujet à ce sujet dans la question de débordement de pile . .

Ça dit:

ReadAllLines charge toutes les lignes en mémoire et renvoie une chaîne []. Très bien si le fichier est petit. Si le fichier est plus volumineux que ce qui peut tenir en mémoire, vous manquerez de mémoire.

ReadLines, d'autre part, utilise return return pour renvoyer une ligne à la fois. Avec lui, vous pouvez lire n'importe quel fichier de taille. Il ne charge pas le fichier entier en mémoire.

Supposons que vous vouliez trouver la première ligne contenant le mot "foo", puis quittez. En utilisant ReadAllLines, vous devez lire l'intégralité du fichier en mémoire, même si "foo" apparaît sur la première ligne. Avec ReadLines, vous ne lisez qu'une seule ligne. Lequel serait le plus rapide?

Si la taille du fichier n'est pas grande, il est plus rapide de lire le fichier entier et de le diviser ensuite

var filestreams = sr.ReadToEnd().Split(Environment.NewLine, 
                              StringSplitOptions.RemoveEmptyEntries);

Si vous avez suffisamment de mémoire, j'ai trouvé des gains de performances en lisant le fichier entier dans un flux de mémoire , puis en ouvrant un lecteur de flux sur celui-ci pour lire les lignes. Tant que vous prévoyez de lire le fichier dans son intégralité, cela peut apporter quelques améliorations.

Vous ne pouvez pas aller plus vite si vous souhaitez utiliser une API existante pour lire les lignes. Mais lire des morceaux plus gros et trouver manuellement chaque nouvelle ligne dans le tampon de lecture serait probablement plus rapide.