La somme de contrôle et la comparaison de morceaux peuvent-elles accélérer la comparaison de fichiers dans .NET ?

Technologie efficace de comparaison de fichiers .NET

Comparer des fichiers octet par octet est une méthode courante, mais elle est inefficace. Cet article explore des méthodes plus rapides de comparaison de fichiers et présente des bibliothèques dans .NET pour générer des sommes de contrôle.

La comparaison des sommes de contrôle peut-elle améliorer la vitesse ?

Oui, l'utilisation d'algorithmes tels que CRC pour la comparaison des sommes de contrôle est plus rapide que la méthode octet par octet. Les sommes de contrôle génèrent une signature unique pour chaque fichier, permettant de comparer les signatures plutôt que des fichiers entiers.

Bibliothèque de génération de somme de contrôle de fichiers .NET

Plusieurs bibliothèques .NET offrent des capacités de génération de somme de contrôle de fichiers :

• System.Security.Cryptography.MD5 : Générez la somme de contrôle MD5 du fichier.
• System.Security.Cryptography.SHA1 : Calculez la somme de contrôle SHA1 du fichier.
• System.Security.Cryptography.SHA256 : Calculez la somme de contrôle SHA256 du fichier.
• System.Security.Cryptography.SHA512 : Générez la somme de contrôle SHA512 du fichier.

Méthode de comparaison optimisée

Bien que le hachage soit une méthode rapide, vous pouvez optimiser davantage les comparaisons de fichiers à l'aide d'une méthode qui lit de gros morceaux d'octets et les compare sous forme de nombres :

<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++)
        {
            int read1 = fs1.Read(one, 0, BYTES_TO_READ);
            int read2 = fs2.Read(two, 0, BYTES_TO_READ);

            if (read1 != read2 || !one.SequenceEqual(two))
                return false;
        }
    }

    return true;
}</code>

Résultats des tests de performances

Les tests de performances montrent que pour les fichiers volumineux (tels qu'un fichier vidéo de 100 Mo), la comparaison des blocs de fichiers sous forme de nombres surpasse les comparaisons octet par octet et les hachages :

• Comparaison de blocs : 1063 ms
• Comparaison octet par octet : 3031 ms
• Hash : 865 ms

Pour les fichiers plus petits, le hachage est généralement plus rapide en raison de sa nature optimisée. Cependant, pour les fichiers volumineux, la surcharge liée à la lecture et au traitement de l'intégralité du fichier peut être importante et la méthode de comparaison de blocs est plus rapide.

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!