Einführung

Wenn Ihr Unternehmen große Mengen von Rechnungen, Rechtsdokumenten oder E‑Mail‑Exporten verarbeiten muss, die als komprimierte ZIP‑ oder RAR‑Dateien vorliegen, besteht der traditionelle Ansatz darin, sie auf die Festplatte zu entpacken, jede Datei mit einem separaten Reader zu öffnen und anschließend die temporären Dateien zu verwerfen. Dieser Umweg verursacht teure I/O‑Operationen, erschwert die Bereinigung und macht die Handhabung verschachtelter Archive zu einem Albtraum.

GroupDocs.Parser für .NET beseitigt diese Probleme. Es ermöglicht Ihnen, ein Archiv direkt zu öffnen, jeden Eintrag aufzulisten und den Rohtext (und Metadaten) vollständig im Speicher zu extrahieren. In diesem Artikel lernen Sie, wie man:

  • Das Parser‑NuGet‑Paket installiert.
  • Text aus einem flachen Archiv in einem Durchgang extrahiert.
  • Verschachtelte ZIP‑/RAR‑Dateien rekursiv durchläuft.
  • Best‑Practice‑Einstellungen für eine robuste Verarbeitung anwendet.

Warum das Parsen von Archiven im Speicher wichtig ist

Das Verarbeiten von Archiven im Speicher bietet Ihnen:

  • Keine temporären Dateien – keine Festplattenunordnung, keine zurückbleibenden Dateien.
  • Geschwindigkeit – vermeidet den zusätzlichen Lese‑/Schreibzyklus für jeden Eintrag.
  • Skalierbarkeit – verarbeitet große Archive oder cloudbasierte Streams, bei denen kein Dateisystem verfügbar ist.

Voraussetzungen

  • .NET 6.0 oder neuer.
  • GroupDocs.Parser für .NET (neueste Version) – siehe die temporäre Lizenz für eine kostenlose Evaluierung.
  • Ein ZIP‑ oder RAR‑Archiv, das unterstützte Dokumente (PDF, DOCX, TXT usw.) enthält.

Installation

dotnet add package GroupDocs.Parser

Fügen Sie die erforderlichen Namespaces hinzu:

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

Schritt 1 – Archiv öffnen

Der erste Schritt besteht darin, eine Parser‑Instanz zu erstellen, die auf die Archivdatei verweist. GetContainer() liefert eine Sammlung von ContainerItem‑Objekten – eines pro Eintrag im Archiv.

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

Was passiert:

  • Der Parser‑Konstruktor lädt das Archiv ohne es auf die Festplatte zu extrahieren.
  • GetContainer() liest das Verzeichnis des Archivs lazy (bei Bedarf) und gibt Ihnen ContainerItem‑Objekte, mit denen Sie arbeiten können.

Schritt 2 – Jeden Eintrag verarbeiten

ExtractDataFromAttachments geht die Liste von ContainerItem‑Einträgen durch, gibt grundlegende Metadaten aus, erkennt verschachtelte Archive und extrahiert Text aus regulären Dokumenten. Die Methode ist vollständig wiederverwendbar – rufen Sie sie einmal für ein Top‑Level‑Archiv und erneut für jedes verschachtelte Archiv auf, das Sie entdecken.

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

Wichtige Punkte

  • Metadatenzugriff – item.Metadata liefert Dateiname, Größe, Erstellungsdatum usw., ohne den Dateiinhalt zu lesen.
  • Rekursive Behandlung – Die gleiche Methode ruft sich selbst auf, wenn sie ein weiteres ZIP/RAR findet, und bietet unbegrenzte Unterstützung für Verschachtelungen.
  • Fehlertoleranz – UnsupportedDocumentFormatException wird abgefangen, sodass eine einzelne fehlerhafte Datei den gesamten Durchlauf nicht abbricht.

Schritt 3 – Alles zusammenführen

Unten befindet sich ein minimales, kopierbares Programm, das die beiden obigen Code‑Snippets kombiniert. Es demonstriert einen vollständigen End‑to‑End‑Ablauf: installieren, öffnen, verarbeiten und berichten.

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

Führen Sie das Programm mit dem Pfad zu Ihrem Archiv aus:

dotnet run -- ./Data/LegalDocs.zip

Bewährte Methoden & Tipps

  • Parsing‑Optionen begrenzen – Standardmäßig extrahiert Parser alle unterstützten Inhalte. Wenn Sie nur Text benötigen, vermeiden Sie das Aufrufen zusätzlicher ressourcenintensiver Methoden wie GetImages().
  • Große Archive – Verarbeiten Sie Elemente sequenziell wie gezeigt; vermeiden Sie das Laden aller Texte gleichzeitig in den Speicher.
  • Performance – Überspringen Sie verschachtelte Archive, die Sie nicht benötigen, indem Sie die Dateierweiterung vor dem Rekursionsschritt prüfen.
  • Fehlerbehandlung – Fangen Sie stets UnsupportedDocumentFormatException; viele Unternehmensarchive enthalten Binärdateien, die der Parser nicht lesen kann.

Fazit

GroupDocs.Parser für .NET bietet einen sauberen, im Speicher arbeitenden Weg, jedes Dokument innerhalb von ZIP‑ oder RAR‑Archiven zu lesen, egal wie tief es verschachtelt ist. Mit nur wenigen Code‑Zeilen können Sie komplexe Entpack‑‑und‑Parse‑Pipelines ersetzen, den I/O‑Overhead reduzieren und zuverlässige Dokument‑Ingest‑Dienste bauen.

Nächste Schritte

  • Erkunden Sie die Funktionen zum Dokumentvergleich oder zur Metadatenextraktion.
  • Erfahren Sie, wie Sie Bilder aus archivierten Dateien mit derselben API extrahieren.
  • Integrieren Sie den extrahierten Text in einen Suchindex oder eine KI‑Pipeline.

Zusätzliche Ressourcen