Comment puis-je comparer des fichiers dans .NET plus efficacement qu'octet par octet ?

Méthode de comparaison de fichiers efficace .NET

Comparer deux fichiers dans .NET peut prendre beaucoup de temps, en particulier pour les fichiers volumineux. La méthode traditionnelle consistant à lire les fichiers binaires octet par octet et à les comparer est inefficace et lente.

Méthodes alternatives

Pour améliorer les performances, envisagez les alternatives suivantes :

Méthode de fusion de fichiers

Une méthode étonnamment rapide consiste à concaténer les deux fichiers en un seul tableau d'octets et à comparer les valeurs résultantes.

<code class="language-csharp">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 (!one.SequenceEqual(two))
                return false;
        }
    }
    return true;
}</code>

Comparaison de la somme de contrôle

Une autre méthode consiste à générer une empreinte digitale de chaque fichier à l'aide d'un algorithme de somme de contrôle tel que CRC ou MD5. La comparaison de ces empreintes digitales est beaucoup plus rapide que la comparaison de fichiers entiers.

<code class="language-csharp">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;
}</code>

Comparaison des performances

Lors du test de fichiers vidéo volumineux, les performances de la méthode de fusion de fichiers étaient environ 3 fois supérieures à celles de la méthode de comparaison octet par octet, tandis que la comparaison de hachage était plus rapide, avec une moyenne d'environ 865 millisecondes.

La meilleure méthode dépend de la taille et de la nature des fichiers que vous souhaitez comparer. Cependant, ces alternatives offrent des améliorations significatives des performances par rapport aux méthodes traditionnelles de comparaison octet par octet.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!