IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

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.

A. 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 connaitre 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;

B. 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), 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);
        // Écriture 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 tiers, 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.

C. 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 où 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 incré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);
        // Écriture des données décompressé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. À 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 ni 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.