Comparar archivos binarios en C#

Question

Quiero comparar dos archivos binarios. Uno de ellos ya está almacenado en el servidor con un CRC32 precalculado en la base de datos desde que lo almacené originalmente.

Sé que si el CRC es diferente, entonces los archivos son definitivamente diferentes. Sin embargo, si el CRC es el mismo, no sé si los archivos sí lo están. Por lo tanto, estoy buscando una manera agradable y eficiente de comparar las dos corrientes: una del archivo publicado y otra del sistema de archivos.

No soy un experto en transmisiones, pero soy consciente de que podría dispararme fácilmente en el pie aquí en lo que respecta al uso de la memoria.

Answer 1

static bool FileEquals(string fileName1, string fileName2) 
{ 
    // Check the file size and CRC equality here.. if they are equal...  
    using (var file1 = new FileStream(fileName1, FileMode.Open)) 
     using (var file2 = new FileStream(fileName2, FileMode.Open)) 
      return FileStreamEquals(file1, file2); 
} 

static bool FileStreamEquals(Stream stream1, Stream stream2) 
{ 
    const int bufferSize = 2048; 
    byte[] buffer1 = new byte[bufferSize]; //buffer size 
    byte[] buffer2 = new byte[bufferSize]; 
    while (true) { 
     int count1 = stream1.Read(buffer1, 0, bufferSize); 
     int count2 = stream2.Read(buffer2, 0, bufferSize); 

     if (count1 != count2) 
      return false; 

     if (count1 == 0) 
      return true; 

     // You might replace the following with an efficient "memcmp" 
     if (!buffer1.Take(count1).SequenceEqual(buffer2.Take(count2))) 
      return false; 
    } 
} 

Answer 2

si cambia que el CCR a una firma SHA1 las posibilidades de que sea diferente pero con la misma firma son astronomicly pequeña

Answer 3

Puede comprobar la duración y las fechas de los dos archivos, incluso antes de comprobar el CRC, para evitar posiblemente la verificación CRC.

Pero si tiene que comparar todo el contenido del archivo, un buen truco que he visto es leer los bytes en pasos iguales al bitness de la CPU. Por ejemplo, en una PC de 32 bits, lea 4 bytes a la vez y compárelos como int32. En una PC de 64 bits puedes leer 8 bytes a la vez. Esto es aproximadamente 4 u 8 veces más rápido que hacerlo byte a byte. También es probable que desee utilizar un bloque de código inseguro para que pueda utilizar punteros en lugar de hacer un montón de cambios de bit y OR para obtener los bytes en los tamaños int nativos.

Puede usar IntPtr.Size para determinar el tamaño ideal para la arquitectura del procesador actual.

Answer 4

Aceleré el "memcmp" utilizando una comparación Int64 en un bucle sobre los fragmentos de flujo de lectura. Esto redujo el tiempo a aproximadamente 1/4.

private static bool StreamsContentsAreEqual(Stream stream1, Stream stream2) 
    { 
     const int bufferSize = 2048 * 2; 
     var buffer1 = new byte[bufferSize]; 
     var buffer2 = new byte[bufferSize]; 

     while (true) 
     { 
      int count1 = stream1.Read(buffer1, 0, bufferSize); 
      int count2 = stream2.Read(buffer2, 0, bufferSize); 

      if (count1 != count2) 
      { 
       return false; 
      } 

      if (count1 == 0) 
      { 
       return true; 
      } 

      int iterations = (int)Math.Ceiling((double)count1/sizeof(Int64)); 
      for (int i = 0; i < iterations; i++) 
      { 
       if (BitConverter.ToInt64(buffer1, i * sizeof(Int64)) != BitConverter.ToInt64(buffer2, i * sizeof(Int64))) 
       { 
        return false; 
       } 
      } 
     } 
    } 

Answer 5

Esta es la forma en que lo haría si no quiere depender de CRC:

/// <summary> 
    /// Binary comparison of two files 
    /// </summary> 
    /// <param name="fileName1">the file to compare</param> 
    /// <param name="fileName2">the other file to compare</param> 
    /// <returns>a value indicateing weather the file are identical</returns> 
    public static bool CompareFiles(string fileName1, string fileName2) 
    { 
     FileInfo info1 = new FileInfo(fileName1); 
     FileInfo info2 = new FileInfo(fileName2); 
     bool same = info1.Length == info2.Length; 
     if (same) 
     { 
      using (FileStream fs1 = info1.OpenRead()) 
      using (FileStream fs2 = info2.OpenRead()) 
      using (BufferedStream bs1 = new BufferedStream(fs1)) 
      using (BufferedStream bs2 = new BufferedStream(fs2)) 
      { 
       for (long i = 0; i < info1.Length; i++) 
       { 
        if (bs1.ReadByte() != bs2.ReadByte()) 
        { 
         same = false; 
         break; 
        } 
       } 
      } 
     } 

     return same; 
    } 

Answer 6

La respuesta aceptada tenía un error que se ha señalado, pero nunca corrigió: flujo de leer las llamadas no se garantiza que devolverán todos los bytes solicitados.

BinaryReaderreadBytes llamadas están garantizados para volver tantos bytes como se pide a menos que el final de la secuencia que se alcance primero.

El siguiente código se aprovecha de BinaryReader hacer la comparación:

static private bool FileEquals(string file1, string file2) 
    { 
     using (FileStream s1 = new FileStream(file1, FileMode.Open, FileAccess.Read, FileShare.Read)) 
     using (FileStream s2 = new FileStream(file2, FileMode.Open, FileAccess.Read, FileShare.Read)) 
     using (BinaryReader b1 = new BinaryReader(s1)) 
     using (BinaryReader b2 = new BinaryReader(s2)) 
     { 
      while (true) 
      { 
       byte[] data1 = b1.ReadBytes(64 * 1024); 
       byte[] data2 = b2.ReadBytes(64 * 1024); 
       if (data1.Length != data2.Length) 
        return false; 
       if (data1.Length == 0) 
        return true; 
       if (!data1.SequenceEqual(data2)) 
        return false; 
      } 
     } 
    }