Archiwa#

Archiwa to pliki będące kontenerami dla innych plików i folderów. Biblioteka standardowa C# pozwala na pracę z archiwami w formacie .zip poprzez klasy w przestrzeni nazw System.IO.Compression oraz w formacie .tar (od .NET 7) poprzez klasy w przestrzeni nazw System.Formats.Tar.

Archiwa ZIP#

Archiwa ZIP, oprócz grupowania plików, domyślnie oferują również kompresję danych.

Do prostych operacji służy statyczna klasa ZipFile, która pozwala na szybkie tworzenie archiwum z folderu (CreateFromDirectory) lub rozpakowywanie go (ExtractToDirectory).

const string sourceDirectory = "my_files_to_zip";
const string zipPath = "archive.zip";
const string extractPath = "extracted_files";

Directory.CreateDirectory(sourceDirectory);
File.WriteAllText(Path.Combine(sourceDirectory, "file1.txt"), "Hello");
Directory.CreateDirectory(Path.Combine(sourceDirectory, "subfolder"));
File.WriteAllText(Path.Combine(sourceDirectory, "subfolder", "file2.txt"), "World");

// Creating .zip archive (overwrite existing)
if (File.Exists(zipPath)) File.Delete(zipPath);
ZipFile.CreateFromDirectory(sourceDirectory, zipPath);

// Extracting archive (overwrite if files exist)
if (Directory.Exists(extractPath)) Directory.Delete(extractPath, true);
ZipFile.ExtractToDirectory(zipPath, extractPath);

Do bardziej zaawansowanych operacji służy metoda ZipFile.Open, która zwraca obiekt ZipArchive. Pozwala to na precyzyjną manipulację zawartością archiwum wpis po wpisie. Archiwum można otworzyć w jednym z trzech trybów: Read (odczyt), Create (tworzenie) lub Update (modyfikacja).

using ZipArchive zip = ZipFile.Open("archive.zip", ZipArchiveMode.Read);

Console.WriteLine("Archive content:");
foreach (ZipArchiveEntry entry in zip.Entries)
{
    Console.WriteLine($"{entry.FullName,-32} Size: {entry.Length} bytes");
}

Poniższa tabela przedstawia wybrane metody i właściwości, które pozwalają na precyzyjną manipulację archiwami po ich otwarciu.

Metoda lub właściwośćOpis
ZipArchive.EntriesPobiera kolekcję wszystkich wpisów (plików i folderów) znajdujących się w archiwum.
ZipArchive.CreateEntryTworzy nowy, pusty wpis w archiwum.
ZipArchive.GetEntryPobiera konkretny wpis z archiwum na podstawie jego nazwy.
ZipArchive.CreateEntryFromFile(Metoda rozszerzająca) Tworzy nowy wpis w archiwum na podstawie istniejącego pliku na dysku.
ZipArchive.ExtractToDirectory(Metoda rozszerzająca) Rozpakowuje całą zawartość archiwum do określonego folderu.
ZipArchiveEntry.DeleteUsuwa bieżący wpis z archiwum.
ZipArchiveEntry.OpenOtwiera strumień do zawartości wpisu, umożliwiając jego odczyt lub zapis.
ZipArchiveEntry.ExtractToFile(Metoda rozszerzająca) Rozpakowuje bieżący wpis do pliku na dysku.

Asynchroniczne API (.NET 10)#

Od .NET 10 archiwa ZIP można też przetwarzać asynchronicznie, bez blokowania wątku podczas operacji wejścia/wyjścia: ZipFile.CreateFromDirectoryAsync, ZipFile.ExtractToDirectoryAsync, ZipFile.OpenAsync, ZipFile.OpenReadAsync, ZipArchive.CreateAsync, ZipArchiveEntry.OpenAsync oraz metody rozszerzające CreateEntryFromFileAsync, ExtractToFileAsync, ExtractToDirectoryAsync. ZipArchive implementuje również IAsyncDisposable.

if (File.Exists("archive.zip")) File.Delete("archive.zip");
await ZipFile.CreateFromDirectoryAsync("my_files_to_zip", "archive.zip");

await using ZipArchive zip = await ZipFile.OpenReadAsync("archive.zip");
foreach (ZipArchiveEntry entry in zip.Entries)
{
    await using Stream stream = await entry.OpenAsync();
    using StreamReader reader = new StreamReader(stream);
    Console.WriteLine($"{entry.FullName}: {await reader.ReadToEndAsync()}");
}

Archiwa TAR (.NET 7)#

Format TAR (Tape Archive) jedynie grupuje pliki w jeden kontener, ale sam w sobie nie stosuje kompresji. Jego zaletą jest obsługa atrybutów systemów uniksowych. W praktyce archiwa .tar są często dodatkowo kompresowane za pomocą algorytmów GZip, Brotli lub BZip2 (niedostępny w bibliotece standardowej), co daje pliki z rozszerzeniami .tar.gz (lub .tgz) oraz .tar.br.

Podobnie jak w przypadku ZIP, klasa TarFile udostępnia proste w użyciu metody CreateFromDirectory i ExtractToDirectory.

const string sourceDirectory = "my_files_to_tar";
const string tarPath = "archive.tar";

Directory.CreateDirectory(sourceDirectory);
File.WriteAllText(Path.Combine(sourceDirectory, "log.txt"), "Log entry");

// Creating .tar archive
if (File.Exists(tarPath)) File.Delete(tarPath);
TarFile.CreateFromDirectory(sourceDirectory, tarPath, false);

Podobnie, do rozpakowywania archiwów służy metoda ExtractToDirectory. W odróżnieniu od ZipFile, wymaga ona, aby folder docelowy istniał.

const string tarPath = "archive.tar";
const string extractPath = "extracted_tar_files";

// Extracting .tar archive
if (Directory.Exists(extractPath)) Directory.Delete(extractPath, true);
Directory.CreateDirectory(extractPath);
TarFile.ExtractToDirectory(tarPath, extractPath, false);

Aby utworzyć skompresowane archiwum .tar.gz, należy podczas tworzenia archiwum zamiast ścieżki podać strumień z nałożoną kompresją:

// Creating .tar.gz archive
using FileStream fileStream = new("archive.tar.gz", FileMode.Create);
using GZipStream gzipStream = new(fileStream, CompressionMode.Compress);
TarFile.CreateFromDirectory(sourceDirectory, gzipStream, false);

Aby rozpakować skompresowane archiwum (np. .tar.gz), należy użyć odpowiedniego strumienia dekompresującego.

const string sourceArchive = "archive.tar.gz";
const string destinationDirectory = "extracted_targz_files";

if (Directory.Exists(destinationDirectory)) Directory.Delete(destinationDirectory, true);
Directory.CreateDirectory(destinationDirectory);

// Extracting .tar.gz archive
using FileStream fileStream = File.OpenRead(sourceArchive);
using GZipStream gzipStream = new(fileStream, CompressionMode.Decompress);
TarFile.ExtractToDirectory(gzipStream, destinationDirectory, false);

TarWriter i TarReader#

Do bardziej precyzyjnej pracy, wpis po wpisie (podobnie jak w przypadku ZipArchive), służą klasy TarWriter i TarReader. Operują one na strumieniach, więc można je łączyć również ze strumieniami kompresującymi:

// Creating .tar.gz archive entry by entry
using (FileStream fs = File.Create("logs.tar.gz"))
using (GZipStream gz = new GZipStream(fs, CompressionMode.Compress))
using (TarWriter writer = new TarWriter(gz))
{
    // Entry from a file on disk
    writer.WriteEntry(Path.Combine("my_files_to_tar", "log.txt"), entryName: "logs/log.txt");

    // Entry with data from a stream
    var entry = new PaxTarEntry(TarEntryType.RegularFile, "logs/info.txt")
    {
        DataStream = new MemoryStream("Hello from TarWriter"u8.ToArray())
    };
    writer.WriteEntry(entry);
}

// Reading .tar.gz archive entry by entry
using (FileStream fs = File.OpenRead("logs.tar.gz"))
using (GZipStream gz = new GZipStream(fs, CompressionMode.Decompress))
using (TarReader reader = new TarReader(gz))
{
    while (reader.GetNextEntry() is TarEntry entry)
    {
        Console.WriteLine($"{entry.Name,-16} {entry.Length,3} bytes, mode: {entry.Mode}");
        // entry.DataStream - entry contents, entry.ExtractToFile(...) - extracting to disk
    }
}
logs/log.txt       9 bytes, mode: OtherRead, GroupRead, UserWrite, UserRead
logs/info.txt     20 bytes, mode: OtherRead, GroupRead, UserWrite, UserRead