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