La compression de fichier avec .Net 2.0 (Version C#)

Nous allons voir dans cet article comment il est possible avec le Framework .Net 2.0 de compresser ou de décompresser un fichier au format GZip. Cette nouveauté fait suite aux demandes des développeurs qui souhaitaient que le Framework intègre de telles fonctionnalités. Toutes ces opérations sont désormais rendues possibles par l'introduction d'un nouveau namespace : le System.IO.Compression .

N'hésitez pas à commenter cet article ! Commentez Donner une note à l'article (5)

Article lu   fois.

L'auteur

Profil ProSite personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

Introduction

Le Framework .Net 2.0 intègre désormais des classes qui permettent de réaliser de la compression de fichier, en effet dans la version 1.1 du Framework cela n'était pas intégré, il fallait passer par des solutions tierces, certaines étant open-source, d'autres gratuites ou même commerciales. Ici, la gestion de la compression de fichier est intégrée nativement dans le Framework, cela s'avère très utile dans de nombreuses applications. Il fallait absolument combler cette lacune et Microsoft l'a fait. En effet nous allons voir qu'il est aisé de compresser ou de décompresser un fichier avec .Net 2.0.

1. Présentation

Les classes permettant la compression de fichier se trouvent dans le namespace System.IO.Compression, ces classes comptent parmi les 1500 nouvelles introduites par la version 2.0 du Framework .Net. Deux algorithmes de compression sont pris en charge : Deflate et Gzip. Je vous renvoie à la documentation pour connaître plus en détail la structure de ces classes. Nous utiliserons dans cet article le très répandu Gzip.

Pour utiliser ces classes, il ne faut cependant pas oublier d'importer les namespaces suivants System.IO et System.IO.Compression.

Namespaces à utiliser :
Sélectionnez

using System.IO;
using System.IO.Compression;

2. Compresser un fichier

Pour compresser un fichier nous devons d'abord le mettre dans un Stream, en effet, la compression s'effectue sur des flux de données et non directement sur le fichier, il faut donc d'abord lire le fichier grâce à un FileStream (il permet d'effectuer diverses opérations au travers du système de fichiers), puis ensuite le GZipStream va compresser ces données et les renvoyer dans un FileStream, puis le fichier .gz sera écrit sur le disque dur.

Vous allez voir dans le code commenté que pour compresser un fichier il n'y a rien de très complexe à réaliser.

Compression d'un fichier
Sélectionnez

public bool compresserFichier(string cheminSource, string cheminDestination)
// cheminSource : chemin complet du fichier à compresser
// cheminDestination : chemin complet du fichier compressé à créer
{
	try
	{
		// Le fichier est placé dans le FileStream
		FileStream monFileStream = new FileStream(cheminSource, FileMode.Open);
	
		byte[] monBuffer = new byte[monFileStream.Length];
		// Lecture de l'intégralité du FileStream
		monFileStream.Read(monBuffer, 0, System.Convert.ToInt32(monFileStream.Length));
		// Fermeture du FileStream
		monFileStream.Close();
		// Création du fichier qui va contenir le fichier compressé
		monFileStream = new FileStream(cheminDestination, FileMode.Create);

		// Compression des données
		GZipStream monGZipStream = new GZipStream(monFileStream, CompressionMode.Compress, false);
		// Ecriture des données compressées dans le fichier de destination
		monGZipStream.Write(monBuffer, 0, monBuffer.Length);
		// Fermeture du GZipStream
		monGZipStream.Close();
		return true;
	}
	catch (Exception ex)
	{
		MessageBox.Show(ex.Message);
		return false;
	}
			
}

Attention : Le fichier qui sera contenu dans l'archive au format Gzip comportera le même nom que le fichier d'origine mais sans son extension, donc si par exemple vous compressez un fichier .txt je vous recommande de nommer le fichier compressé "mon_fichier.txt.gz", ainsi si vous le décompressez avec un logiciel tierce, le fichier sera bien nommé "mon_fichier.txt" et non "mon_fichier", ce qui pourrait être ennuyeux si l'on ne connait pas l'extension de ce fichier...

Après avoir vu comment compresser un fichier, passons maintenant à la décompression.

3. Décompresser un fichier

La décompression de fichiers est une opération légèrement plus complexe que la compression, il faut tout d'abord récupérer la taille du fichier pour dimensionner le buffer, puis à l'aide d'une boucle lire les données pour les décompresser au fur et à mesure. Une fois cette opération terminée il faut écrire les données décompressées dans un nouveau fichier.

Décompresser un fichier
Sélectionnez

public bool decompression(string cheminSource, string cheminDestination)
// cheminSource : chemin complet du fichier compressé
// cheminDestination : chemin complet du fichier  le fichier doit être décompressé
{
	try
	{
		// Lecture du fichier compresse
		FileStream monFileStream = new FileStream(cheminSource, FileMode.Open);
		// Données du fichier placées dans un GZipStream
		GZipStream monGzipStream = new GZipStream(monFileStream, CompressionMode.Decompress);

		// Tableau qui va contenir la taille du fichier
		byte[] tailleOctets = new byte[4];

		// Positionnement dans le Stream pour récupérer la taille
		int position = System.Convert.ToInt32(monFileStream.Length - 4);
		monFileStream.Position = position;

		// Récupération de la taille du fichier
		monFileStream.Read(tailleOctets, 0, 4);

		// Repositionnement en début du Stream
		monFileStream.Position = 0;

		// Conversion de la taille du fichier en entier
		int tailleFichier = BitConverter.ToInt32(tailleOctets, 0);
		// Dimesionnement du buffer
		byte[] buffer = new byte[tailleFichier + 100];
		// Offset qui permettra de se repérer dans le Stream
		int monOffset = 0;

		while ((true))
		{

			// Les données sont décompressées et placées dans le buffer
			int decompressionOctets = monGzipStream.Read(buffer, monOffset, 100);

			// Tant qu'il reste des données on continue
			if ((decompressionOctets == 0))
			{
				goto exitWhileStatement0;
			}

			// On icrémente l'offset pour ne pas repartir de 0 à chaque fois...
			monOffset += decompressionOctets;
		}
		
		exitWhileStatement0: ;

		// Création du fichier décompressé
		monFileStream = new FileStream(cheminDestination, FileMode.Create);
		// Ecriture des données décomrpessées dans le fichier
		monFileStream.Write(buffer, 0, tailleFichier - 1);

		// Efface les données en mémoire tampon
		monFileStream.Flush();

		// Fermeture des Streams
		monFileStream.Close();
		monGzipStream.Close();

		return true;

	}
	catch (Exception ex)
	{

		MessageBox.Show(ex.Message);
		return false;

	}
}

Conclusion

Comme vous l'avez découvert au cours de cet article il n'y a rien de compliqué pour utiliser la compression/décompression de fichier du Framework .Net 2.0. L'intégration de ces classes dans le Framework répond à une demande des développeurs, en effet, ces processus sont très fréquemment utilisés dans les applications. Un seul bémol à cette nouveauté, le manque de paramétrages avancés et d'options, comme le propose par exemple #Ziplib, mais cela ne sera cependant pas problématique dans la majorité des cas. A vos claviers pour tirer bénéfice au plus vite de cette nouveauté appréciable du Framework, et rendez-vous dans un prochain article.

Ressources



Un grand merci à Pharaonix pour la relecture de cet article.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Copyright © 2005 Ronald VASSEUR. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.