Comment puis-je obtenir une comparaison de fichiers efficace dans .NET ?

Méthode de comparaison de fichiers efficace .NET

Lors de la comparaison de deux fichiers, la rapidité est souvent essentielle. La méthode traditionnelle de lecture de fichiers octet par octet prend beaucoup de temps pour les fichiers volumineux. Cet article explore les moyens d'effectuer des comparaisons de fichiers plus rapides dans .NET, notamment des comparaisons de sommes de contrôle et des comparaisons de tableaux d'octets personnalisés.

Comparaison des sommes de contrôle : solution possible ?

Les comparaisons de somme de contrôle (telles que le contrôle de redondance cyclique (CRC)) génèrent une empreinte digitale unique pour chaque fichier. La comparaison de ces empreintes digitales est plus rapide que la comparaison du fichier entier octet par octet. Cependant, il est important de noter que les sommes de contrôle peuvent produire des faux positifs, des vérifications supplémentaires peuvent donc être nécessaires pour garantir l'exactitude.

Performance de la comparaison des sommes de contrôle :

Bien que la comparaison des sommes de contrôle soit plus rapide que la comparaison octet par octet dans certains cas, ce n'est pas toujours la meilleure solution. Nos tests ont montré que les comparaisons peuvent toujours être effectuées en quelques secondes à l'aide de l'algorithme de hachage MD5.

Personnalisez la comparaison des tableaux d'octets pour optimiser les performances :

Nous proposons une méthode de comparaison de tableaux d'octets personnalisée qui fonctionne bien mieux que la comparaison octet par octet. Cette méthode lit un bloc d'octets dans un tableau et compare les valeurs du tableau sous forme d'entiers. Cette parallélisation réduit la surcharge des comparaisons d'octets individuels.

Exemple de code pour la comparaison de tableaux d'octets :

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

Tester et comparer :

Dans nos tests, les comparaisons de tableaux d'octets personnalisés ont donné des résultats presque 3 fois supérieurs aux comparaisons directes octet par octet. Bien que la méthode de hachage soit plus lente que le tableau d'octets, elle peut toujours être complétée en 1 seconde lors du test.

En choisissant la méthode de comparaison de fichiers appropriée en fonction des exigences de taille et de précision du fichier, les développeurs peuvent réaliser une comparaison de fichiers rapide et efficace dans les applications .NET.

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!