StreamReader.Readline () est-il vraiment la méthode la plus rapide pour compter les lignes dans un fichier?

Non, il n'est pas. Point est - il matérialise les cordes, ce qui n'est pas nécessaire.

De les COMPTER, vous êtes beaucoup mieux d'ignorer la "chaîne" de la Partie et aller à la "ligne" de la Partie.

une LIGNE est une seriees d'octets se terminant par \r\n (13, 10 - CR LF) ou d'un autre marqueur.

Simplement courir sur les octets, dans un tampon de flux, de compter le nombre d'apparitions de votre marqueur de fin de ligne.

J'ai essayé plusieurs méthodes et testé leurs performances:

Celui qui lit un octet est environ 50% plus lent que les autres méthodes. Les autres méthodes sont tous de retour autour de la même quantité de temps. Vous pouvez essayer de créer des threads et le faire de manière asynchrone, si bien que vous êtes en attente pour une lecture, vous pouvez commencer le traitement d'une précédente lecture. Cela ressemble à un casse-tête pour moi.

Je voudrais aller avec l'un liner: File.ReadLines(filePath).Count(); il effectue en tant que bien que les autres méthodes que j'ai testé.

        private static int countFileLines(string filePath)
{
using (StreamReader r = new StreamReader(filePath))
{
int i = 0;
while (r.ReadLine() != null)
{
i++;
}
return i;
}
}
private static int countFileLines2(string filePath)
{
using (Stream s = new FileStream(filePath, FileMode.Open))
{
int i = 0;
int b;
b = s.ReadByte();
while (b >= 0)
{
if (b == 10)
{
i++;
}
b = s.ReadByte();
}
return i + 1;
}
}
private static int countFileLines3(string filePath)
{
using (Stream s = new FileStream(filePath, FileMode.Open))
{
int i = 0;
byte[] b = new byte[bufferSize];
int n = 0;
n = s.Read(b, 0, bufferSize);
while (n > 0)
{
i += countByteLines(b, n);
n = s.Read(b, 0, bufferSize);
}
return i + 1;
}
}
private static int countByteLines(byte[] b, int n)
{
int i = 0;
for (int j = 0; j < n; j++)
{
if (b[j] == 10)
{
i++;
}
}
return i;
}
private static int countFileLines4(string filePath)
{
return File.ReadLines(filePath).Count();
}

Oui, la lecture des lignes comme ça, c'est la manière la plus rapide et la plus simple façon dans toute l'acception du terme.

Il n'y a pas de raccourcis ici. Les fichiers ne sont pas de la ligne de base, de sorte que vous devez lire chaque octet du fichier à déterminer le nombre de lignes.

Que TomTom a souligné, la création de chaînes n'est pas strictement nécessaire de compter les lignes, mais une grande majorité du temps passé sera en attente pour la lecture des données à partir du disque. L'écriture d'un beaucoup plus compliqué algorithme serait peut-être raser un pour cent du temps d'exécution, et il permettrait d'améliorer considérablement le temps pour écrire et tester le code.

StreamReader n'est pas le moyen le plus rapide pour lire les fichiers en général en raison de la faible surcharge de codage des octets de caractères, de sorte que la lecture du fichier dans un tableau d'octets est plus rapide.

Les résultats que j'obtiens sont un peu différentes à chaque fois en raison de la mise en cache et d'autres processus, mais ici, c'est l'un des résultats que j'ai obtenu (en millisecondes) avec 16 MO de fichier :

75 ReadLines 
82 ReadLine 
22 ReadAllBytes 
23 Read 32K 
21 Read 64K 
27 Read 128K 

En général File.ReadLines devrait être un peu plus lent qu'un StreamReader.ReadLine boucle.
File.ReadAllBytes est plus lent avec des fichiers plus gros et vont se jeter hors de la mémoire d'exception avec de gros fichiers.
La taille par défaut du tampon pour FileStream est 4K, mais sur ma machine 64 KO semblait le plus rapide.

    private static int countWithReadLines(string filePath)
{
int count = 0;
var lines = File.ReadLines(filePath);
foreach (var line in lines) count++;
return count;
}
private static int countWithReadLine(string filePath)
{
int count = 0;
using (var sr = new StreamReader(filePath))      
while (sr.ReadLine() != null)
count++;
return count;
}
private static int countWithFileStream(string filePath, int bufferSize = 1024 * 4)
{
using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
int count = 0;
byte[] array = new byte[bufferSize];
while (true)
{
int length = fs.Read(array, 0, bufferSize);
for (int i = 0; i < length; i++)
if(array[i] == 10)
count++;
if (length < bufferSize) return count;
}
} //end of using
}

et testé avec:

var path = "1234567890.txt"; Stopwatch sw; string s = "";
File.WriteAllLines(path, Enumerable.Repeat("1234567890abcd", 1024 * 1024 )); //16MB (16 bytes per line)
sw = Stopwatch.StartNew(); countWithReadLines(path)   ; sw.Stop(); s += sw.ElapsedMilliseconds + " ReadLines \n";
sw = Stopwatch.StartNew(); countWithReadLine(path)    ; sw.Stop(); s += sw.ElapsedMilliseconds + " ReadLine \n";
sw = Stopwatch.StartNew(); countWithReadAllBytes(path); sw.Stop(); s += sw.ElapsedMilliseconds + " ReadAllBytes \n";
sw = Stopwatch.StartNew(); countWithFileStream(path, 1024 * 32); sw.Stop(); s += sw.ElapsedMilliseconds + " Read 32K \n";
sw = Stopwatch.StartNew(); countWithFileStream(path, 1024 * 64); sw.Stop(); s += sw.ElapsedMilliseconds + " Read 64K \n";
sw = Stopwatch.StartNew(); countWithFileStream(path, 1024 *128); sw.Stop(); s += sw.ElapsedMilliseconds + " Read 128K \n";
MessageBox.Show(s);