Qual é a maneira mais rápida de ler um arquivo de texto linha por linha?

Quero ler um arquivo de texto linha por linha. Eu queria saber se estou fazendo isso da maneira mais eficiente possível no escopo do .NET C #.

Isto é o que estou tentando até agora:

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
}

Para encontrar a maneira mais rápida de ler um arquivo linha por linha, você precisará fazer alguns testes comparativos. Fiz alguns pequenos testes no meu computador, mas você não pode esperar que meus resultados se apliquem ao seu ambiente.

Usando StreamReader.ReadLine

Este é basicamente o seu método. Por algum motivo, você define o tamanho do buffer para o menor valor possível (128). Aumentar isso geralmente aumentará o desempenho. O tamanho padrão é 1.024 e outras boas opções são 512 (o tamanho do setor no Windows) ou 4.096 (o tamanho do cluster no NTFS). Você precisará executar uma referência para determinar o tamanho ideal do buffer. Um buffer maior é - se não mais rápido - pelo menos não mais lento que um buffer menor.

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
  }

O FileStreamconstrutor permite especificar FileOptions . Por exemplo, se você estiver lendo um arquivo grande sequencialmente do começo ao fim, poderá se beneficiar FileOptions.SequentialScan. Novamente, o benchmarking é a melhor coisa que você pode fazer.

Usando File.ReadLines

Isso é muito parecido com sua própria solução, exceto que ela é implementada usando um StreamReadertamanho de buffer fixo de 1.024. No meu computador, isso resulta em um desempenho um pouco melhor comparado ao seu código com o tamanho do buffer de 128. No entanto, você pode obter o mesmo aumento de desempenho usando um tamanho de buffer maior. Este método é implementado usando um bloco iterador e não consome memória para todas as linhas.

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

Usando File.ReadAllLines

Isso é muito parecido com o método anterior, exceto que esse método aumenta uma lista de cadeias usadas para criar a matriz de linhas retornada, para que os requisitos de memória sejam maiores. No entanto, ele retorna String[]e não IEnumerable<String>permite que você acesse as linhas aleatoriamente.

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

Usando String.Split

Esse método é consideravelmente mais lento, pelo menos em arquivos grandes (testados em um arquivo de 511 KB), provavelmente devido à maneira como String.Splité implementado. Ele também aloca uma matriz para todas as linhas, aumentando a memória necessária em comparação com a sua solução.

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

Minha sugestão é usar File.ReadLinesporque é limpo e eficiente. Se você precisar de opções especiais de compartilhamento (por exemplo, use FileShare.ReadWrite), poderá usar seu próprio código, mas deverá aumentar o tamanho do buffer.

Se você estiver usando o .NET 4, basta usar o File.ReadLinesque faz tudo por você. Eu suspeito que é muito o mesmo que o seu, a não ser que também pode usar FileOptions.SequentialScane um buffer maior (128 parece muito pequena).

Embora File.ReadAllLines()seja uma das maneiras mais simples de ler um arquivo, também é uma das mais lentas.

Se você deseja apenas ler linhas em um arquivo sem fazer muito, de acordo com esses benchmarks , a maneira mais rápida de ler um arquivo é o antigo método de:

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

No entanto, se você precisar fazer muito com cada linha, este artigo conclui que a melhor maneira é a seguinte (e é mais rápido pré-alocar uma string [] se você souber quantas linhas vai ler):

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

Use o seguinte código:

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

Essa foi uma enorme diferença no desempenho da leitura.

Ele custa o consumo de memória, mas vale a pena!

Há um bom tópico sobre isso na pergunta Stack Overflow. O retorno do rendimento é mais lento que o retorno da "velha escola"? .

Diz:

ReadAllLines carrega todas as linhas na memória e retorna uma string []. Tudo bem se o arquivo for pequeno. Se o arquivo for maior do que caberá na memória, você ficará sem memória.

ReadLines, por outro lado, usa retorno de rendimento para retornar uma linha por vez. Com ele, você pode ler qualquer arquivo de tamanho. Não carrega o arquivo inteiro na memória.

Digamos que você queira encontrar a primeira linha que contém a palavra "foo" e saia. Usando ReadAllLines, você teria que ler o arquivo inteiro na memória, mesmo que "foo" ocorra na primeira linha. Com o ReadLines, você lê apenas uma linha. Qual seria o mais rápido?

Se o tamanho do arquivo não for grande, será mais rápido ler o arquivo inteiro e dividi-lo depois

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

Se você tiver memória suficiente, encontrei alguns ganhos de desempenho lendo o arquivo inteiro em um fluxo de memória e abrindo um leitor de fluxo para ler as linhas. Contanto que você realmente planeje ler o arquivo inteiro de qualquer maneira, isso poderá gerar algumas melhorias.

Você não pode ficar mais rápido se quiser usar uma API existente para ler as linhas. Mas ler pedaços maiores e encontrar manualmente cada nova linha no buffer de leitura provavelmente seria mais rápido.