¿Cuál es la forma más rápida de crear una suma de verificación para archivos grandes en C #?

Tengo que sincronizar archivos grandes en algunas máquinas. Los archivos pueden tener hasta 6 GB de tamaño. La sincronización se realizará manualmente cada pocas semanas. No puedo tomar en cuenta el nombre del archivo porque pueden cambiar en cualquier momento.

Mi plan es crear sumas de verificación en la PC de destino y en la PC de origen y luego copiar todos los archivos con una suma de verificación, que aún no están en el destino, al destino. Mi primer intento fue algo como esto:

using System.IO;
using System.Security.Cryptography;

private static string GetChecksum(string file)
{
    using (FileStream stream = File.OpenRead(file))
    {
        SHA256Managed sha = new SHA256Managed();
        byte[] checksum = sha.ComputeHash(stream);
        return BitConverter.ToString(checksum).Replace("-", String.Empty);
    }
}

El problema fue el tiempo de ejecución:
- con SHA256 con un archivo de 1,6 GB -> 20 minutos
- con MD5 con un archivo de 1,6 GB -> 6,15 minutos

¿Existe una forma mejor, más rápida, de obtener la suma de comprobación (tal vez con una mejor función hash)?

El problema aquí es que SHA256Managedlee 4096 bytes a la vez (hereda FileStreamy anula Read(byte[], int, int)para ver cuánto lee del flujo de archivos), que es un búfer demasiado pequeño para el disco IO.

Para acelerar las cosas (2 minutos para hash de archivo de 2 GB en mi máquina con SHA256, 1 minuto para MD5) envoltura FileStreamen BufferedStreamy configurar el tamaño de búfer de tamaño razonable (probé con tampón ~ 1 Mb):

// Not sure if BufferedStream should be wrapped in using block
using(var stream = new BufferedStream(File.OpenRead(filePath), 1200000))
{
    // The rest remains the same
}

No realice una suma de comprobación de todo el archivo, cree sumas de comprobación cada 100 MB aproximadamente, de modo que cada archivo tenga una colección de sumas de comprobación.

Luego, al comparar sumas de verificación, puede dejar de comparar después de la primera suma de verificación diferente, salir temprano y evitar que procese todo el archivo.

Todavía tomará el tiempo completo para archivos idénticos.

Como señaló Anton Gogolev , FileStream lee 4096 bytes a la vez de forma predeterminada, pero puede especificar cualquier otro valor utilizando el constructor FileStream:

new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 16 * 1024 * 1024)

Tenga en cuenta que Brad Abrams de Microsoft escribió en 2004:

no hay ningún beneficio en envolver un BufferedStream alrededor de un FileStream. Copiamos la lógica de almacenamiento en búfer de BufferedStream en FileStream hace aproximadamente 4 años para fomentar un mejor rendimiento predeterminado

fuente

Invoque el puerto de Windows de md5sum.exe . Es aproximadamente dos veces más rápido que la implementación de .NET (al menos en mi máquina usando un archivo de 1.2 GB)

public static string Md5SumByProcess(string file) {
    var p = new Process ();
    p.StartInfo.FileName = "md5sum.exe";
    p.StartInfo.Arguments = file;            
    p.StartInfo.UseShellExecute = false;
    p.StartInfo.RedirectStandardOutput = true;
    p.Start();
    p.WaitForExit();           
    string output = p.StandardOutput.ReadToEnd();
    return output.Split(' ')[0].Substring(1).ToUpper ();
}

Ok, gracias a todos ustedes, déjenme terminar esto:

1. El uso de un exe "nativo" para hacer el hashing tomó tiempo de 6 minutos a 10 segundos, lo cual es enorme.
2. El aumento del búfer fue aún más rápido: el archivo de 1.6GB tardó 5.2 segundos usando MD5 en .Net, así que iré con esta solución, gracias de nuevo

Hice pruebas con el tamaño del búfer, ejecuté este código

using (var stream = new BufferedStream(File.OpenRead(file), bufferSize))
{
    SHA256Managed sha = new SHA256Managed();
    byte[] checksum = sha.ComputeHash(stream);
    return BitConverter.ToString(checksum).Replace("-", String.Empty).ToLower();
}

Y probé con un archivo de 29½ GB de tamaño, los resultados fueron

• 10.000: 369,24s
• 100.000: 362,55s
• 1.000.000: 361,53s
• 10.000.000: 434,15s
• 100.000.000: 435,15s
• 1.000.000.000: 434,31s
• Y 376,22s cuando se usa el código original, ninguno almacenado.

Estoy ejecutando una CPU i5 2500K, 12 GB de RAM y una unidad SSD OCZ Vertex 4 de 256 GB.

Entonces pensé, ¿qué pasa con un disco duro estándar de 2TB? Y los resultados fueron así

• 10.000: 368,52s
• 100.000: 364,15s
• 1.000.000: 363,06s
• 10.000.000: 678,96s
• 100.000.000: 617,89s
• 1.000.000.000: 626,86s
• Y para ninguno amortiguado 368,24

Por lo tanto, recomendaría sin búfer o un búfer de máximo 1 mill.

Estás haciendo algo mal (probablemente un búfer de lectura demasiado pequeño). En una máquina de edad indecente (Athlon 2x1800MP de 2002) que tiene DMA en el disco probablemente fuera de control (6.6M / s es muy lento cuando se hacen lecturas secuenciales):

Cree un archivo 1G con datos "aleatorios":

# dd if=/dev/sdb of=temp.dat bs=1M count=1024    
1073741824 bytes (1.1 GB) copied, 161.698 s, 6.6 MB/s

# time sha1sum -b temp.dat
abb88a0081f5db999d0701de2117d2cb21d192a2 *temp.dat

1m5.299s

# time md5sum -b temp.dat
9995e1c1a704f9c1eb6ca11e7ecb7276 *temp.dat

1m58.832s

Esto también es extraño, md5 es consistentemente más lento que sha1 para mí (reran varias veces).

Sé que llego tarde a la fiesta pero realicé una prueba antes de implementar la solución.

Realicé la prueba contra la clase MD5 incorporada y también md5sum.exe . En mi caso, la clase incorporada tomó 13 segundos, donde md5sum.exe también alrededor de 16-18 segundos en cada ejecución.

    DateTime current = DateTime.Now;
    string file = @"C:\text.iso";//It's 2.5 Gb file
    string output;
    using (var md5 = MD5.Create())
    {
        using (var stream = File.OpenRead(file))
        {
            byte[] checksum = md5.ComputeHash(stream);
            output = BitConverter.ToString(checksum).Replace("-", String.Empty).ToLower();
            Console.WriteLine("Total seconds : " + (DateTime.Now - current).TotalSeconds.ToString() + " " + output);
        }
    }

Puede echar un vistazo a XxHash.Net ( https://github.com/wilhelmliao/xxHash.NET )
El algoritmo xxHash parece ser más rápido que todos los demás.
Algunos puntos de referencia en el sitio xxHash: https://github.com/Cyan4973/xxHash

PD: aún no lo he usado.