Crc32 compatible winzip et winrar par défaut (généralisation basé sur le code c# de li9)


Télécharger le projet
Commenter

Description

Voici une classe, sous forme de lecteur (similaire à TextReader et BinaryReader pour ceux qui connaissent) qui permet de calculer le CRC32 de fichiers, ou d'autres flux de données selon certaines restrictions. Elle permet même le calcul du CRC32 d'un tableau d'octets.
Cette classe est basée à l'origine sur le code C# de li9 (http://csharpfr.com/code.aspx?ID=29137). Cependant, à cause des nombreuses restructuration du code de calcul, il n'est plus explicitement visible.
Le polynôme permettant le calcul du CRC32 ainsi que la taille du tampon à utiliser sont paramètrables.
Grâce à l'implémentation de IDisposable, ce lecteur peut être utilisé dans une structure using(type var = expr) {}.
Comme code, je vous met mon commentaire d'en-tête qui contient un exemple d'utilisation.

Source / Exemple : 


/*
 * Calcul de CRC32 en C#
 * 2005/04/06 par MyGoddess
 * Basé sur le code C# de li9 (lunatik)
 * http://csharpfr.com/code.aspx?ID=29137
 * lui même basé sur le code C++ de Capa6T
 * http://www.cppfrance.com/code.aspx?ID=24351
 * Site de lunatik : http://www.kawaiistudio.no-ip.com/lunatikv6
 * *************************************************************
 * Modifications :


     
  •   - Taille du tampon de lecture. Utilisation d'un tampon de 8192.

    •  
  •     Cette valeur peut être modifiée par le programme.

    •  
  •   - La classe deviens un lecteur afin de permettre la génération du CRC pendant la lecture du fichier.

    •  
  •   - Les méthodes de CRC32 peuvent prendre des noms de fichiers comme des flux. La méthode prenant les noms

    •  
  •     agit comme un wrapper autour de la méthode utilisant les flux. Il peut aussi y avoir un tableau en entrée.

    •  
  •   - La table est calculée à la première utilisation puis stockée. Ainsi elle n'est pas recrée à chaque appels puisque lors de l'utilisation de l'instantiation, le CRC peut être calculé souvent à cause de la petitesse des tableaux utilisés.

    •  
  •   - Le polynôme peut être changé pour les nouvelles instances ou calcul, dans ce cas, la table est recalculer à la prochaine demande.

    •  
  •   - Si le flux sous-jacent est modifié en position alors le lecteur échoue.

 * 
 * Exemple d'utilisation sur une application Console C#.
 * Montre l'utilisation des deux type de calcul.
 */ 
 
namespace Test
{
	using MyGoddess.Data;
	using System;
	using System.IO;

	/// <summary>
	/// Test
	/// </summary>
	public class Test
	{
		[STAThread()]
		static void Main(string[] args)
		{
			// Vérifie les paramètres
			if (args.Length != 2)
			{
				Console.WriteLine("Utilisation : Test <fichier entré> <fichier journal>");
				return;
			}
			Console.WriteLine("Calcul du CRC32...");
			// Initialise le fichier de registre de l'opération.
			TextWriter log = new StreamWriter(args[1], false);
			log.WriteLine("Progression, Lut, CRC32 données lut");
			// Initialise le tampon et récupère la taille du fichier.
			byte[] buffer = new byte[CRC32Reader.BufferSize];
			long taille = (new FileInfo(args[0])).Length;
			//Crée le lecteur qui sera disposé à la fin du bloc d'instruction, ce qui permet de ne pas écrire explicitement l'appel à la méthode Close().
			using (CRC32Reader crc32r = new CRC32Reader(args[0]))
			{
				long total = 0;
				long lut;
				// Boucle de lecture des données.
				// La progression est affichée à l'écran et enregistrée dans le fichier journal.
				while ((lut = crc32r.Read(buffer)) != 0)
				{
					total += lut;
					log.WriteLine(percent(total, taille) + ", " + lut + ", " + crc32r.LocalCRC32.ToString("X"));
					Console.Write(percent(total, taille) + " " + crc32r.LocalCRC32.ToString("X") + "\t\r");
				}
				// On affiche la valeur finale de la progression, enregistre la dernière ligne de progression du fichier journal.
				log.WriteLine(percent(total, taille) + ", " + lut + ", " + crc32r.LocalCRC32.ToString("X"));
				Console.WriteLine(percent(total, taille) + " " + crc32r.LocalCRC32.ToString("X") + "\t");
				// On affiche et enregistre le CRC32 total du fichier.
				log.WriteLine("CRC32 du fichier : " + crc32r.CRC32.ToString("X"));
				Console.WriteLine("CRC32 du fichier : " + crc32r.CRC32.ToString("X"));
			}
			// On calcul le CRC32 par la méthode directe.
			string crc32 = CRC32Reader.GetCRC32(args[0]).ToString("X");
			log.WriteLine("CRC32 du fichier calculer avec la méthode directe : " + crc32);
			Console.WriteLine("CRC32 du fichier calculer avec la méthode directe : " + crc32);
		}

		// Fonction transformant une fraction en un pourcentage sur 2 chiffres.
		static string percent(long num, long den)
		{
			return (((10000 * num) / den) / 100.0) + " %";
		}
	}
}

Conclusion :


Je metterais bientôt, si j'en trouve l'occasion, un exemple utilisant des boîtes de dialogue pour afficher la progression.
L'utilisation sous forme de lecteur permet aussi de copier le fichier en calculant son CRC32 au lieu de faire les deux actions séparément.
Pour l'instant je ne l'ai testé qu'avec le programme exemple présenté. Et les résultats sont cohérents et correspondant avec celui que m'a généré WinRAR. Comme afficher dans la capture.

L'utilisation des flux est restreintes aux flux qui ont une taille, ceux qui sont crées uniquement pour le lecteur et ceux qui sont à leur position de départ lors de la construction de lecteur.
Pour les contraintes et modification, voir le commentaire dans le code de l'exemple.

Tout commentaire est le bienvenu. Pour l'explication du CRC32, voir les sources cités.
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (BaFM)