Améliorations des API Zip et GZip asynchrones dans .NET 10

.NET 10 introduit de nouvelles APIs asynchrones pour travailler avec les archives ZIP et améliore significativement les performances des opérations de compression et décompression, notamment pour les archives volumineuses et les flux GZip concaténés.

Améliorations majeures

• Nouvelles méthodes async pour les opérations non-bloquantes

• Meilleures performances I/O asynchrones et parallélisation de l'extraction

• Support optimisé des flux GZip concaténés

• Utilisation mémoire réduite et meilleur recyclage des buffers

• Aucun changement cassant - le code existant bénéficie automatiquement des optimisations

Nouvelles APIs asynchrones

.NET 10 ajoute plusieurs méthodes asynchrones très attendues :

• ZipArchive.CreateAsync()

• ZipFile.CreateFromDirectoryAsync()

• ZipFile.ExtractToDirectoryAsync()

• ZipFile.OpenAsync()

• ZipFile.OpenReadAsync()

• ZipArchiveEntry.OpenAsync()

• ZipFileExtensions.CreateEntryFromFileAsync()

• ZipFileExtensions.ExtractToDirectoryAsync()

• ZipFileExtensions.ExtractToFileAsync()

Exemples d'utilisation

Extraction asynchrone d'une archive ZIP

Le code ci-dessous fonctionne beaucoup plus rapidement sur .NET 10 grâce aux optimisations internes :

using System;
using System.IO;
using System.IO.Compression;
using System.Threading;
using System.Threading.Tasks;

public static class ZipExtractor
{
    public static async Task ExtractZipAsync(
        string zipPath,
        string destination,
        CancellationToken ct = default)
    {
        Directory.CreateDirectory(destination);

        await using var fs = File.OpenRead(zipPath);
        using var archive = new ZipArchive(fs, ZipArchiveMode.Read, leaveOpen: false);

        foreach (var entry in archive.Entries)
        {
            // Skip directory entries
            if (string.IsNullOrEmpty(entry.Name))
                continue;

            string outPath = Path.Combine(destination, entry.FullName);
            Directory.CreateDirectory(Path.GetDirectoryName(outPath)!);

            await using var entryStream = entry.Open();
            await using var outStream = File.Create(outPath);

            // Asynchronous copy avoids blocking the calling thread
            await entryStream.CopyToAsync(outStream, ct);

            Console.WriteLine($"Extracted: {entry.FullName}");
        }
    }
}

// Usage
await ZipExtractor.ExtractZipAsync("sample.zip", "./out", CancellationToken.None);

Création asynchrone d'une archive ZIP

Créer une archive ZIP de manière asynchrone à partir d'un répertoire :

using System.IO.Compression;
using System.Threading;
using System.Threading.Tasks;

public static class ZipCreator
{
    public static async Task CreateZipFromDirectoryAsync(
        string sourceDirectory,
        string zipPath,
        CancellationToken ct = default)
    {
        // New async API in .NET 10
        await ZipFile.CreateFromDirectoryAsync(
            sourceDirectory,
            zipPath,
            CompressionLevel.Optimal,
            includeBaseDirectory: false,
            ct);
    }
}

// Usage
await ZipCreator.CreateZipFromDirectoryAsync("./source", "archive.zip");

Lecture de fichiers GZip concaténés

GZip peut contenir plusieurs membres concaténés. .NET 10 gère cela plus efficacement :

using System;
using System.IO;
using System.IO.Compression;
using System.Text;
using System.Threading.Tasks;

async Task ReadConcatenatedGzipAsync(string path)
{
    await using var fileStream = File.OpenRead(path);
    await using var gzip = new GZipStream(fileStream, CompressionMode.Decompress);
    using var reader = new StreamReader(gzip, Encoding.UTF8);

    string content = await reader.ReadToEndAsync();
    Console.WriteLine(content);
}

// Works even if the file contains multiple gzip members concatenated
await ReadConcatenatedGzipAsync("data.gz");

Détection intelligente des limites des membres GZip, overhead réduit lors de la lecture de plusieurs blocs, et meilleures performances en lecture asynchrone.

Avantages

• Meilleures performances sans modification de code

• Support complet des opérations asynchrones

• Support des CancellationToken pour annuler les opérations longues

• Applications plus réactives avec les opérations I/O-bound

• Traitement efficace des grandes archives

Points clés

• Aucun changement d'API cassant

• Optimisations automatiques en ciblant .NET 10

• I/O asynchrone amélioré, moins de blocages

• Extraction parallélisée pour les archives contenant de nombreux fichiers

• Support natif amélioré des fichiers GZip multi-membres