Wie vergleiche ich 2 Dateien schnell mit .NET?

Typische Ansätze empfehlen, die Binärdatei über FileStream zu lesen und byteweise zu vergleichen.

• Wäre ein Prüfsummenvergleich wie CRC schneller?
• Gibt es .NET-Bibliotheken, die eine Prüfsumme für eine Datei generieren können?

Ein Prüfsummenvergleich ist höchstwahrscheinlich langsamer als ein byteweiser Vergleich.

Um eine Prüfsumme zu generieren, müssen Sie jedes Byte der Datei laden und die Verarbeitung durchführen. Sie müssen dies dann für die zweite Datei tun. Die Verarbeitung wird mit ziemlicher Sicherheit langsamer sein als die Vergleichsprüfung.

So generieren Sie eine Prüfsumme: Mit den Kryptografieklassen können Sie dies problemlos tun. Hier ist ein kurzes Beispiel für das Generieren einer MD5-Prüfsumme mit C #.

Eine Prüfsumme kann jedoch schneller und sinnvoller sein, wenn Sie die Prüfsumme des Falls "Test" oder "Basis" vorberechnen können. Wenn Sie über eine vorhandene Datei verfügen und prüfen, ob eine neue Datei mit der vorhandenen identisch ist, bedeutet die Vorberechnung der Prüfsumme für Ihre "vorhandene" Datei, dass Sie das DiskIO nur einmal ausführen müssen neue Datei. Dies wäre wahrscheinlich schneller als ein Byte-für-Byte-Vergleich.

Die langsamste Methode besteht darin, zwei Dateien byteweise zu vergleichen. Das schnellste, das ich finden konnte, ist ein ähnlicher Vergleich, aber anstelle von jeweils einem Byte würden Sie ein Array von Bytes mit der Größe Int64 verwenden und dann die resultierenden Zahlen vergleichen.

Folgendes habe ich mir ausgedacht:

    const int BYTES_TO_READ = sizeof(Int64);

    static bool FilesAreEqual(FileInfo first, FileInfo second)
    {
        if (first.Length != second.Length)
            return false;

        if (string.Equals(first.FullName, second.FullName, StringComparison.OrdinalIgnoreCase))
            return true;

        int iterations = (int)Math.Ceiling((double)first.Length / BYTES_TO_READ);

        using (FileStream fs1 = first.OpenRead())
        using (FileStream fs2 = second.OpenRead())
        {
            byte[] one = new byte[BYTES_TO_READ];
            byte[] two = new byte[BYTES_TO_READ];

            for (int i = 0; i < iterations; i++)
            {
                 fs1.Read(one, 0, BYTES_TO_READ);
                 fs2.Read(two, 0, BYTES_TO_READ);

                if (BitConverter.ToInt64(one,0) != BitConverter.ToInt64(two,0))
                    return false;
            }
        }

        return true;
    }

Bei meinen Tests konnte ich feststellen, dass dies ein einfaches ReadByte () -Szenario um fast 3: 1 übertrifft. Im Durchschnitt über 1000 Läufe erhielt ich diese Methode bei 1063 ms und die folgende Methode (einfacher Byte-für-Byte-Vergleich) bei 3031 ms. Hashing kam mit durchschnittlich 865 ms immer im Sekundentakt zurück. Dieser Test wurde mit einer ~ 100 MB Videodatei durchgeführt.

Hier sind die ReadByte- und Hashing-Methoden, die ich zu Vergleichszwecken verwendet habe:

    static bool FilesAreEqual_OneByte(FileInfo first, FileInfo second)
    {
        if (first.Length != second.Length)
            return false;

        if (string.Equals(first.FullName, second.FullName, StringComparison.OrdinalIgnoreCase))
            return true;

        using (FileStream fs1 = first.OpenRead())
        using (FileStream fs2 = second.OpenRead())
        {
            for (int i = 0; i < first.Length; i++)
            {
                if (fs1.ReadByte() != fs2.ReadByte())
                    return false;
            }
        }

        return true;
    }

    static bool FilesAreEqual_Hash(FileInfo first, FileInfo second)
    {
        byte[] firstHash = MD5.Create().ComputeHash(first.OpenRead());
        byte[] secondHash = MD5.Create().ComputeHash(second.OpenRead());

        for (int i=0; i<firstHash.Length; i++)
        {
            if (firstHash[i] != secondHash[i])
                return false;
        }
        return true;
    }

Wenn Sie nicht entscheiden, dass Sie wirklich einen vollständigen Byte-für-Byte-Vergleich benötigen (siehe andere Antworten zur Diskussion des Hashings), ist die einfachste Lösung:

• für System.IO.FileInfoBeispiele:

public static bool AreFileContentsEqual(FileInfo fi1, FileInfo fi2) =>
    fi1.Length == fi2.Length &&
    (fi1.Length == 0 || File.ReadAllBytes(fi1.FullName).SequenceEqual(
                        File.ReadAllBytes(fi2.FullName)));

• für System.StringPfadnamen:

public static bool AreFileContentsEqual(String path1, String path2) =>
                   AreFileContentsEqual(new FileInfo(path1), new FileInfo(path2));

Im Gegensatz zu einigen anderen veröffentlichten Antworten ist dies für jede Art von Datei eindeutig korrekt : Binär, Text, Medien, ausführbare Datei usw., aber als vollständiger binärer Vergleich Dateien, die sich nur in "unwichtigen" Arten unterscheiden (wie Stückliste , Zeile) -end , Zeichenkodierung , Medienmetadaten, Leerzeichen, Auffüllen, Quellcodekommentare usw.) werden immer als ungleich betrachtet .

Dieser Code lädt beide Dateien vollständig in den Speicher, daher sollte er nicht zum Vergleichen wirklich gigantischer Dateien verwendet werden . Abgesehen von dieser wichtigen Einschränkung ist das vollständige Laden angesichts des Designs des .NET GC (da es grundlegend optimiert ist, um kleine, kurzlebige Zuordnungen extrem billig zu halten) keine wirkliche Strafe und könnte sogar optimal sein, wenn Dateigrößen erwartet werden auf weniger als 85K , da ein Minimum an Benutzercode verwenden (wie hier gezeigt) Datei Performance - Probleme auf die Delegation von maximal impliziert CLR, BCLund JITdie neueste Design - Technologie, System - Code und adaptive Laufzeit Optimierungen profitieren von (zB).

Darüber hinaus sind in solchen Workaday-Szenarien Bedenken hinsichtlich der Leistung des Byte-für-Byte-Vergleichs über LINQEnumeratoren (wie hier gezeigt) umstritten, da das Schlagen der Festplatte a filet / a̲l̲l̲ für Datei-E / A die Vorteile um mehrere Größenordnungen in den Schatten stellt der verschiedenen Speichervergleichsalternativen. Zum Beispiel, obwohl SequenceEqual es uns tatsächlich die "Optimierung" gibt , bei der ersten Nichtübereinstimmung abzubrechen , spielt dies kaum eine Rolle, nachdem wir bereits den Inhalt der Dateien abgerufen haben, die jeweils vollständig erforderlich sind, um die Übereinstimmung zu bestätigen.

Zusätzlich zu Reed Copseys Antwort:

• Der schlimmste Fall ist, wenn die beiden Dateien identisch sind. In diesem Fall ist es am besten, die Dateien Byte für Byte zu vergleichen.

• Wenn die beiden Dateien nicht identisch sind, können Sie die Dinge etwas beschleunigen, indem Sie früher erkennen, dass sie nicht identisch sind.

Wenn die beiden Dateien beispielsweise unterschiedlich lang sind, wissen Sie, dass sie nicht identisch sein können, und Sie müssen nicht einmal ihren tatsächlichen Inhalt vergleichen.

Es wird noch schneller, wenn Sie nicht in kleinen 8-Byte-Blöcken lesen, sondern eine Schleife herumlegen und einen größeren Block lesen. Ich habe die durchschnittliche Vergleichszeit auf 1/4 reduziert.

    public static bool FilesContentsAreEqual(FileInfo fileInfo1, FileInfo fileInfo2)
    {
        bool result;

        if (fileInfo1.Length != fileInfo2.Length)
        {
            result = false;
        }
        else
        {
            using (var file1 = fileInfo1.OpenRead())
            {
                using (var file2 = fileInfo2.OpenRead())
                {
                    result = StreamsContentsAreEqual(file1, file2);
                }
            }
        }

        return result;
    }

    private static bool StreamsContentsAreEqual(Stream stream1, Stream stream2)
    {
        const int bufferSize = 1024 * sizeof(Int64);
        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;
                }
            }
        }
    }
}

Das einzige, was einen Prüfsummenvergleich etwas schneller machen kann als einen byteweisen Vergleich, ist die Tatsache, dass Sie jeweils eine Datei lesen, was die Suchzeit für den Plattenkopf etwas verkürzt. Dieser leichte Gewinn kann jedoch sehr gut durch die zusätzliche Zeit der Berechnung des Hashs aufgefressen werden.

Außerdem kann ein Prüfsummenvergleich natürlich nur dann schneller sein, wenn die Dateien identisch sind. Wenn dies nicht der Fall ist, würde ein Byte-für-Byte-Vergleich beim ersten Unterschied enden und ihn viel schneller machen.

Sie sollten auch berücksichtigen, dass ein Hash-Code-Vergleich nur besagt, dass dies sehr wahrscheinlich ist dass die Dateien identisch sind. Um 100% sicher zu sein, müssen Sie einen byteweisen Vergleich durchführen.

Wenn der Hash-Code beispielsweise 32 Bit beträgt, sind Sie zu 99,99999998% sicher, dass die Dateien identisch sind, wenn die Hash-Codes übereinstimmen. Das ist fast 100%, aber wenn Sie wirklich 100% Sicherheit brauchen, ist es das nicht.

Bearbeiten: Diese Methode würde nicht zum Vergleichen von Binärdateien funktionieren!

In .NET 4.0 verfügt die FileKlasse über die folgenden zwei neuen Methoden:

public static IEnumerable<string> ReadLines(string path)
public static IEnumerable<string> ReadLines(string path, Encoding encoding)

Was bedeutet, dass Sie verwenden könnten:

bool same = File.ReadLines(path1).SequenceEqual(File.ReadLines(path2));

Ehrlich gesagt denke ich, dass Sie Ihren Suchbaum so weit wie möglich kürzen müssen.

Dinge zu überprüfen, bevor Sie Byte für Byte gehen:

1. Sind die Größen gleich?
2. Unterscheidet sich das letzte Byte in Datei A von Datei B.

Außerdem ist das gleichzeitige Lesen großer Blöcke effizienter, da Laufwerke sequentielle Bytes schneller lesen. Byteweise gehen führt nicht nur zu weitaus mehr Systemaufrufen, sondern auch dazu, dass der Lesekopf einer herkömmlichen Festplatte häufiger hin und her sucht, wenn sich beide Dateien auf derselben Festplatte befinden.

Lesen Sie Block A und Block B in einen Bytepuffer und vergleichen Sie sie (verwenden Sie NICHT Array.Equals, siehe Kommentare). Passen Sie die Größe der Blöcke an, bis Sie das erreichen, was Sie für einen guten Kompromiss zwischen Speicher und Leistung halten. Sie können den Vergleich auch mit mehreren Threads durchführen, die Festplattenlesevorgänge jedoch nicht mit mehreren Threads.

Meine Antwort ist eine Ableitung von @lars, behebt aber den Fehler im Aufruf von Stream.Read. Ich füge auch einige schnelle Pfadüberprüfungen hinzu, die andere Antworten hatten, und eine Eingabevalidierung. Kurz gesagt, dies sollte die Antwort sein:

using System;
using System.IO;

namespace ConsoleApp4
{
    class Program
    {
        static void Main(string[] args)
        {
            var fi1 = new FileInfo(args[0]);
            var fi2 = new FileInfo(args[1]);
            Console.WriteLine(FilesContentsAreEqual(fi1, fi2));
        }

        public static bool FilesContentsAreEqual(FileInfo fileInfo1, FileInfo fileInfo2)
        {
            if (fileInfo1 == null)
            {
                throw new ArgumentNullException(nameof(fileInfo1));
            }

            if (fileInfo2 == null)
            {
                throw new ArgumentNullException(nameof(fileInfo2));
            }

            if (string.Equals(fileInfo1.FullName, fileInfo2.FullName, StringComparison.OrdinalIgnoreCase))
            {
                return true;
            }

            if (fileInfo1.Length != fileInfo2.Length)
            {
                return false;
            }
            else
            {
                using (var file1 = fileInfo1.OpenRead())
                {
                    using (var file2 = fileInfo2.OpenRead())
                    {
                        return StreamsContentsAreEqual(file1, file2);
                    }
                }
            }
        }

        private static int ReadFullBuffer(Stream stream, byte[] buffer)
        {
            int bytesRead = 0;
            while (bytesRead < buffer.Length)
            {
                int read = stream.Read(buffer, bytesRead, buffer.Length - bytesRead);
                if (read == 0)
                {
                    // Reached end of stream.
                    return bytesRead;
                }

                bytesRead += read;
            }

            return bytesRead;
        }

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

            while (true)
            {
                int count1 = ReadFullBuffer(stream1, buffer1);
                int count2 = ReadFullBuffer(stream2, buffer2);

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

Oder wenn Sie super-fantastisch sein möchten, können Sie die asynchrone Variante verwenden:

using System;
using System.IO;
using System.Threading.Tasks;

namespace ConsoleApp4
{
    class Program
    {
        static void Main(string[] args)
        {
            var fi1 = new FileInfo(args[0]);
            var fi2 = new FileInfo(args[1]);
            Console.WriteLine(FilesContentsAreEqualAsync(fi1, fi2).GetAwaiter().GetResult());
        }

        public static async Task<bool> FilesContentsAreEqualAsync(FileInfo fileInfo1, FileInfo fileInfo2)
        {
            if (fileInfo1 == null)
            {
                throw new ArgumentNullException(nameof(fileInfo1));
            }

            if (fileInfo2 == null)
            {
                throw new ArgumentNullException(nameof(fileInfo2));
            }

            if (string.Equals(fileInfo1.FullName, fileInfo2.FullName, StringComparison.OrdinalIgnoreCase))
            {
                return true;
            }

            if (fileInfo1.Length != fileInfo2.Length)
            {
                return false;
            }
            else
            {
                using (var file1 = fileInfo1.OpenRead())
                {
                    using (var file2 = fileInfo2.OpenRead())
                    {
                        return await StreamsContentsAreEqualAsync(file1, file2).ConfigureAwait(false);
                    }
                }
            }
        }

        private static async Task<int> ReadFullBufferAsync(Stream stream, byte[] buffer)
        {
            int bytesRead = 0;
            while (bytesRead < buffer.Length)
            {
                int read = await stream.ReadAsync(buffer, bytesRead, buffer.Length - bytesRead).ConfigureAwait(false);
                if (read == 0)
                {
                    // Reached end of stream.
                    return bytesRead;
                }

                bytesRead += read;
            }

            return bytesRead;
        }

        private static async Task<bool> StreamsContentsAreEqualAsync(Stream stream1, Stream stream2)
        {
            const int bufferSize = 1024 * sizeof(Int64);
            var buffer1 = new byte[bufferSize];
            var buffer2 = new byte[bufferSize];

            while (true)
            {
                int count1 = await ReadFullBufferAsync(stream1, buffer1).ConfigureAwait(false);
                int count2 = await ReadFullBufferAsync(stream2, buffer2).ConfigureAwait(false);

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

Meine Experimente zeigen, dass es definitiv hilfreich ist, Stream.ReadByte () weniger oft aufzurufen, aber die Verwendung von BitConverter zum Packen von Bytes macht keinen großen Unterschied zum Vergleich von Bytes in einem Byte-Array.

Es ist also möglich, diese "Math.Ceiling and Iterations" -Schleife im obigen Kommentar durch die einfachste zu ersetzen:

            for (int i = 0; i < count1; i++)
            {
                if (buffer1[i] != buffer2[i])
                    return false;
            }

Ich denke, es hat damit zu tun, dass BitConverter.ToInt64 vor dem Vergleich ein wenig Arbeit erledigen muss (Argumente überprüfen und dann die Bitverschiebung durchführen), und dies entspricht dem Arbeitsaufwand für den Vergleich von 8 Bytes in zwei Arrays .

Wenn die Dateien nicht zu groß sind, können Sie Folgendes verwenden:

public static byte[] ComputeFileHash(string fileName)
{
    using (var stream = File.OpenRead(fileName))
        return System.Security.Cryptography.MD5.Create().ComputeHash(stream);
}

Es ist nur möglich, Hashes zu vergleichen, wenn die Hashes zum Speichern nützlich sind.

(Der Code wurde etwas sauberer bearbeitet.)

Eine weitere Verbesserung bei großen Dateien mit identischer Länge könnte darin bestehen, die Dateien nicht nacheinander zu lesen, sondern mehr oder weniger zufällige Blöcke zu vergleichen.

Sie können mehrere Threads verwenden, die an verschiedenen Positionen in der Datei beginnen und entweder vorwärts oder rückwärts vergleichen.

Auf diese Weise können Sie Änderungen in der Mitte / am Ende der Datei schneller erkennen, als Sie es mit einem sequentiellen Ansatz erreichen würden.

Wenn Sie nur zwei Dateien vergleichen müssen, ist der schnellste Weg (in C weiß ich nicht, ob er auf .NET anwendbar ist).

1. öffne beide Dateien f1, f2
2. Holen Sie sich die jeweilige Dateilänge l1, l2
3. wenn l1! = l2 sind die Dateien unterschiedlich; halt
4. mmap () beide Dateien
5. Verwenden Sie memcmp () für die mmap () ed-Dateien

OTOH, wenn Sie herausfinden müssen, ob in einem Satz von N Dateien doppelte Dateien vorhanden sind, ist der schnellste Weg zweifellos die Verwendung eines Hashs, um N-Wege-Bit-für-Bit-Vergleiche zu vermeiden.

Etwas (hoffentlich) einigermaßen Effizientes:

public class FileCompare
{
    public static bool FilesEqual(string fileName1, string fileName2)
    {
        return FilesEqual(new FileInfo(fileName1), new FileInfo(fileName2));
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="file1"></param>
    /// <param name="file2"></param>
    /// <param name="bufferSize">8kb seemed like a good default</param>
    /// <returns></returns>
    public static bool FilesEqual(FileInfo file1, FileInfo file2, int bufferSize = 8192)
    {
        if (!file1.Exists || !file2.Exists || file1.Length != file2.Length) return false;

        var buffer1 = new byte[bufferSize];
        var buffer2 = new byte[bufferSize];

        using (var stream1 = file1.Open(FileMode.Open, FileAccess.Read, FileShare.Read))
        {
            using (var stream2 = file2.Open(FileMode.Open, FileAccess.Read, FileShare.Read))
            {

                while (true)
                {
                    var bytesRead1 = stream1.Read(buffer1, 0, bufferSize);
                    var bytesRead2 = stream2.Read(buffer2, 0, bufferSize);

                    if (bytesRead1 != bytesRead2) return false;
                    if (bytesRead1 == 0) return true;
                    if (!ArraysEqual(buffer1, buffer2, bytesRead1)) return false;
                }
            }
        }
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="array1"></param>
    /// <param name="array2"></param>
    /// <param name="bytesToCompare"> 0 means compare entire arrays</param>
    /// <returns></returns>
    public static bool ArraysEqual(byte[] array1, byte[] array2, int bytesToCompare = 0)
    {
        if (array1.Length != array2.Length) return false;

        var length = (bytesToCompare == 0) ? array1.Length : bytesToCompare;
        var tailIdx = length - length % sizeof(Int64);

        //check in 8 byte chunks
        for (var i = 0; i < tailIdx; i += sizeof(Int64))
        {
            if (BitConverter.ToInt64(array1, i) != BitConverter.ToInt64(array2, i)) return false;
        }

        //check the remainder of the array, always shorter than 8 bytes
        for (var i = tailIdx; i < length; i++)
        {
            if (array1[i] != array2[i]) return false;
        }

        return true;
    }
}

Im Folgenden finden Sie einige Dienstprogrammfunktionen, mit denen Sie feststellen können, ob zwei Dateien (oder zwei Streams) identische Daten enthalten.

Ich habe eine "schnelle" Version bereitgestellt, die Multithread-fähig ist, da sie Byte-Arrays (jeder Puffer wird aus den in jeder Datei gelesenen Daten gefüllt) in verschiedenen Threads mithilfe von Aufgaben vergleicht.

Wie erwartet ist es viel schneller (ungefähr 3x schneller), verbraucht aber mehr CPU (weil es Multithread-fähig ist) und mehr Speicher (weil es zwei Byte-Array-Puffer pro Vergleichsthread benötigt).

    public static bool AreFilesIdenticalFast(string path1, string path2)
    {
        return AreFilesIdentical(path1, path2, AreStreamsIdenticalFast);
    }

    public static bool AreFilesIdentical(string path1, string path2)
    {
        return AreFilesIdentical(path1, path2, AreStreamsIdentical);
    }

    public static bool AreFilesIdentical(string path1, string path2, Func<Stream, Stream, bool> areStreamsIdentical)
    {
        if (path1 == null)
            throw new ArgumentNullException(nameof(path1));

        if (path2 == null)
            throw new ArgumentNullException(nameof(path2));

        if (areStreamsIdentical == null)
            throw new ArgumentNullException(nameof(path2));

        if (!File.Exists(path1) || !File.Exists(path2))
            return false;

        using (var thisFile = new FileStream(path1, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
        {
            using (var valueFile = new FileStream(path2, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
            {
                if (valueFile.Length != thisFile.Length)
                    return false;

                if (!areStreamsIdentical(thisFile, valueFile))
                    return false;
            }
        }
        return true;
    }

    public static bool AreStreamsIdenticalFast(Stream stream1, Stream stream2)
    {
        if (stream1 == null)
            throw new ArgumentNullException(nameof(stream1));

        if (stream2 == null)
            throw new ArgumentNullException(nameof(stream2));

        const int bufsize = 80000; // 80000 is below LOH (85000)

        var tasks = new List<Task<bool>>();
        do
        {
            // consumes more memory (two buffers for each tasks)
            var buffer1 = new byte[bufsize];
            var buffer2 = new byte[bufsize];

            int read1 = stream1.Read(buffer1, 0, buffer1.Length);
            if (read1 == 0)
            {
                int read3 = stream2.Read(buffer2, 0, 1);
                if (read3 != 0) // not eof
                    return false;

                break;
            }

            // both stream read could return different counts
            int read2 = 0;
            do
            {
                int read3 = stream2.Read(buffer2, read2, read1 - read2);
                if (read3 == 0)
                    return false;

                read2 += read3;
            }
            while (read2 < read1);

            // consumes more cpu
            var task = Task.Run(() =>
            {
                return IsSame(buffer1, buffer2);
            });
            tasks.Add(task);
        }
        while (true);

        Task.WaitAll(tasks.ToArray());
        return !tasks.Any(t => !t.Result);
    }

    public static bool AreStreamsIdentical(Stream stream1, Stream stream2)
    {
        if (stream1 == null)
            throw new ArgumentNullException(nameof(stream1));

        if (stream2 == null)
            throw new ArgumentNullException(nameof(stream2));

        const int bufsize = 80000; // 80000 is below LOH (85000)
        var buffer1 = new byte[bufsize];
        var buffer2 = new byte[bufsize];

        var tasks = new List<Task<bool>>();
        do
        {
            int read1 = stream1.Read(buffer1, 0, buffer1.Length);
            if (read1 == 0)
                return stream2.Read(buffer2, 0, 1) == 0; // check not eof

            // both stream read could return different counts
            int read2 = 0;
            do
            {
                int read3 = stream2.Read(buffer2, read2, read1 - read2);
                if (read3 == 0)
                    return false;

                read2 += read3;
            }
            while (read2 < read1);

            if (!IsSame(buffer1, buffer2))
                return false;
        }
        while (true);
    }

    public static bool IsSame(byte[] bytes1, byte[] bytes2)
    {
        if (bytes1 == null)
            throw new ArgumentNullException(nameof(bytes1));

        if (bytes2 == null)
            throw new ArgumentNullException(nameof(bytes2));

        if (bytes1.Length != bytes2.Length)
            return false;

        for (int i = 0; i < bytes1.Length; i++)
        {
            if (bytes1[i] != bytes2[i])
                return false;
        }
        return true;
    }

Ich denke, es gibt Anwendungen, bei denen "Hash" schneller ist als der Vergleich von Byte für Byte. Wenn Sie eine Datei mit anderen vergleichen müssen oder eine Miniaturansicht eines Fotos haben, die sich ändern kann. Es hängt davon ab, wo und wie es verwendet wird.

private bool CompareFilesByte(string file1, string file2)
{
    using (var fs1 = new FileStream(file1, FileMode.Open))
    using (var fs2 = new FileStream(file2, FileMode.Open))
    {
        if (fs1.Length != fs2.Length) return false;
        int b1, b2;
        do
        {
            b1 = fs1.ReadByte();
            b2 = fs2.ReadByte();
            if (b1 != b2 || b1 < 0) return false;
        }
        while (b1 >= 0);
    }
    return true;
}

private string HashFile(string file)
{
    using (var fs = new FileStream(file, FileMode.Open))
    using (var reader = new BinaryReader(fs))
    {
        var hash = new SHA512CryptoServiceProvider();
        hash.ComputeHash(reader.ReadBytes((int)file.Length));
        return Convert.ToBase64String(hash.Hash);
    }
}

private bool CompareFilesWithHash(string file1, string file2)
{
    var str1 = HashFile(file1);
    var str2 = HashFile(file2);
    return str1 == str2;
}

Hier können Sie das bekommen, was am schnellsten ist.

var sw = new Stopwatch();
sw.Start();
var compare1 = CompareFilesWithHash(receiveLogPath, logPath);
sw.Stop();
Debug.WriteLine(string.Format("Compare using Hash {0}", sw.ElapsedTicks));
sw.Reset();
sw.Start();
var compare2 = CompareFilesByte(receiveLogPath, logPath);
sw.Stop();
Debug.WriteLine(string.Format("Compare byte-byte {0}", sw.ElapsedTicks));

Optional können wir den Hash in einer Datenbank speichern.

Hoffe das kann helfen

Noch eine Antwort, abgeleitet von @chsh. MD5 mit Verwendungen und Verknüpfungen für Datei gleich, Datei existiert nicht und unterschiedliche Längen:

/// <summary>
/// Performs an md5 on the content of both files and returns true if
/// they match
/// </summary>
/// <param name="file1">first file</param>
/// <param name="file2">second file</param>
/// <returns>true if the contents of the two files is the same, false otherwise</returns>
public static bool IsSameContent(string file1, string file2)
{
    if (file1 == file2)
        return true;

    FileInfo file1Info = new FileInfo(file1);
    FileInfo file2Info = new FileInfo(file2);

    if (!file1Info.Exists && !file2Info.Exists)
       return true;
    if (!file1Info.Exists && file2Info.Exists)
        return false;
    if (file1Info.Exists && !file2Info.Exists)
        return false;
    if (file1Info.Length != file2Info.Length)
        return false;

    using (FileStream file1Stream = file1Info.OpenRead())
    using (FileStream file2Stream = file2Info.OpenRead())
    { 
        byte[] firstHash = MD5.Create().ComputeHash(file1Stream);
        byte[] secondHash = MD5.Create().ComputeHash(file2Stream);
        for (int i = 0; i < firstHash.Length; i++)
        {
            if (i>=secondHash.Length||firstHash[i] != secondHash[i])
                return false;
        }
        return true;
    }
}

Dies funktioniert gut, wenn man zuerst die Länge vergleicht, ohne Daten zu lesen, und dann die Lese-Byte-Sequenz vergleicht

private static bool IsFileIdentical(string a, string b)
{            
   if (new FileInfo(a).Length != new FileInfo(b).Length) return false;
   return (File.ReadAllBytes(a).SequenceEqual(File.ReadAllBytes(b)));
}