Décompressez les fichiers par programme dans .net

J'essaie de décompresser par programme un fichier zippé.

J'ai essayé d'utiliser la System.IO.Compression.GZipStreamclasse en .NET, mais lorsque mon application s'exécute (en fait un test unitaire), j'obtiens cette exception:

System.IO.InvalidDataException: le nombre magique dans l'en-tête GZip n'est pas correct. Assurez-vous que vous passez dans un flux GZip ..

Je me rends compte maintenant qu'un .zipfichier n'est pas le même qu'un .gzfichier, et ce GZipn'est pas la même chose que Zip.

Cependant, comme je suis capable d'extraire le fichier en double-cliquant manuellement sur le fichier compressé puis en cliquant sur le bouton "Extraire tous les fichiers", je pense qu'il devrait également y avoir un moyen de le faire dans le code.

Par conséquent, j'ai essayé d'utiliser Process.Start()avec le chemin d'accès au fichier compressé en entrée. Cela amène mon application à ouvrir une fenêtre affichant le contenu du fichier compressé. C'est très bien, mais l'application sera installée sur un serveur sans aucun pour cliquer sur le bouton "Extraire tous les fichiers".

Alors, comment puis-je obtenir mon application pour extraire les fichiers dans les fichiers compressés?

Ou existe-t-il une autre façon de procéder? Je préfère le faire en code, sans télécharger de bibliothèques ou d'applications tierces; le service de sécurité n'a pas trop envie de ça ...

Nous avons utilisé SharpZipLib avec succès sur de nombreux projets. Je sais que c'est un outil tiers, mais le code source est inclus et pourrait fournir un aperçu si vous choisissez de réinventer la roue ici.

Avec .NET 4.5, vous pouvez désormais décompresser des fichiers à l'aide du framework .NET:

using System;
using System.IO;

namespace ConsoleApplication
{
  class Program
  {
    static void Main(string[] args)
    {
      string startPath = @"c:\example\start";
      string zipPath = @"c:\example\result.zip";
      string extractPath = @"c:\example\extract";

      System.IO.Compression.ZipFile.CreateFromDirectory(startPath, zipPath);
      System.IO.Compression.ZipFile.ExtractToDirectory(zipPath, extractPath);
    }
  }
}

Le code ci-dessus provient directement de la documentation de Microsoft: http://msdn.microsoft.com/en-us/library/ms404280(v=vs.110).aspx

ZipFileest contenu dans l'assemblage System.IO.Compression.FileSystem. (Merci nateirvin ... voir le commentaire ci-dessous)

Pour .Net 4.5+

Il n'est pas toujours souhaitable d'écrire le fichier non compressé sur le disque. En tant que développeur ASP.Net, je devrais jouer avec les autorisations pour accorder des droits pour que mon application écrive sur le système de fichiers. En travaillant avec des flux en mémoire, je peux contourner tout cela et lire les fichiers directement:

using (ZipArchive archive = new ZipArchive(postedZipStream))
{
    foreach (ZipArchiveEntry entry in archive.Entries)
    {
         var stream = entry.Open();
         //Do awesome stream stuff!!
    }
}

Alternativement, vous pouvez toujours écrire le fichier décompressé sur le disque en appelant ExtractToFile():

using (ZipArchive archive = ZipFile.OpenRead(pathToZip))
{
    foreach (ZipArchiveEntry entry in archive.Entries)
    {
        entry.ExtractToFile(Path.Combine(destination, entry.FullName));
    }
} 

Pour utiliser la ZipArchiveclasse, vous devrez ajouter une référence à l' System.IO.Compressionespace de noms et à System.IO.Compression.FileSystem.

Gratuit et aucun fichier DLL externe. Tout est dans un seul fichier CS. Un téléchargement n'est que le fichier CS, un autre téléchargement est un exemple très facile à comprendre. Je viens de l'essayer aujourd'hui et je ne peux pas croire à quel point la configuration était simple. Cela a fonctionné du premier coup, pas d'erreurs, rien.

https://github.com/jaime-olivares/zipstorer

Utilisez la bibliothèque DotNetZip à http://www.codeplex.com/DotNetZip

bibliothèque de classes et ensemble d'outils pour manipuler les fichiers zip. Utilisez VB, C # ou tout autre langage .NET pour créer, extraire ou mettre à jour facilement des fichiers zip ...

DotNetZip fonctionne sur les PC avec le .NET Framework complet et fonctionne également sur les appareils mobiles qui utilisent le .NET Compact Framework. Créez et lisez des fichiers zip en VB, C #, ou n'importe quel langage .NET, ou n'importe quel environnement de script ...

Si tout ce que vous voulez, c'est une meilleure classe DeflateStream ou GZipStream pour remplacer celle qui est intégrée dans le .NET BCL, DotNetZip l'a aussi. DeflateStream et GZipStream de DotNetZip sont disponibles dans un assemblage autonome, basé sur un port .NET de Zlib. Ces flux prennent en charge les niveaux de compression et offrent des performances bien meilleures que les classes intégrées. Il y a aussi un ZlibStream pour compléter l'ensemble (RFC 1950, 1951, 1952) ...

String ZipPath = @"c:\my\data.zip";
String extractPath = @"d:\\myunzips";
ZipFile.ExtractToDirectory(ZipPath, extractPath);

Pour utiliser la classe ZipFile, vous devez ajouter une référence à l'assembly System.IO.Compression.FileSystem dans votre projet

Les fichiers zip standard utilisent normalement l'algorithme de dégonflage.

Pour extraire des fichiers sans utiliser de bibliothèques tierces, utilisez DeflateStream. Vous aurez besoin d'un peu plus d'informations sur le format d'archive du fichier zip car Microsoft ne fournit que l'algorithme de compression.

Vous pouvez également essayer d'utiliser zipfldr.dll. Il s'agit de la bibliothèque de compression de Microsoft (dossiers compressés à partir du menu Envoyer vers). Il semble que ce soit une bibliothèque de com mais elle n'est pas documentée. Vous pourrez peut-être le faire fonctionner pour vous grâce à l'expérimentation.

Je l'utilise pour compresser ou décompresser plusieurs fichiers. Le truc Regex n'est pas requis, mais je l'utilise pour changer le timbre à date et supprimer les traits de soulignement indésirables. J'utilise la chaîne vide dans la chaîne Compress >> zipPath pour préfixer quelque chose à tous les fichiers si nécessaire. En outre, je commente généralement Compress () ou Decompress () en fonction de ce que je fais.

using System;
using System.IO.Compression;
using System.IO;
using System.Text.RegularExpressions;

namespace ZipAndUnzip
{
    class Program
    {
        static void Main(string[] args)
        {
            var directoryPath = new DirectoryInfo(@"C:\your_path\");

            Compress(directoryPath);
            Decompress(directoryPath);
        }

        public static void Compress(DirectoryInfo directoryPath)
        {
            foreach (DirectoryInfo directory in directoryPath.GetDirectories())
            {
                var path = directoryPath.FullName;
                var newArchiveName = Regex.Replace(directory.Name, "[0-9]{8}", "20130913");
                newArchiveName = Regex.Replace(newArchiveName, "[_]+", "_");
                string startPath = path + directory.Name;
                string zipPath = path + "" + newArchiveName + ".zip";

                ZipFile.CreateFromDirectory(startPath, zipPath);
            }

        }

        public static void Decompress(DirectoryInfo directoryPath)
        {
            foreach (FileInfo file in directoryPath.GetFiles())
            {
                var path = directoryPath.FullName;
                string zipPath = path + file.Name;
                string extractPath = Regex.Replace(path + file.Name, ".zip", "");

                ZipFile.ExtractToDirectory(zipPath, extractPath);
            }
        }


    }
}

Cela le fera System.IO.Compression.ZipFile.ExtractToDirectory(ZipName, ExtractToPath)

D' ici :

Les objets GZipStream compressés écrits dans un fichier avec une extension .gz peuvent être décompressés à l'aide de nombreux outils de compression courants; cependant, cette classe ne fournit pas intrinsèquement des fonctionnalités pour ajouter ou extraire des fichiers à partir d'archives .zip.

Vous pouvez tout faire dans .NET 3.5 à l'aide de DeflateStream. La chose qui manque dans .NET 3.5 est la possibilité de traiter les sections d'en-tête de fichier utilisées pour organiser les fichiers zippés. PKWare a publié ces informations, que vous pouvez utiliser pour traiter le fichier zip après avoir créé les structures utilisées. Ce n'est pas particulièrement onéreux, et c'est une bonne pratique dans la construction d'outils sans utiliser de code tiers.

Ce n'est pas une réponse d'une seule ligne, mais c'est complètement faisable si vous êtes disposé et capable de prendre le temps vous-même. J'ai écrit une classe pour le faire en quelques heures et ce que j'ai obtenu c'est la possibilité de compresser et de décompresser des fichiers en utilisant .NET 3.5 uniquement.

J'ai découvert celui-ci (package Unzip sur NuGet) aujourd'hui, car j'ai rencontré un bogue dur dans DotNetZip, et j'ai réalisé qu'il n'y avait pas vraiment beaucoup de travail effectué sur DotNetZip au cours des deux dernières années.

Le paquet Unzip est maigre, et il a fait le travail pour moi - il n'avait pas le bug que DotNetZip avait. En outre, il s'agissait d'un fichier raisonnablement petit, s'appuyant sur le Microsoft BCL pour la décompression réelle. Je pouvais facilement faire les ajustements dont j'avais besoin (pour pouvoir suivre la progression pendant la décompression). Je le recommande.

De Embed Ressources:

using (Stream _pluginZipResourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(programName + "." + "filename.zip"))
{
    using (ZipArchive zip = new ZipArchive(_pluginZipResourceStream))
    {
        zip.ExtractToDirectory(Application.StartupPath);
    }
}

Jusqu'à présent, j'utilisais des processus cmd pour extraire un fichier .iso, le copier dans un chemin temporaire depuis le serveur et extrait sur une clé USB. Récemment, j'ai trouvé que cela fonctionnait parfaitement avec des .iso de moins de 10 Go. Pour une iso comme 29 Go, cette méthode est bloquée d'une manière ou d'une autre.

    public void ExtractArchive()
    {
        try
        {

            try
            {
                Directory.Delete(copyISOLocation.OutputPath, true); 
            }
            catch (Exception e) when (e is IOException || e is UnauthorizedAccessException)
            {
            }

            Process cmd = new Process();
            cmd.StartInfo.FileName = "cmd.exe";
            cmd.StartInfo.RedirectStandardInput = true;
            cmd.StartInfo.RedirectStandardOutput = true;
            cmd.StartInfo.CreateNoWindow = true;
            cmd.StartInfo.UseShellExecute = false;
            cmd.StartInfo.WindowStyle = ProcessWindowStyle.Normal;

            //stackoverflow
            cmd.StartInfo.Arguments = "-R";

            cmd.Disposed += (sender, args) => {
                Console.WriteLine("CMD Process disposed");
            };
            cmd.Exited += (sender, args) => {
                Console.WriteLine("CMD Process exited");
            };
            cmd.ErrorDataReceived += (sender, args) => {
                Console.WriteLine("CMD Process error data received");
                Console.WriteLine(args.Data);
            };
            cmd.OutputDataReceived += (sender, args) => {
                Console.WriteLine("CMD Process Output data received");
                Console.WriteLine(args.Data);
            };

            //stackoverflow


            cmd.Start();

            cmd.StandardInput.WriteLine("C:");
            //Console.WriteLine(cmd.StandardOutput.Read());
            cmd.StandardInput.Flush();

            cmd.StandardInput.WriteLine("cd C:\\\"Program Files (x86)\"\\7-Zip\\");
            //Console.WriteLine(cmd.StandardOutput.ReadToEnd());
            cmd.StandardInput.Flush();

            cmd.StandardInput.WriteLine(string.Format("7z.exe x -o{0} {1}", copyISOLocation.OutputPath, copyISOLocation.TempIsoPath));
            //Console.WriteLine(cmd.StandardOutput.ReadToEnd());
            cmd.StandardInput.Flush();
            cmd.StandardInput.Close();
            cmd.WaitForExit();
            Console.WriteLine(cmd.StandardOutput.ReadToEnd());
            Console.WriteLine(cmd.StandardError.ReadToEnd());

vous pouvez utiliser la ligne de commande Info-unzip cod.vous n'avez qu'à télécharger unzip.exe depuis le site officiel d'Info-unzip.

 internal static void Unzip(string sorcefile)
    {
        try
        {
            AFolderFiles.AFolderFilesDelete.DeleteFolder(TempBackupFolder); // delete old folder   
            AFolderFiles.AFolderFilesCreate.CreateIfNotExist(TempBackupFolder); // delete old folder   
           //need to Command command also to export attributes to a excel file
            System.Diagnostics.Process process = new System.Diagnostics.Process();
            System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
            startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden; // window type
            startInfo.FileName = UnzipExe;
            startInfo.Arguments = sorcefile + " -d " + TempBackupFolder;
            process.StartInfo = startInfo;
            process.Start();
            //string result = process.StandardOutput.ReadToEnd();
            process.WaitForExit();
            process.Dispose();
            process.Close();
        }
        catch (Exception ex){ throw ex; }
    }