Introductie

Wanneer uw bedrijf grote hoeveelheden facturen, juridische documenten of e‑mail‑exports moet verwerken die aankomen als gecomprimeerde ZIP‑ of RAR‑bestanden, is de traditionele aanpak om ze eerst uit te pakken naar schijf, elk bestand met een aparte lezer te openen en vervolgens de tijdelijke bestanden te verwijderen. Deze ronde‑trip voegt dure I/O toe, maakt opruimen ingewikkeld en maakt het omgaan met geneste archieven een nachtmerrie.

GroupDocs.Parser voor .NET elimineert die pijnpunten. Het stelt u in staat om een archief direct te openen, elke entry te enumereren en ruwe tekst (en metadata) volledig in het geheugen te extraheren. In dit artikel leert u hoe u:

  • Het Parser‑NuGet‑pakket installeert.
  • Tekst uit een plat archief in één doorloop haalt.
  • Geneste ZIP/RAR‑bestanden recursief doorloopt.
  • Beste‑praktijken toepast voor robuuste verwerking.

Waarom in‑geheugen archief‑parsing ertoe doet

Het verwerken van archieven in het geheugen biedt u:

  • Geen tijdelijke bestanden – geen rommel op de schijf, geen achtergebleven bestanden.
  • Snelheid – vermijd de extra lees‑/schrijfcyclus voor elke entry.
  • Schaalbaarheid – verwerk grote archieven of cloud‑gebaseerde streams waarin een bestandssysteem mogelijk niet beschikbaar is.

Voorvereisten

  • .NET 6.0 of later.
  • GroupDocs.Parser voor .NET (nieuwste versie) – zie de tijdelijke licentie voor een gratis evaluatie.
  • Een ZIP‑ of RAR‑archief dat ondersteunde documenten bevat (PDF, DOCX, TXT, enz.).

Installatie

dotnet add package GroupDocs.Parser

Voeg de benodigde namespaces toe:

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

Stap 1 – Open het archief

De eerste stap is het maken van een Parser‑instantie die naar het archiefbestand wijst. GetContainer() retourneert een collectie van ContainerItem‑objecten – één per entry binnen het archief.

// 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);
}

Wat er gebeurt:

  • De Parser‑constructor laadt het archief zonder het uit te pakken naar schijf.
  • GetContainer() leest lui de directory van het archief en geeft u ContainerItem‑objecten die u kunt gebruiken.

Stap 2 – Verwerk elke entry

ExtractDataFromAttachments doorloopt de ContainerItem‑lijst, drukt basis‑metadata af, detecteert geneste archieven en extraheert tekst uit gewone documenten. De methode is volledig herbruikbaar – roep hem één keer aan voor een top‑level archief en opnieuw voor elk genest archief dat u tegenkomt.

/// <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}");
        }
    }
}

Belangrijke punten

  • Metadatatoegang – item.Metadata geeft u bestandsnaam, grootte, aanmaakdatum, enz., zonder de bestandsinhoud te lezen.
  • Recursieve afhandeling – Dezelfde methode roept zichzelf aan wanneer een ander ZIP/RAR‑bestand wordt aangetroffen, waardoor u onbeperkte genesting ondersteunt.
  • Foutbestendigheid – UnsupportedDocumentFormatException wordt opgevangen zodat één slecht bestand de hele uitvoering niet onderbreekt.

Stap 3 – Alles samenvoegen

Hieronder vindt u een minimaal, kant‑klaar programma dat de twee bovenstaande fragmenten combineert. Het toont een volledige end‑to‑end‑stroom: installeren, openen, verwerken en rapporteren.

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}");
            }
        }
    }
}

Voer het programma uit met het pad naar uw archief:

dotnet run -- ./Data/LegalDocs.zip

Beste praktijken & tips

  • Beperk parse‑opties – Standaard extraheert Parser alle ondersteunde inhoud. Als u alleen tekst nodig heeft, vermijd dan het aanroepen van extra zware methoden zoals GetImages().
  • Grote archieven – Verwerk items achtereenvolgens zoals hierboven getoond; laad niet alle teksten tegelijk in het geheugen.
  • Prestaties – Sla geneste archieven over die u niet nodig heeft door de bestandsextensie te controleren voordat u recursief gaat.
  • Foutafhandeling – Vang altijd UnsupportedDocumentFormatException op; veel bedrijfsarchieven bevatten binaire bestanden die de parser niet kan lezen.

Conclusie

GroupDocs.Parser voor .NET biedt een nette, in‑geheugen manier om elk document binnen ZIP‑ of RAR‑archieven te lezen, hoe diep ze ook genesteld zijn. Met slechts een paar regels code kunt u complexe unzip‑plus‑parse‑pijplijnen vervangen, I/O‑overhead verminderen en betrouwbare document‑ingestiediensten bouwen.

Vervolgstappen

  • Verken de documentvergelijking of metadata‑extractie‑functionaliteit.
  • Leer hoe u afbeeldingen uit gearchiveerde bestanden kunt extraheren met dezelfde API.
  • Integreer de geëxtraheerde tekst in een zoek‑index of AI‑pipeline.

Aanvullende bronnen