descomprimir - ziparchive c#

Descomprima archivos mediante programación en.net

Question

Estoy tratando de descomprimir programáticamente un archivo comprimido.

He intentado utilizar la clase System.IO.Compression.GZipStream en .NET, pero cuando se ejecuta mi aplicación (en realidad, una prueba de unidad) obtengo esta excepción:

System.IO.InvalidDataException: el número mágico en el encabezado GZip no es correcto. Asegúrate de pasar en una transmisión de GZip.

Ahora me doy cuenta de que un archivo .zip no es lo mismo que un archivo .gz , y que GZip no es lo mismo que Zip .

Sin embargo, dado que soy capaz de extraer el archivo haciendo doble clic manualmente en el archivo comprimido y luego haciendo clic en el botón "Extraer todos los archivos", creo que también debería haber una forma de hacerlo en el código.

Por lo tanto, he intentado utilizar Process.Start() con la ruta al archivo comprimido como entrada. Esto hace que mi aplicación abra una ventana que muestra los contenidos en el archivo comprimido. Eso está bien, pero la aplicación se instalará en un servidor sin ninguno para hacer clic en el botón "Extraer todos los archivos".

Entonces, ¿cómo obtengo mi aplicación para extraer los archivos en los archivos comprimidos?

¿O hay otra forma de hacerlo? Prefiero hacerlo en código, sin descargar ninguna biblioteca o aplicación de terceros; el departamento de seguridad no es demasiado elegante sobre eso ...

Answer 1

Con .NET 4.5 ahora puede descomprimir archivos usando .NET framework:

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);
    }
  }
}

El código anterior fue tomado directamente de la documentación de Microsoft: http://msdn.microsoft.com/en-us/library/ms404280(v=vs.110).aspx

ZipFile está contenido en el ensamblado System.IO.Compression.FileSystem . (Gracias nateirvin ... ver comentario a continuación)

Answer 2

De los recursos incrustados:

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

Answer 3

Descubrí esto (Descomprimir paquete en NuGet) hoy, ya que encontré un error en DotNetZip, y me di cuenta de que realmente no se había trabajado tanto en DotNetZip durante los últimos dos años.

El paquete Unzip es delgado, y me sirvió - no tenía el error que tenía DotNetZip. Además, era un archivo razonablemente pequeño, confiando en el BCL de Microsoft para la descompresión real. Fácilmente podía hacer los ajustes que necesitaba (para poder seguir el progreso mientras descomprimía). Lo recomiendo.

Answer 4

Desde here :

Los objetos comprimidos de GZipStream escritos en un archivo con una extensión de .gz se pueden descomprimir usando muchas herramientas de compresión comunes; sin embargo, esta clase no proporciona inherentemente la funcionalidad para agregar archivos o extraer archivos de archivos .zip.

Answer 5

Gratis, y sin archivos DLL externos. Todo está en un archivo CS. Una descarga es solo el archivo CS, otra descarga es un ejemplo muy fácil de entender. Lo intenté hoy y no puedo creer lo simple que fue la configuración. Funcionó en el primer intento, sin errores, sin nada.

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

Answer 6

Hasta ahora, estaba usando procesos cmd para extraer un archivo .iso, copiarlo en una ruta temporal desde el servidor y extraerlo en un dispositivo USB. Recientemente he descubierto que esto funciona perfectamente con .iso que son menos de 10 Gb. Para una ISO como 29 Gb este método se atasca de alguna manera.

    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;

            //
            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);
            };

            //


            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());

Answer 7

Hemos utilizado SharpZipLib éxito en muchos proyectos. Sé que es una herramienta de terceros, pero el código fuente está incluido y podría proporcionar alguna información si decide reinventar la rueda aquí.

Answer 8

Lo uso para comprimir o descomprimir varios archivos. Las cosas Regex no son necesarias, pero las utilizo para cambiar el sello de fecha y eliminar los caracteres de subrayado no deseados. Uso la cadena vacía en la cadena Comprimir >> zipPath para prefijar algo a todos los archivos si es necesario. Además, suelo comentar Compress () o Decompress () en función de lo que estoy haciendo.

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);
            }
        }


    }
}

Answer 9

Los archivos zip estándar normalmente usan el algoritmo de desinflado.

Para extraer archivos sin utilizar bibliotecas de terceros, use DeflateStream. Necesitará un poco más de información sobre el formato de archivo de archivo zip ya que Microsoft solo proporciona el algoritmo de compresión.

También puede intentar usar zipfldr.dll. Es la biblioteca de compresión de Microsoft (carpetas comprimidas del menú Enviar a). Parece ser una biblioteca de com pero no está documentada. Es posible que pueda hacer que funcione para usted a través de la experimentación.

Answer 10

Puedes hacerlo todo dentro de .NET 3.5 usando DeflateStream. Lo que falta en .NET 3.5 es la capacidad de procesar las secciones del encabezado del archivo que se utilizan para organizar los archivos comprimidos. PKWare ha publicado esta información, que puede utilizar para procesar el archivo zip después de crear las estructuras que se utilizan. No es particularmente oneroso, y es una buena práctica en la construcción de herramientas sin usar código de terceros.

No es una respuesta de una sola línea, pero es completamente factible si está dispuesto y puede tomarse el tiempo usted mismo. Escribí una clase para hacer esto en un par de horas y lo que obtuve de eso es la capacidad de comprimir y descomprimir archivos usando .NET 3.5 solamente.

Answer 11

Use la biblioteca DotNetZip en http://www.codeplex.com/DotNetZip

biblioteca de clases y conjunto de herramientas para manipular archivos zip. Use VB, C # o cualquier lenguaje .NET para crear, extraer o actualizar archivos zip fácilmente ...

DotNetZip funciona en PC con .NET Framework completo, y también se ejecuta en dispositivos móviles que usan .NET Compact Framework. Cree y lea archivos zip en VB, C # o cualquier lenguaje .NET, o cualquier entorno de scripts ...

Si todo lo que quiere es una mejor clase DeflateStream o GZipStream para reemplazar la que está incorporada en .NET BCL, DotNetZip también lo tiene. Los sistemas DeflateStream y GZipStream de DotNetZip están disponibles en un ensamblaje independiente, basado en un puerto .NET de Zlib. Estas secuencias admiten niveles de compresión y ofrecen un rendimiento mucho mejor que las clases integradas. También hay un ZlibStream para completar el set (RFC 1950, 1951, 1952) ...

Answer 12

Para .Net 4.5+

No siempre se desea escribir el archivo descomprimido en el disco. Como desarrollador de ASP.Net, tendría que jugar con permisos para otorgar derechos para que mi aplicación escriba en el sistema de archivos. Al trabajar con streams en la memoria, puedo eludir todo eso y leer los archivos directamente:

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

Alternativamente, aún puede escribir el archivo descomprimido en el disco llamando a ExtractToFile() :

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

Para usar la clase ZipArchive , deberá agregar una referencia al espacio de nombres System.IO.Compression .

Answer 13

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

Para usar la clase ZipFile, debe agregar una referencia al ensamblado System.IO.Compression.FileSystem en su proyecto