¿La mejor manera de leer un archivo grande en una matriz de bytes en C #?

Tengo un servidor web que leerá archivos binarios grandes (varios megabytes) en conjuntos de bytes. El servidor podría estar leyendo varios archivos al mismo tiempo (solicitudes de página diferentes), por lo que estoy buscando la forma más optimizada para hacerlo sin gravar demasiado la CPU. ¿El código a continuación es lo suficientemente bueno?

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

Simplemente reemplace todo con:

return File.ReadAllBytes(fileName);

Sin embargo, si usted está preocupado por el consumo de memoria, debe no leer todo el archivo en memoria a la vez a todos. Deberías hacer eso en trozos.

Podría argumentar que la respuesta aquí generalmente es "no". A menos que necesite absolutamente todos los datos a la vez, considere usar una StreamAPI basada en (o alguna variante de lector / iterador). Es decir especialmente importante cuando tiene múltiples operaciones paralelas (como lo sugiere la pregunta) para minimizar la carga del sistema y maximizar el rendimiento.

Por ejemplo, si está transmitiendo datos a una persona que llama:

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

Yo pensaría esto:

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

Su código se puede tener en cuenta para esto (en lugar 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;
} 

Tenga en cuenta el Integer.MaxValue: limitación de tamaño de archivo establecida por el método Read. En otras palabras, solo puedes leer un fragmento de 2GB a la vez.

También tenga en cuenta que el último argumento para FileStream es un tamaño de búfer.

También sugeriría leer sobre FileStream y BufferedStream .

Como siempre, un programa de muestra simple para perfilar que es el más rápido será el más beneficioso.

Además, su hardware subyacente tendrá un gran efecto en el rendimiento. ¿Está utilizando unidades de disco duro basadas en servidor con cachés grandes y una tarjeta RAID con memoria caché integrada? ¿O está utilizando una unidad estándar conectada al puerto IDE?

Dependiendo de la frecuencia de las operaciones, el tamaño de los archivos y la cantidad de archivos que está viendo, hay otros problemas de rendimiento a tener en cuenta. Una cosa para recordar es que cada una de sus matrices de bytes se liberará a merced del recolector de basura. Si no está almacenando en caché ninguno de esos datos, podría terminar creando mucha basura y perdiendo la mayor parte de su rendimiento por % de tiempo en GC. Si los fragmentos son más grandes que 85K, se asignará al Montón de objetos grandes (LOH) que requerirá una colección de todas las generaciones para liberarse (esto es muy costoso, y en un servidor detendrá toda ejecución mientras continúa) ) Además, si tiene una tonelada de objetos en el LOH, puede terminar con la fragmentación de LOH (el LOH nunca se compacta), lo que conduce a un rendimiento deficiente y excepciones de falta de memoria. Puede reciclar el proceso una vez que llegue a cierto punto, pero no sé si es una buena práctica.

El punto es que debe considerar el ciclo de vida completo de su aplicación antes de simplemente leer todos los bytes en la memoria de la manera más rápida posible o podría estar intercambiando el rendimiento a corto plazo por el rendimiento general.

Diría que BinaryReaderestá bien, pero se puede refactorizar a esto, en lugar de todas esas líneas de código para obtener la longitud del búfer:

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

Debería ser mejor que usar .ReadAllBytes(), ya que vi en los comentarios en la respuesta superior que incluye .ReadAllBytes()que uno de los comentaristas tuvo problemas con archivos> 600 MB, ya que BinaryReaderestá destinado a este tipo de cosas. Además, poniéndola en un usingcomunicado asegura que el FileStreamy BinaryReaderestán cerrados y eliminados.

En caso de que 'un archivo grande' signifique más allá del límite de 4 GB, entonces mi siguiente lógica de código escrito es apropiada. La cuestión clave a tener en cuenta es el tipo de datos LARGO utilizado con el método SEEK. Como LONG es capaz de apuntar más allá de 2 ^ 32 límites de datos. En este ejemplo, el código procesa procesando primero el archivo grande en fragmentos de 1 GB, después de que se procesan los fragmentos enteros grandes de 1 GB, se procesan los bytes restantes (<1 GB). Utilizo este código para calcular el CRC de archivos más allá del tamaño de 4 GB. (usando https://crc32c.machinezoo.com/ para el cálculo de crc32c en este ejemplo)

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 la clase BufferedStream en C # para mejorar el rendimiento. Un búfer es un bloque de bytes en la memoria que se usa para almacenar en caché los datos, lo que reduce la cantidad de llamadas al sistema operativo. Los buffers mejoran el rendimiento de lectura y escritura.

Consulte lo siguiente para ver un ejemplo de código y una explicación adicional: http://msdn.microsoft.com/en-us/library/system.io.bufferedstream.aspx

utilizar este:

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

Descripción general: si su imagen se agrega como un recurso acción = incrustado, use GetExecutingAssembly para recuperar el recurso jpg en una secuencia y luego lea los datos binarios de la secuencia en una 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;

    }

Recomiendo probar el Response.TransferFile()método a continuación, una Response.Flush()y Response.End()para servir a sus archivos de gran tamaño.

Si está tratando con archivos de más de 2 GB, encontrará que los métodos anteriores fallan.

Es mucho más fácil simplemente pasar la transmisión a MD5 y permitir que fragmente el archivo por usted:

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