Hacer un archivo ZIP plano

Su archivo zip puede tener otros archivos zip dentro. Es posible que desee extraer el contenido del archivo zip anidado en el archivo principal para obtener una estructura plana.

Estructura de archivo actual

outer.zip
 ├first.txt
 ├inner.zip
 │ ├game.exe
 │ └subitem.bin
 └picture.gif

Estructura de archivo deseada

flatten.zip
 ├first.txt
 ├picture.gif
 ├game.exe
 └subitem.bin

Si no está familiarizado con Aspose.Zip, lea primero cómo extraer archivo zip.

Explicación general

Primero, necesitamos enumerar todas las entradas del archivo. Las entradas regulares deben mantenerse tal como están, ni siquiera debemos descomprimirlas. Las entradas que son archivos en sí mismas deben extraerse a la memoria y eliminarse del archivo externo. Su contenido debe incluirse en el archivo principal.

Detección de entradas que son archivos

Decidamos qué entradas son archivos en sí. Podemos resolver esto por la extensión del nombre de la entrada. Más adelante eliminaremos esas entradas del archivo principal, así que manténgalas en una lista.

if (entry.Name.EndsWith(".zip", StringComparison.InvariantCultureIgnoreCase)) {
    entriesToDelete.Add(entry);
    ...
}

Extrayendo el contenido de la entrada a la memoria

Aspose.Zip permite extraer el contenido de la entrada zip en cualquier flujo de escritura, no solo en un archivo. Entonces, podemos extraer un archivo anidado a una secuencia de memoria.

Tenga en cuenta: la memoria virtual debe ser lo suficientemente grande para guardar todo el contenido extraído.

MemoryStream innerCompressed = new MemoryStream();
entry.Open().CopyTo(innerCompressed); 

Después de eso, la secuencia internalCompressed contiene el archivo interno en sí. El Constructor de archivo permite descomprimir la secuencia proporcionada. Entonces, podemos extraerlo también:

Archive inner = new Archive(innerCompressed);

Excluyendo entradas

Podemos eliminar una entrada del archivo zip con método particular.

foreach (ArchiveEntry e in entriesToDelete) { outer.DeleteEntry(e); }

Ponlo todo junto

Aquí está el algoritmo completo.

    using (Archive outer = new Archive("outer.zip"))
    {
        List<ArchiveEntry> entriesToDelete = new List<ArchiveEntry>();
        List<string> namesToInsert = new List<string>();
        List<MemoryStream> contentToInsert = new List<MemoryStream>();

        foreach (ArchiveEntry entry in outer.Entries)
        {
            if (entry.Name.EndsWith(".zip", StringComparison.InvariantCultureIgnoreCase)) // Find an entry which is an archive itself
            {
                entriesToDelete.Add(entry); // Keep reference to the entry in order to remove it from the archive later
                MemoryStream innerCompressed = new MemoryStream();
                entry.Open().CopyTo(innerCompressed); //This extracts the entry to a memory stream

                using (Archive inner = new Archive(innerCompressed)) // We know that content of the entry is an zip archive so we may extract
                {
                    foreach (ArchiveEntry ie in inner.Entries) // Loop over entries of inner archive
                    {
                        namesToInsert.Add(ie.Name); // Keep the name of inner entry.
                        MemoryStream content = new MemoryStream();
                        ie.Open().CopyTo(content);
                        contentToInsert.Add(content); // Keep the content of inner entry.
                    }
                }
            }
        }

        foreach (ArchiveEntry e in entriesToDelete) 
            outer.DeleteEntry(e); // Delete all the entries which are archives itself

        for (int i = 0; i < namesToInsert.Count; i++)    
            outer.CreateEntry(namesToInsert[i], contentToInsert[i]); // Adds entries which were entries of inner archives
        
        outer.Save("flatten.zip");
    }