Comment lire un grand fichier txt (1 Go) en .NET ?

Question

J'ai un fichier texte de 1 Go que je dois lire ligne par ligne. Quelle est la meilleure et la plus rapide façon de le faire ?

private void ReadTxtFile()
{            
    string filePath = string.Empty;
    filePath = openFileDialog1.FileName;
    if (string.IsNullOrEmpty(filePath))
    {
        using (StreamReader sr = new StreamReader(filePath))
        {
            String line;
            while ((line = sr.ReadLine()) != null)
            {
                FormatData(line);                        
            }
        }
    }
}

Sur FormatData() Je vérifie le mot de départ de la ligne qui doit correspondre à un mot et, en fonction de cela, j'incrémente une variable entière.

void FormatData(string line)
{
    if (line.StartWith(word))
    {
        globalIntVariable++;
    }
}

Answer 1

Si vous utilisez .NET 4.0, essayez Fichier en mémoire qui est une classe conçue pour ce scénario.

Vous pouvez utiliser StreamReader.ReadLine autrement.

Answer 2

L'utilisation de StreamReader est probablement la meilleure solution puisque vous ne voulez pas avoir tout le fichier en mémoire en même temps. MemoryMappedFile est plus destiné à l'accès aléatoire qu'à la lecture séquentielle (il est dix fois plus rapide pour la lecture séquentielle et le mappage de la mémoire est dix fois plus rapide pour l'accès aléatoire).

Vous pouvez également essayer de créer votre lecteur de flux à partir d'un flux de données avec FileOptions défini sur SequentialScan ( http://msdn.microsoft.com/en-us/library/system.io.fileoptions.aspx ) mais je doute que cela fasse une grande différence.

Il y a cependant des moyens de rendre votre exemple plus efficace, puisque vous effectuez votre formatage dans la même boucle que la lecture, vous gaspillez des cycles d'horloge. Si vous voulez encore plus de performances, il serait préférable d'utiliser une solution asynchrone multithread où un thread lit les données et un autre les formate dès qu'elles sont disponibles. Consultez BlockingColletion qui pourrait répondre à vos besoins :

http://blogs.msdn.com/b/csharpfaq/archive/2010/08/12/blocking-collection-and-the-producer-consumer-problem.aspx

Si vous voulez obtenir les performances les plus rapides possibles, d'après mon expérience, le seul moyen est de lire séquentiellement un gros morceau de données binaires et de le désérialiser en texte en parallèle, mais le code commence à se compliquer à ce stade.

Answer 3

Vous pouvez utiliser LINQ :

int result = File.ReadLines(filePath).Count(line => line.StartsWith(word));

Fichier.LireLignes renvoie un IEnumerable<String> qui lit paresseusement chaque ligne du fichier sans charger le fichier entier en mémoire.

Enumerable.Count compte les lignes qui commencent par ce mot.

Si vous appelez cette fonction à partir d'un thread de l'interface utilisateur, utilisez une balise Travailleur d'arrière-plan .

Answer 4

Probablement pour le lire ligne par ligne.

Il est préférable de ne pas essayer de le forcer à se mémoriser en le lisant jusqu'au bout puis en le traitant.

Answer 5

StreamReader.ReadLine devrait fonctionner correctement. Laissez le framework choisir la mise en mémoire tampon, sauf si vous savez, grâce au profilage, que vous pouvez faire mieux.