Discussion :

[mercure07]

salut tt le monde, bon je désire comparer 2 fichiers en utilisant leur checksum.
Est ce que quelqu'un pourrait m'aider par un bout de code.
Merci

[ZaaN]

soit tu veux implementer toi meme ton CRC et je te conseille d'etudier la thorie relative, soit tu utilise une lib deja faites...

Dans tout les cas tu trouveras plein d'info sur wikipedia (y.c. des sources)

[xenozephyr]

Salut,

Moi je te déconseille d'utiliser un crc 32bit pour comparer des fichiers car il y a énormément de collisions (2 fichiers diff = même crc)
Tu risque d'avoir de mauvaises surprises.
Le hashage MD5 est beaucoup plus fiable et disponible dans le framework. Et pour encore plus de fiablilité il y a SHA.

a+

[tomlev]

Salut,

Moi je te déconseille d'utiliser un crc 32bit pour comparer des fichiers car il y a énormément de collisions (2 fichiers diff = même crc)
Tu risque d'avoir de mauvaises surprises.
Le hashage MD5 est beaucoup plus fiable et disponible dans le framework. Et pour encore plus de fiablilité il y a SHA.

a+

+1
voir la classe MD5CryproServiceProvider

[Graffito]

je désire comparer 2 fichiers en utilisant leur checksum.
Est ce que quelqu'un pourrait m'aider par un bout de code.

En dehors d'un exercice imposé ou de programmes de synchro entre 2 machines, la comparaison effective me parait aussi simple/rapide et évite tous les cas de collision (même checksum, fichiers différents).

En fait, seule une différence de checksum est significative : 2 fichiers avec le même checksum pouvant être (rarement) différents.

[Niklaos]

Avec un peu de recherche j'ai trouvé du code en C que j'ai porté vite fait en C#.
J'ai besoins d'environ 50sec pour faire la somme sur un fichier de 1Go

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
static UInt32 CheckSum32bits(Byte[] bytes)
        {
            if (bytes.Length < 4) return (0);
 
            UInt32 result = 0;
            UInt32 quotient = 0x04c11db7;
            Byte octet = 0;
 
            result = (UInt32)(bytes[0] << 24);
            result |= (UInt32)(bytes[1] << 16);
            result |= (UInt32)(bytes[2] << 8);
            result |= bytes[3];
            result = ~result;
 
            for (Int32 i = 4; i < bytes.Length; ++i)
            {
                octet = bytes[i];
                for (Int32 j = 0; j < 8; ++j)
                {
                    if ((result & 0x80000000) == 0)
                        result = (result << 1) ^ quotient ^ (UInt32)(octet >> 7);
                    else
                        result = (result << 1) ^ (UInt32)(octet >> 7);
                    octet <<= 1;
                }
            }
            return (~result);
        }

[smyley]

En dehors d'un exercice imposé ou de programmes de synchro entre 2 machines, la comparaison effective me parait aussi simple/rapide et évite tous les cas de collision (même checksum, fichiers différents).

En fait, la méthode de comparaison directe est plus efficace qu'un checksum si ce dernier n'est pas réutilisé. Dans le cas d'archives alors on calcule une seule fois le checksum et après on a terminé. Si par contre c'est une comparaison ponctuelle vaut mieux comparer directement.
Après, on peut toujours faire en sorte que si on trouve deux checksums identiques, rebasculer vers une comparaison directe pour éliminer les doutes possibles.