Eu tenho que analisar um arquivo grande, então ao invés de fazer:

 string unparsedFile = myStreamReader.ReadToEnd(); // takes 4 seconds
 parse(unparsedFile); // takes another 4 seconds

Eu quero aproveitar os primeiros 4 segundos e tentar fazer as duas coisas ao mesmo tempo, fazendo algo como:

        while (true)
        {
            char[] buffer = new char[1024];

            var charsRead = sr.Read(buffer, 0, buffer.Length);

            if (charsRead < 1)
                break;

            if (charsRead != 1024)
            {
                Console.Write("Here");  // debuger stops here several times why?
            }

            addChunkToQueue(buffer); 
        }

aqui está a imagem do debuger: (eu adicioneiint counter para mostrar em qual iteração lemos menos de 1024 bytes)

Note que existem 643 caracteres lidos e não 1024. Na próxima iteração eu recebo:

Eu acho que devo ler 1024 bytes o tempo todo até chegar à última iteração onde os bytes reminiscentes são menores que 1024.

Então minha pergunta é Por que eu vou ler o número "aleatório" de caracteres como eu repetir o loop while?

Editar

Eu não sei com que tipo de fluxo estou lidando. Eu executo um processo como:

        ProcessStartInfo psi = new ProcessStartInfo("someExe.exe")
        {
            RedirectStandardError = true,
            RedirectStandardOutput = true,
            UseShellExecute = false,
            CreateNoWindow = true,
        };

        // execute command and return ouput of command
        using (var proc = new Process())
        {
            proc.StartInfo = psi;
            proc.Start();                               

            var output = proc.StandardOutput;  //  <------------- this is where I get the strem

            //if (string.IsNullOrEmpty(output))
            //output = proc.StandardError.ReadToEnd();

            return output;
        }
    }