StreamReader. Readline () действительно самый быстрый метод, чтобы посчитать линии в файле?

Лучший способ знать, как сделать это быстро, состоит в том, чтобы думать о самом быстром способе сделать это, не используя C/C++.

На собрании есть операция по уровню процессоров, которая просматривает память для характера так на собрании, вы сделали бы следующее

• Рид большая часть (или все) файла в память
• Выполняет команду SCASB
• Повторение по мере необходимости

Так, в C# вы хотите, чтобы компилятор добрался максимально близко к этому.

Я попробовал многочисленные методы и проверил их работу:

Тот, который читает единственный байт, приблизительно на 50% медленнее, чем другие методы. Другие методы все возвращение вокруг того же самого количества времени. Вы могли попытаться создать нити и сделать это асинхронно, поэтому в то время как вы ждете прочитанного, можно начать обрабатывать прочитанное предыдущее. Это походит на головную боль мне.

Я пошел бы с одним лайнером: Файл. ReadLines (filePath).Count (); это выступает, а также другие методы, которые я проверил.

        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();
        }

Да, чтение линий как этот является самым быстрым и самым легким путем в любом практическом смысле.

Здесь нет никаких коротких путей. Файлы не базирующаяся линия, таким образом, необходимо прочитать каждый байт от файла, чтобы определить сколько линий, там.

Как TomTom указал, создание последовательностей не строго необходимо, чтобы посчитать линии, но подавляющее большинство проведенного времени будет ждать данных, которые будут прочитаны из диска. Написание намного более сложного алгоритма, возможно, сбрило бы процент времени выполнения, и это существенно увеличит время для написания и тестирования кода.

public static int CountLines(Stream stm)
{
    StreamReader _reader = new StreamReader(stm);
    int c = 0, count = 0;
    while ((c = _reader.Read()) != -1)
    {
        if (c == '\n')
        {
            count++;
        }
    }
    return count;
}

Есть многочисленные способы прочитать файл. Обычно, , самые быстрые путь, являются самыми простыми:

using (StreamReader sr = File.OpenText(fileName))
{
        string s = String.Empty;
        while ((s = sr.ReadLine()) != null)
        {
               //do what you gotta do here
        }
}

This page does a great performance comparison between several different techniques including using BufferedReaders, reading into StringBuilder objects, and into an entire array.

StreamReader is not the fastest way to read files in general because of the small overhead from encoding the bytes to characters, so reading the file in a byte array is faster.
The results I get are a bit different each time due to caching and other processes, but here is one of the results I got (in milliseconds) with a 16 MB file :

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

В общем Файл. ReadLines должен быть немного медленнее, чем StreamReader. ReadLine петля. Файл. ReadAllBytes медленнее с большими файлами и бросит из исключения памяти с огромными файлами. Размер буфера по умолчанию для , FileStream является 4K, но на моей машине 64K, казался самым быстрым.

    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
    }

и проверенный с:

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);