Introduction

Lorsque votre entreprise doit ingérer de gros lots de factures, de documents juridiques ou d’exports d’e‑mail arrivant sous forme de fichiers compressés ZIP ou RAR, l’approche traditionnelle consiste à les décompresser sur le disque, à ouvrir chaque fichier avec un lecteur distinct, puis à supprimer les fichiers temporaires. Ce aller‑retour entraîne des E/S coûteuses, complique le nettoyage et rend la gestion des archives imbriquées un cauchemar.

GroupDocs.Parser for .NET élimine ces points douloureux. Il vous permet de ouvrir une archive directement, d’énumérer chaque entrée, et d’extraire le texte brut (et les métadonnées) entièrement en mémoire. Dans cet article, vous apprendrez à :

  • Installer le package NuGet Parser.
  • Extraire le texte d’une archive simple en un seul passage.
  • Parcourir récursivement les fichiers ZIP/RAR imbriqués.
  • Appliquer les paramètres recommandés pour un traitement robuste.

Why In‑Memory Archive Parsing Matters

  • Aucun fichier temporaire – aucune accumulation sur le disque, aucun fichier résiduel.
  • Vitesse – éviter le cycle lecture/écriture supplémentaire pour chaque entrée.
  • Scalabilité – traiter de grandes archives ou des flux basés sur le cloud où un système de fichiers peut ne pas être disponible.

Prerequisites

  • .NET 6.0 ou version ultérieure.
  • GroupDocs.Parser for .NET (dernière version) – voir la licence temporaire pour une évaluation gratuite.
  • Une archive ZIP ou RAR contenant des documents pris en charge (PDF, DOCX, TXT, etc.).

Installation

dotnet add package GroupDocs.Parser

Ajoutez les espaces de noms requis :

using GroupDocs.Parser;
using GroupDocs.Parser.Data;
using System.Collections.Generic;
using System.IO;

Step 1 – Open the Archive

La première étape consiste à créer une instance Parser qui pointe vers le fichier d’archive. GetContainer() renvoie une collection d’objets ContainerItem – un par entrée à l’intérieur de l’archive.

// Path to the archive you want to scan
string archivePath = "./SampleDocs/InvoicesArchive.zip";

using (Parser parser = new Parser(archivePath))
{
    // Retrieve every file (or nested archive) inside the container
    IEnumerable<ContainerItem> attachments = parser.GetContainer();

    if (attachments == null)
    {
        Console.WriteLine("Archive is empty or could not be read.");
        return;
    }

    // Hand off the collection to a helper that extracts text/metadata
    ExtractDataFromAttachments(attachments);
}

Ce qui se passe :

  • Le constructeur Parser charge l’archive sans l’extraire sur le disque.
  • GetContainer() lit paresseusement le répertoire de l’archive et vous fournit des objets ContainerItem avec lesquels vous pouvez travailler.

Step 2 – Process Each Entry

ExtractDataFromAttachments parcourt la liste ContainerItem, affiche les métadonnées de base, détecte les archives imbriquées et extrait le texte des documents standards. La méthode est entièrement réutilisable – appelez‑la une fois pour une archive de niveau supérieur et de nouveau pour toute archive imbriquée que vous découvrez.

/// <summary>
/// Recursively extracts metadata and plain‑text from each item in an archive.
/// </summary>
static void ExtractDataFromAttachments(IEnumerable<ContainerItem> attachments)
{
    foreach (ContainerItem item in attachments)
    {
        // Print a quick line with file name and size (optional)
        Console.WriteLine($"File: {item.FilePath} | Size: {item.Metadata.Size} bytes");

        try
        {
            // Each ContainerItem can open its own Parser instance
            using (Parser itemParser = item.OpenParser())
            {
                if (itemParser == null)
                {
                    // The item is not a supported document – skip it
                    continue;
                }

                // Detect nested archives by extension (case‑insensitive)
                bool isArchive = item.FilePath.EndsWith(".zip", StringComparison.OrdinalIgnoreCase) ||
                                 item.FilePath.EndsWith(".rar", StringComparison.OrdinalIgnoreCase);

                if (isArchive)
                {
                    // Recursively process the inner archive
                    IEnumerable<ContainerItem>? nested = itemParser.GetContainer();
                    if (nested != null)
                    {
                        ExtractDataFromAttachments(nested);
                    }
                }
                else
                {
                    // Regular document – extract its raw text
                    using (TextReader reader = itemParser.GetText())
                    {
                        string text = reader.ReadToEnd();
                        Console.WriteLine($"Extracted {text.Length} characters from {item.FilePath}");
                        // Here you could store `text` in a database, index it, etc.
                    }
                }
            }
        }
        catch (UnsupportedDocumentFormatException)
        {
            // The file type is not supported by GroupDocs.Parser – ignore gracefully
            Console.WriteLine($"Skipping unsupported format: {item.FilePath}");
        }
    }
}

Key Points

  • Accès aux métadonnées – item.Metadata vous fournit le nom du fichier, la taille, la date de création, etc., sans lire le contenu du fichier.
  • Gestion récursive – La même méthode s’appelle elle‑-même lorsqu’elle rencontre un autre ZIP/RAR, vous offrant un support d’imbrication illimité.
  • Résilience aux erreurs – UnsupportedDocumentFormatException est interceptée afin qu’un fichier défectueux n’interrompe pas l’exécution complète.

Step 3 – Putting It All Together

Ci‑dessous se trouve un programme minimal, copiable‑collable, qui combine les deux extraits précédents. Il montre un flux complet de bout en bout : installation, ouverture, traitement et génération de rapports.

using GroupDocs.Parser;
using GroupDocs.Parser.Data;
using System;
using System.Collections.Generic;
using System.IO;

class ArchiveTextExtractor
{
    static void Main(string[] args)
    {
        string archivePath = args.Length > 0 ? args[0] : "./SampleDocs/InvoicesArchive.zip";
        using (Parser parser = new Parser(archivePath))
        {
            IEnumerable<ContainerItem> attachments = parser.GetContainer();
            if (attachments == null)
            {
                Console.WriteLine("No items found in the archive.");
                return;
            }
            ExtractDataFromAttachments(attachments);
        }
    }

    static void ExtractDataFromAttachments(IEnumerable<ContainerItem> attachments)
    {
        foreach (ContainerItem item in attachments)
        {
            Console.WriteLine($"File: {item.FilePath} | Size: {item.Metadata.Size} bytes");
            try
            {
                using (Parser itemParser = item.OpenParser())
                {
                    if (itemParser == null) continue;

                    bool isArchive = item.FilePath.EndsWith(".zip", StringComparison.OrdinalIgnoreCase) ||
                                     item.FilePath.EndsWith(".rar", StringComparison.OrdinalIgnoreCase);

                    if (isArchive)
                    {
                        var nested = itemParser.GetContainer();
                        if (nested != null) ExtractDataFromAttachments(nested);
                    }
                    else
                    {
                        using (TextReader reader = itemParser.GetText())
                        {
                            string text = reader.ReadToEnd();
                            Console.WriteLine($"Extracted {text.Length} chars from {item.FilePath}");
                        }
                    }
                }
            }
            catch (UnsupportedDocumentFormatException)
            {
                Console.WriteLine($"Unsupported format: {item.FilePath}");
            }
        }
    }
}

Exécutez le programme avec le chemin vers votre archive :

dotnet run -- ./Data/LegalDocs.zip

Best Practices & Tips

  • Limiter les options d’analyse – Par défaut, Parser extrait tout le contenu pris en charge. Si vous ne avez besoin que du texte, évitez d’appeler des méthodes lourdes supplémentaires comme GetImages().
  • Grandes archives – Traitez les éléments séquentiellement comme indiqué ; évitez de charger tous les textes en mémoire d’un coup.
  • Performance – Ignorez les archives imbriquées dont vous n’avez pas besoin en vérifiant l’extension du fichier avant de récursiver.
  • Gestion des erreurs – Capturez toujours UnsupportedDocumentFormatException ; de nombreuses archives d’entreprise contiennent des binaires que le parseur ne peut pas lire.

Conclusion

GroupDocs.Parser for .NET offre une méthode propre et en mémoire pour lire chaque document à l’intérieur des archives ZIP ou RAR, quel que soit leur niveau d’imbrication. En quelques lignes de code seulement, vous pouvez remplacer les pipelines complexes de décompression‑plus‑analyse, réduire la surcharge d’E/S et créer des services d’ingestion de documents fiables.

Étapes suivantes

  • Explorez les fonctionnalités de comparaison de documents ou d’extraction de métadonnées.
  • Apprenez comment extraire des images à partir de fichiers archivés avec la même API.
  • Intégrez le texte extrait dans un index de recherche ou un pipeline d’IA.

Additional Resources