Úvod

Když vaše firma potřebuje zpracovávat velké dávky faktur, právních dokumentů nebo exportů e‑mailů, které přicházejí jako komprimované soubory ZIP nebo RAR, tradiční přístup spočívá v jejich rozbalení na disk, otevření každého souboru samostatnou čtečkou a následném smazání dočasných souborů. Tento zpětný tah přidává nákladné I/O, komplikuje úklid a zpracování vnořených archivů se stává noční můrou.

GroupDocs.Parser pro .NET odstraňuje tyto bolestivé body. Umožňuje vám otevřít archiv přímo, vyjmenovat každý záznam a extrahovat surový text (a metadata) kompletně v paměti. V tomto článku se naučíte, jak:

  • Nainstalovat NuGet balíček Parser.
  • Vyjmout text z plochého archivu v jednom průchodu.
  • Rekurzivně procházet vnořené soubory ZIP/RAR.
  • Použít osvědčená nastavení pro spolehlivé zpracování.

Proč je důležité parsování archivů v paměti

Zpracování archivů v paměti vám poskytuje:

  • Žádné dočasné soubory – žádný nepořádek na disku, žádné zbylé soubory.
  • Rychlost – vyhnout se extra cyklu čtení/zápisu pro každý záznam.
  • Škálovatelnost – zpracovávat velké archivy nebo cloudové streamy, kde nemusí být k dispozici souborový systém.

Předpoklady

  • .NET 6.0 nebo novější.
  • GroupDocs.Parser pro .NET (nejnovější verze) – viz [temporary license][TEMP_LICENSE_URL] pro bezplatné vyzkoušení.
  • Archiv ZIP nebo RAR obsahující podporované dokumenty (PDF, DOCX, TXT, atd.).

Instalace

dotnet add package GroupDocs.Parser

Přidejte požadované jmenné prostory:

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

Krok 1 – Otevření archivu

Prvním krokem je vytvořit instanci Parser, která ukazuje na soubor archivu. GetContainer() vrací kolekci objektů ContainerItem – jeden pro každý záznam v archivu.

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

Co se děje:

  • Parser konstruktor načte archiv bez jeho rozbalení na disk.
  • GetContainer() líně čte adresář archivu a poskytne vám objekty ContainerItem, se kterými můžete pracovat.

Krok 2 – Zpracování každého záznamu

ExtractDataFromAttachments prochází seznam ContainerItem, vypisuje základní metadata, detekuje vnořené archivy a extrahuje text z běžných dokumentů. Metoda je zcela znovupoužitelná – zavolejte ji jednou pro archiv na nejvyšší úrovni a znovu pro jakýkoli vnořený archiv, který objevíte.

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

Klíčové body

  • Přístup k metadatům – item.Metadata vám poskytuje název souboru, velikost, datum vytvoření atd., aniž by četl obsah souboru.
  • Rekurzivní zpracování – Stejná metoda se volá sama, když narazí na další ZIP/RAR, což vám poskytuje neomezenou podporu vnoření.
  • Odolnost vůči chybám – UnsupportedDocumentFormatException je zachycena, takže jeden špatný soubor neukončí celou operaci.

Krok 3 – Sestavení všeho dohromady

Níže je minimální program, který lze zkopírovat a vložit, a který kombinuje oba výše uvedené úryvky. Ukazuje kompletní end‑to‑end tok: instalace, otevření, zpracování a reportování.

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

Spusťte program s cestou k vašemu archivu:

dotnet run -- ./Data/LegalDocs.zip

Doporučené postupy a tipy

  • Omezte možnosti parsování – Ve výchozím nastavení Parser extrahuje celý podporovaný obsah. Pokud potřebujete pouze text, vyhněte se volání dalších náročných metod jako GetImages().
  • Velké archivy – Zpracovávejte položky postupně, jak je ukázáno; vyhněte se načítání veškerých textů do paměti najednou.
  • Výkon – Přeskočte vnořené archivy, které nepotřebujete, kontrolou přípony souboru před rekurzí.
  • Zpracování chyb – Vždy zachytávejte UnsupportedDocumentFormatException; mnoho firemních archivů obsahuje binárky, které parser neumí číst.

Závěr

GroupDocs.Parser pro .NET poskytuje čistý, paměťový způsob, jak číst každý dokument uvnitř archivů ZIP nebo RAR, bez ohledu na to, jak hluboko jsou vnořeny. Pouhých několik řádků kódu vám umožní nahradit složité pipeline rozbalení‑plus‑parsování, snížit režii I/O a vytvořit spolehlivé služby pro příjem dokumentů.

Další kroky

  • Prozkoumejte funkce [document comparison][DOCS_URL] nebo [metadata extraction][DOCS_URL].
  • Naučte se, jak extrahovat obrázky z archivovaných souborů pomocí stejného API.
  • Integrovat extrahovaný text do vyhledávacího indexu nebo AI pipeline.

Další zdroje

  • [GroupDocs.Parser Dokumentace][DOCS_URL]
  • [API Reference][API_REFERENCE_URL]
  • [Získat dočasnou licenci][TEMP_LICENSE_URL]
  • [Ukázkové projekty na GitHub][GITHUB_URL]
  • [GroupDocs.Parser Blog Category][BLOG_CATEGORY_URL]
  • [Community Forum][FORUM_URL]