logo
Helpful resources ▼
  Nuget   Pricing   Buy

Dateien in .NET komprimieren oder entpacken

Überblick

In diesem Artikel erfahren Sie, wie Sie Zip-Dateien mit verschiedenen Methoden unter Verwendung von C# oder der.NET-API und Beispielcode programmgesteuert komprimieren. Sie erfahren, wie Sie eine oder mehrere Dateien komprimieren oder komprimieren und wie Sie Dateien gleichzeitig komprimieren. Außerdem erfahren Sie, wie Sie Dateien dekomprimieren oder entpacken.

Dateien in C# komprimieren oder komprimieren und Dateien in C# dekomprimieren oder entpacken

Mit der Aspose.ZIP-API können Sie Dateien komprimieren und dekomprimieren, ohne sich Gedanken über die zugrunde liegende Dateistruktur machen zu müssen. In diesem Artikel wird das Arbeiten mit Einzel- und Mehrfachdateikomprimierung beschrieben.

Dateien komprimieren

Einzelne Datei komprimieren

Schritte: Komprimieren einer einzelnen Datei in C#

  1. Erstellen Sie einen Dateistream mit dem gewünschten Namen Ihrer Ausgabe-ZIP-Datei.
  2. Erstellen Sie einen Dateistream der zu komprimierenden Datendatei.
  3. Erstellen Sie eine Instanz der Klasse Archive und übergeben Sie ihr eine Instanz der Klasse ArchiveEntrySettings.
  4. Fügen Sie die in Schritt 2 erstellte Datendatei mit der Methode Archive.CreateEntry hinzu.
  5. Zippen Sie die Datendatei mit der Methode Archive.Save und übergeben Sie ihr den in Schritt 1 erstellten Dateistream.
 1    // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
 2    using (FileStream zipFile = File.Open(dataDir + "CompressSingleFile_out.zip", FileMode.Create))
 3    {
 4        //File to be added to archive
 5        using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
 6        {
 7            using (var archive = new Archive(new ArchiveEntrySettings()))
 8            {
 9                archive.CreateEntry("alice29.txt", source1);
10                
11                archive.Save(zipFile);
12            }
13        }
14    }

Komprimieren mehrerer Dateien

Schritte: Komprimieren mehrerer Dateien in C#

  1. Erstellen Sie einen Dateistream mit dem gewünschten Namen Ihrer Ausgabe-ZIP-Datei.
  2. Erstellen Sie einen Dateistream der ersten zu komprimierenden Datendatei.
  3. Erstellen Sie einen Dateistream der zweiten zu komprimierenden Datendatei.
  4. Erstellen Sie eine Instanz der Klasse Archive.
  5. Fügen Sie die in Schritt 2 und Schritt 3 erstellten Datendateien mit der Methode Archive.CreateEntry hinzu.
  6. Erstellen Sie eine Instanz der Klasse ArchiveSaveOptions.
  7. Zippen Sie die Datendateien mit der Methode Archive.Save und übergeben Sie ihr den in Schritt 1 erstellten Dateistream und die im obigen Schritt erstellte Instanz von ArchiveSaveOptions.
 1    // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
 2    using (FileStream zipFile = File.Open(dataDir + "CompressMultipleFiles_out.zip", FileMode.Create))
 3    {
 4        using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
 5        {
 6            using (FileStream source2 = File.Open(dataDir + "asyoulik.txt", FileMode.Open, FileAccess.Read))
 7            {
 8                using (var archive = new Archive())
 9                {
10                    archive.CreateEntry("alice29.txt", source1);
11                    archive.CreateEntry("asyoulik.txt", source2);
12                    archive.Save(zipFile, new ArchiveSaveOptions() { Encoding = Encoding.ASCII, ArchiveComment = "There are two poems from Canterbury corpus" });
13                }
14            }
15        }
16    }
17

Dateien nach Dateiinformationen komprimieren

Schritte: Dateien nach Dateiinformationen komprimieren in C#

  1. Öffnen Sie mit FileMode.Create einen Dateistream mit dem gewünschten Namen Ihrer Ausgabe-ZIP-Datei.
  2. Erstellen Sie das Objekt FileInfo Ihrer ersten zu komprimierenden Datendatei.
  3. Erstellen Sie ein FileInfo-Objekt Ihrer zweiten zu komprimierenden Datendatei.
  4. Erstellen Sie eine Instanz der Klasse Archive.
  5. Fügen Sie die in Schritt 2 und Schritt 3 erstellten Datendateien mit der Methode Archive.CreateEntry hinzu.
  6. Erstellen Sie eine Instanz der Klasse ArchiveSaveOptions.
  7. Komprimieren Sie die Datendateien mit der Methode Archive.Save und übergeben Sie ihr den in Schritt 1 erstellten Dateistream und die im obigen Schritt erstellte Instanz von ArchiveSaveOptions.
 1    // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
 2    using (FileStream zipFile = File.Open(dataDir + "CompressFilesByFileInfo_out.zip", FileMode.Create))
 3    {
 4        FileInfo fi1 = new FileInfo(dataDir + "alice29.txt");
 5        FileInfo fi2 = new FileInfo(dataDir + "fields.c");
 6
 7        using (var archive = new Archive())
 8        {
 9            archive.CreateEntry("alice29.txt", fi1);
10            archive.CreateEntry("fields.c", fi2);
11            archive.Save(zipFile, new ArchiveSaveOptions() { Encoding = Encoding.ASCII });
12        }
13    }
14

Dateien ohne Komprimierung in Archiven speichern

Schritte: Speichern Dateien in Archiven ohne Komprimierung mit C#1. Öffnen Sie mit FileMode.Create einen Dateistream mit dem gewünschten Namen Ihrer Ausgabe-ZIP-Datei. 2. Erstellen Sie FileInfo-Objekte für Ihre Datendateien, die im Archiv gespeichert werden sollen. 3. Erstellen Sie eine Instanz der Klasse ArchiveEntrySettings und übergeben Sie ihr eine Instanz der Klasse StoreCompressionSettings. 4. Erstellen Sie eine Instanz der Klasse Archive und übergeben Sie ihr die im obigen Schritt erstellte Instanz der Klasse ArchiveEntrySettings. 5. Fügen Sie in Schritt 2 erstellte FileInfo-Objekte mit der Methode Archive.CreateEntry hinzu. 6. Erstellen Sie eine Instanz von ArchiveSaveOptions und legen Sie Encoding = Encoding.ASCII fest. 7. Zippen Sie die Datendateien mit der Methode Archive.Save und übergeben Sie ihr den in Schritt 1 erstellten Dateistream und die im obigen Schritt erstellte Instanz von ArchiveSaveOptions.

 1    // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
 2    //Creates zip archive without compressing files
 3    using (FileStream zipFile = File.Open(dataDir + "StoreMultipleFilesWithoutCompression_out.zip", FileMode.Create))
 4    {
 5        FileInfo fi1 = new FileInfo(dataDir + "alice29.txt");
 6        FileInfo fi2 = new FileInfo(dataDir + "lcet10.txt");
 7
 8        using (Archive archive = new Archive(new ArchiveEntrySettings(new StoreCompressionSettings())))
 9        {
10            archive.CreateEntry("alice29.txt", fi1);
11            archive.CreateEntry("lcet10.txt", fi2);
12            archive.Save(zipFile, new ArchiveSaveOptions() { Encoding = Encoding.ASCII });
13        }
14
15    }
16

Parallelität zum Komprimieren von Dateien verwenden

Schritte: Verwenden von Parallelität zum Komprimieren von Dateien mit C#

  1. Öffnen Sie mit FileMode.Create einen Dateistream mit dem gewünschten Namen Ihrer Ausgabe-ZIP-Datei.
  2. Öffnen Sie Dateistreams mit FileMode.Open und FileAccess.Read für Ihre erste und zweite Datendatei, die komprimiert werden soll.
  3. Erstellen Sie eine Instanz der Klasse Archive.
  4. Fügen Sie die in Schritt 2 erstellten Datendateien mit der Methode Archive.CreateEntry hinzu.
  5. Erstellen Sie eine Instanz von ParallelOptions und legen Sie ParallelCompressInMemory = ParallelCompressionMode.Always fest.
  6. Erstellen Sie eine Instanz von ArchiveSaveOptions und legen Sie deren Eigenschaft ParallelOptions mit der obigen Instanz fest.
  7. Zippen Sie die Datendateien mit der Methode Archive.Save und übergeben Sie ihr den in Schritt 1 erstellten Dateistream und die im obigen Schritt erstellte Instanz von ArchiveSaveOptions.
 1    // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
 2    using (FileStream zipFile = File.Open(dataDir + "UsingParallelismToCompressFiles_out.zip", FileMode.Create))
 3    {
 4        using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
 5        {
 6            using (FileStream source2 = File.Open(dataDir + "asyoulik.txt", FileMode.Open, FileAccess.Read))
 7            {
 8                using (var archive = new Archive())
 9                {
10                    archive.CreateEntry("alice29.txt", source1);
11                    archive.CreateEntry("asyoulik.txt", source2);
12                    //Define the parallelism criterion
13                    var parallelOptions = new ParallelOptions
14                    {
15                        ParallelCompressInMemory = ParallelCompressionMode.Always
16                    };
17                    archive.Save(zipFile,
18                        new ArchiveSaveOptions()
19                        {
20                            ParallelOptions = parallelOptions,
21                            Encoding = Encoding.ASCII,
22                            ArchiveComment = "There are two poems from Canterbury corpus"
23                        });
24                }
25            }
26        }
27    }
28

LZMA-Komprimierung im ZIP-Archiv

Der Lempel-Ziv-Markov-Kettenalgorithmus (LZMA) ist ein Algorithmus, der zur Durchführung einer verlustfreien Datenkomprimierung verwendet wird. LZMA verwendet einen Wörterbuchkomprimierungsalgorithmus. Der komprimierte Stream ist ein Bitstrom. Durch die LZMA-Komprimierung innerhalb des ZIP-Archivs können ZIP-Container LZMA-komprimierte Einträge enthalten. Das folgende Codebeispiel zeigt die Implementierung der LZMA-Komprimierung mithilfe der Aspose.ZIP-API.

Schritte: LZMA-Komprimierung im ZIP-Archiv mit C#

  1. Öffnen Sie mit FileMode.Create einen Dateistream mit dem gewünschten Namen Ihrer Ausgabe-ZIP-Datei.
  2. Erstellen Sie eine Instanz von ArchiveEntrySettings und übergeben Sie ihr die Instanz der Klasse LzmaCompressionSettings.
  3. Erstellen Sie eine Instanz der Klasse Archive und übergeben Sie ihr die oben erstellte Instanz von ArchiveEntrySettings.
  4. Fügen Sie zu komprimierende Datendateien über Dateipfade mit der Methode Archive.CreateEntry hinzu.
  5. Komprimieren Sie die Datendateien mit der Methode Archive.Save.
1    using (FileStream zipFile = File.Open(dataDir + "LZMACompression_out.zip", FileMode.Create))
2    {
3        using (Archive archive = new Archive(new ArchiveEntrySettings(new LzmaCompressionSettings())))
4        {
5            archive.CreateEntry("sample.txt", dataDir + "sample.txt");
6            archive.Save(zipFile);
7        }
8    }

BZip2-Komprimierung innerhalb des ZIP-Archivs

Die BZip2-Komprimierungseinstellungen ermöglichen es dem ZIP-Container, BZip2-komprimierte Einträge zu enthalten. Das folgende Codebeispiel zeigt die Implementierung der BZip2-Komprimierung mithilfe der Aspose.ZIP-API.

Schritte: BZip2-Komprimierung im ZIP-Archiv mit C#

  1. Öffnen Sie mit FileMode.Create einen Dateistream mit dem gewünschten Namen Ihrer Ausgabe-ZIP-Datei.
  2. Erstellen Sie eine Instanz von ArchiveEntrySettings und übergeben Sie ihr die Instanz der Klasse Bzip2CompressionSettings.
  3. Erstellen Sie eine Instanz der Klasse Archive und übergeben Sie ihr die oben erstellte Instanz von ArchiveEntrySettings.
  4. Fügen Sie die zu komprimierenden Datendateien über Dateipfade mit der Methode Archive.CreateEntry hinzu.
  5. Komprimieren Sie die Datendateien mit der Methode Archive.Save.
1    using (FileStream zipFile = File.Open(dataDir + "Bzip2Compression_out.zip", FileMode.Create))
2    {
3        using (Archive archive = new Archive(new ArchiveEntrySettings(new Bzip2CompressionSettings())))
4        {
5            archive.CreateEntry("sample.txt", dataDir + "sample.txt");
6            archive.Save(zipFile);
7        }
8    }    
9

PPMd-Komprimierung innerhalb des ZIP-Archivs

Die PPMd-Komprimierungseinstellungen ermöglichen es dem ZIP-Container, PPMd-komprimierte Einträge zu enthalten. Das folgende Codebeispiel demonstrierte die Implementierung der PPMd-Komprimierung mithilfe der Aspose.ZIP-API.

Schritte: PPMd-Komprimierung innerhalb des ZIP-Archivs mit C#

  1. Öffnen Sie mit FileMode.Create einen Dateistream mit dem gewünschten Namen Ihrer Ausgabe-ZIP-Datei.
  2. Erstellen Sie eine Instanz von ArchiveEntrySettings und übergeben Sie ihr die Instanz der Klasse PPMdCompressionSettings.
  3. Erstellen Sie eine Instanz der Klasse Archive und übergeben Sie ihr die oben erstellte Instanz von ArchiveEntrySettings.
  4. Fügen Sie zu komprimierende Datendateien über Dateipfade mit der Methode Archive.CreateEntry hinzu.
  5. Komprimieren Sie die Datendateien mit der Methode Archive.Save.
1    using (FileStream zipFile = File.Open(dataDir + "PPMdCompression_out.zip", FileMode.Create))
2    {
3        using (Archive archive = new Archive(new ArchiveEntrySettings(new PPMdCompressionSettings())))
4        {
5            archive.CreateEntry("sample.txt", dataDir + "sample.txt");
6            archive.Save(zipFile);
7        }
8    }    
9

Archive dekomprimieren

Archiv mit einer einzelnen Datei dekomprimieren

Schritte: Dekomprimieren einer einzelnen Datei aus einem Archiv mit C#

  1. Öffnen Sie mit FileMode.OpenRead einen Dateistream für die ZIP-Eingabedatei.
  2. Erstellen Sie eine Instanz der Archive-Klasse, indem Sie den Dateistream an den Konstruktor übergeben.
  3. Überwachen Sie den Dekomprimierungsfortschritt mithilfe des ExtractionProgressed-Ereignisses des Archiveintrags.
  4. Extrahieren Sie die einzelne Datei mit der Extract-Methode aus dem Archiv und geben Sie dabei den Pfad der Ausgabedatei an.
  5. Zeigen Sie den Dekomprimierungsfortschritt in Prozent in der Konsole an
 1    // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
 2    using (FileStream fs = File.OpenRead(dataDir + "CompressSingleFile_out.zip"))
 3    {
 4        using (Archive archive = new Archive(fs))
 5        {
 6            int percentReady = 0;
 7            archive.Entries[0].ExtractionProgressed += (s, e) =>
 8            {
 9                int percent = (int)((100 * e.ProceededBytes) / ((ArchiveEntry)s).UncompressedSize);
10                if (percent > percentReady)
11                {
12                    Console.WriteLine(string.Format("{0}% decompressed", percent));
13                    percentReady = percent;
14                }
15            };
16            archive.Entries[0].Extract(dataDir + "alice_extracted_out.txt");
17        }
18    }    
19

Archiv mit mehreren Dateien dekomprimieren

Schritte: Mehrere Dateien aus einem Archiv mit C# dekomprimieren< /strong>

  1. Öffnen Sie mit FileMode.Open einen Dateistream für die ZIP-Eingabedatei.
  2. Erstellen Sie eine Instanz der Archive-Klasse mit benutzerdefinierten Ladeoptionen, um Einträge aufzulisten und den Dekomprimierungsfortschritt zu verfolgen.
  3. Zeigen Sie die Namen aller Archiveinträge mithilfe des EntryListed-Ereignisses an.
  4. Überwachen Sie den Dekomprimierungsfortschritt mit dem Ereignis „EntryExtractionProgressed“ und zeigen Sie den Fortschritt in der Konsole an.
  5. Extrahieren Sie mehrere Dateien aus dem Archiv, indem Sie die Extract-Methode verwenden und Daten in die Ausgabedateien einlesen.
 1    // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
 2    using (FileStream zipFile = File.Open(dataDir + "CompressMultipleFiles_out.zip", FileMode.Open))
 3    {
 4        StringBuilder sb = new StringBuilder("Entries are: ");
 5        int percentReady = 0;
 6        using (Archive archive = new Archive(zipFile,
 7            new ArchiveLoadOptions()
 8            {
 9                EntryListed = (s, e) => { sb.AppendFormat("{0}, ", e.Entry.Name); },
10                EntryExtractionProgressed = (s, e) =>
11                {
12                    int percent = (int)((100 * e.ProceededBytes) / ((ArchiveEntry)s).UncompressedSize);
13                    if (percent > percentReady)
14                    {
15                        Console.WriteLine(string.Format("{0}% compressed", percent)); percentReady = percent;
16                    }
17                }
18            }))
19        {
20            Console.WriteLine(sb.ToString(0, sb.Length - 2));
21            using (var extracted = File.Create(dataDir + "alice_extracted_out.txt"))
22            {
23                using (var decompressed = archive.Entries[0].Open())
24                {
25                    byte[] buffer = new byte[8192];
26                    int bytesRead;
27                    while (0 < (bytesRead = decompressed.Read(buffer, 0, buffer.Length)))
28                    {
29                        extracted.Write(buffer, 0, bytesRead);
30                    }
31                    // Read from decompressed stream to extracting file.
32                }
33            }
34            percentReady = 0;
35            archive.Entries[1].Extract(dataDir + "asyoulik_extracted_out.txt");
36        }
37    }    
38

Gespeichertes Archiv ohne Komprimierung extrahieren

Schritte: Extrahieren Sie Dateien aus einem Archiv und speichern Sie sie auf der Festplatte mit C#

  1. Öffnen Sie die ZIP-Datei und erstellen Sie eine Instanz der Archive-Klasse.
  2. Extrahieren Sie die erste Datei aus dem Archiv, indem Sie den Stream des Eintrags öffnen und seinen Inhalt in eine neue Datei schreiben.
  3. Verwenden Sie einen Puffer, um Daten aus dem dekomprimierten Stream zu lesen und in der Ausgabedatei zu speichern.
  4. Wiederholen Sie den Vorgang für die zweite Datei im Archiv und schreiben Sie deren Inhalt in eine separate Ausgabedatei.
 1    // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
 2    using (FileStream zipFile = File.Open(dataDir + "StoreMultipleFilesWithoutCompression_out.zip", FileMode.Open))
 3    {
 4        using (Archive archive = new Archive(zipFile))
 5        {
 6            using (var extracted = File.Create(dataDir + "alice_extracted_store_out.txt"))
 7            {
 8                using (var decompressed = archive.Entries[0].Open())
 9                {
10                    byte[] buffer = new byte[8192];
11                    int bytesRead;
12                    while (0 < (bytesRead = decompressed.Read(buffer, 0, buffer.Length)))
13                    {
14                        extracted.Write(buffer, 0, bytesRead);
15                    }
16                    // Read from decompressed stream to extracting file.
17                }
18            }
19
20            using (var extracted = File.Create(dataDir + "asyoulik_extracted_store_out.txt"))
21            {
22                using (var decompressed = archive.Entries[1].Open())
23                {
24                    byte[] buffer = new byte[8192];
25                    int bytesRead;
26                    while (0 < (bytesRead = decompressed.Read(buffer, 0, buffer.Length)))
27                    {
28                        extracted.Write(buffer, 0, bytesRead);
29                    }
30                    // Read from decompressed stream to extracting file.
31                }
32            }
33        }
34    }    
35
Arbeiten mit 7z-Archiven Erstellen Sie ein flaches ZIP-Archiv
Subscribe to Aspose Product Updates

Get monthly newsletters & offers directly delivered to your mailbox.

© Aspose Pty Ltd 2001-2024. All Rights Reserved.