Melhor maneira de ler um arquivo grande em uma matriz de bytes em c #?

Eu tenho um servidor web que lê grandes arquivos binários (vários megabytes) em matrizes de bytes. O servidor pode estar lendo vários arquivos ao mesmo tempo (solicitações de página diferentes), por isso estou procurando a maneira mais otimizada de fazer isso sem sobrecarregar demais a CPU. O código abaixo é bom o suficiente?

public byte[] FileToByteArray(string fileName)
{
    byte[] buff = null;
    FileStream fs = new FileStream(fileName, 
                                   FileMode.Open, 
                                   FileAccess.Read);
    BinaryReader br = new BinaryReader(fs);
    long numBytes = new FileInfo(fileName).Length;
    buff = br.ReadBytes((int) numBytes);
    return buff;
}

Simplesmente substitua a coisa toda por:

return File.ReadAllBytes(fileName);

No entanto, se você está preocupado com o consumo de memória, você deve não ler o arquivo inteiro na memória de uma só vez a todos. Você deve fazer isso em pedaços.

Eu poderia argumentar que a resposta aqui geralmente é "não". A menos que você precise absolutamente de todos os dados de uma vez, considere usar uma StreamAPI baseada em (ou alguma variante do leitor / iterador). Isso é especialmente importante quando você tem várias operações paralelas (conforme sugerido pela pergunta) para minimizar a carga do sistema e maximizar a taxa de transferência.

Por exemplo, se você estiver transmitindo dados para um chamador:

Stream dest = ...
using(Stream source = File.OpenRead(path)) {
    byte[] buffer = new byte[2048];
    int bytesRead;
    while((bytesRead = source.Read(buffer, 0, buffer.Length)) > 0) {
        dest.Write(buffer, 0, bytesRead);
    }
}

Eu pensaria o seguinte:

byte[] file = System.IO.File.ReadAllBytes(fileName);

Seu código pode ser fatorado para isso (em vez de File.ReadAllBytes):

public byte[] ReadAllBytes(string fileName)
{
    byte[] buffer = null;
    using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read))
    {
        buffer = new byte[fs.Length];
        fs.Read(buffer, 0, (int)fs.Length);
    }
    return buffer;
} 

Observe a limitação de tamanho de arquivo Integer.MaxValue colocada pelo método Read. Em outras palavras, você pode ler apenas um pedaço de 2 GB de uma vez.

Observe também que o último argumento para o FileStream é um tamanho de buffer.

Eu também sugeriria ler sobre o FileStream e BufferedStream .

Como sempre, um programa de amostra simples para definir o perfil mais rápido será mais benéfico.

Além disso, seu hardware subjacente terá um grande efeito no desempenho. Você está usando unidades de disco rígido baseadas em servidor com caches grandes e uma placa RAID com cache de memória integrado? Ou você está usando uma unidade padrão conectada à porta IDE?

Dependendo da frequência das operações, do tamanho dos arquivos e do número de arquivos que você está visualizando, há outros problemas de desempenho a serem considerados. Uma coisa a lembrar é que cada uma de suas matrizes de bytes será liberada à mercê do coletor de lixo. Se você não estiver armazenando em cache nenhum desses dados, poderá criar muito lixo e perder a maior parte do seu desempenho para % Time in GC. Se os pedaços forem maiores que 85K, você estará alocando para o Large Object Heap (LOH), que exigirá a liberação de uma coleção de todas as gerações (isso é muito caro e o servidor interromperá toda a execução enquanto estiver acontecendo) ) Além disso, se você tiver vários objetos no LOH, poderá acabar com a fragmentação do LOH (o LOH nunca é compactado), o que leva a um desempenho ruim e a exceções de falta de memória. Você pode reciclar o processo depois de atingir um determinado ponto, mas não sei se essa é uma prática recomendada.

O ponto é que você deve considerar o ciclo de vida completo do seu aplicativo antes de necessariamente ler todos os bytes na memória da maneira mais rápida possível ou pode estar trocando desempenho de curto prazo pelo desempenho geral.

Eu diria que BinaryReaderestá bem, mas pode ser refatorado para isso, em vez de todas essas linhas de código para obter o comprimento do buffer:

public byte[] FileToByteArray(string fileName)
{
    byte[] fileData = null;

    using (FileStream fs = File.OpenRead(fileName)) 
    { 
        using (BinaryReader binaryReader = new BinaryReader(fs))
        {
            fileData = binaryReader.ReadBytes((int)fs.Length); 
        }
    }
    return fileData;
}

Deveria ser melhor do que usar .ReadAllBytes(), já que vi nos comentários a resposta principal que inclui .ReadAllBytes()que um dos comentaristas teve problemas com arquivos> 600 MB, já que a BinaryReaderdestina-se a esse tipo de coisa. Além disso, colocando-o em uma usingdeclaração assegura a FileStreame BinaryReaderestá fechado e descartado.

No caso de "um arquivo grande", além do limite de 4 GB, minha lógica de código escrita a seguir é apropriada. O principal problema a ser observado é o tipo de dados LONG usado com o método SEEK. Como um LONG, é capaz de apontar além de 2 ^ 32 limites de dados. Neste exemplo, o código está processando primeiro o processamento do arquivo grande em pedaços de 1 GB, depois que os pedaços grandes de 1 GB são processados, os bytes restantes (<1 GB) são processados. Eu uso esse código para calcular o CRC de arquivos além do tamanho de 4 GB. (usando https://crc32c.machinezoo.com/ para o cálculo crc32c neste exemplo)

private uint Crc32CAlgorithmBigCrc(string fileName)
{
    uint hash = 0;
    byte[] buffer = null;
    FileInfo fileInfo = new FileInfo(fileName);
    long fileLength = fileInfo.Length;
    int blockSize = 1024000000;
    decimal div = fileLength / blockSize;
    int blocks = (int)Math.Floor(div);
    int restBytes = (int)(fileLength - (blocks * blockSize));
    long offsetFile = 0;
    uint interHash = 0;
    Crc32CAlgorithm Crc32CAlgorithm = new Crc32CAlgorithm();
    bool firstBlock = true;
    using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read))
    {
        buffer = new byte[blockSize];
        using (BinaryReader br = new BinaryReader(fs))
        {
            while (blocks > 0)
            {
                blocks -= 1;
                fs.Seek(offsetFile, SeekOrigin.Begin);
                buffer = br.ReadBytes(blockSize);
                if (firstBlock)
                {
                    firstBlock = false;
                    interHash = Crc32CAlgorithm.Compute(buffer);
                    hash = interHash;
                }
                else
                {
                    hash = Crc32CAlgorithm.Append(interHash, buffer);
                }
                offsetFile += blockSize;
            }
            if (restBytes > 0)
            {
                Array.Resize(ref buffer, restBytes);
                fs.Seek(offsetFile, SeekOrigin.Begin);
                buffer = br.ReadBytes(restBytes);
                hash = Crc32CAlgorithm.Append(interHash, buffer);
            }
            buffer = null;
        }
    }
    //MessageBox.Show(hash.ToString());
    //MessageBox.Show(hash.ToString("X"));
    return hash;
}

Use a classe BufferedStream em C # para melhorar o desempenho. Um buffer é um bloco de bytes na memória usado para armazenar dados em cache, reduzindo assim o número de chamadas para o sistema operacional. Os buffers melhoram o desempenho de leitura e gravação.

Consulte o seguinte para obter um exemplo de código e explicação adicional: http://msdn.microsoft.com/en-us/library/system.io.bufferedstream.aspx

usa isto:

 bytesRead = responseStream.ReadAsync(buffer, 0, Length).Result;

Visão geral: se sua imagem for adicionada como um recurso action = incorporado, use o GetExecutingAssembly para recuperar o recurso jpg em um fluxo e leia os dados binários no fluxo em uma matriz de bytes

   public byte[] GetAImage()
    {
        byte[] bytes=null;
        var assembly = Assembly.GetExecutingAssembly();
        var resourceName = "MYWebApi.Images.X_my_image.jpg";

        using (Stream stream = assembly.GetManifestResourceStream(resourceName))
        {
            bytes = new byte[stream.Length];
            stream.Read(bytes, 0, (int)stream.Length);
        }
        return bytes;

    }

Eu recomendaria tentar o Response.TransferFile()método, em seguida, um Response.Flush()e Response.End()para servir seus arquivos grandes.

Se você estiver lidando com arquivos acima de 2 GB, verá que os métodos acima falham.

É muito mais fácil enviar o fluxo para o MD5 e permitir que você divida seu arquivo para você:

private byte[] computeFileHash(string filename)
{
    MD5 md5 = MD5.Create();
    using (FileStream fs = new FileStream(filename, FileMode.Open))
    {
        byte[] hash = md5.ComputeHash(fs);
        return hash;
    }
}