Pendahuluan

Ketika bisnis Anda harus mengkonsumsi sejumlah besar faktur, dokumen hukum, atau ekspor email yang datang dalam bentuk file ZIP atau RAR yang terkompresi, pendekatan tradisional adalah mengekstrak file tersebut ke disk, membuka setiap file dengan pembaca terpisah, lalu menghapus file sementara. Proses bolak‑balik ini menambah I/O yang mahal, menyulitkan pembersihan, dan membuat penanganan arsip bersarang menjadi mimpi buruk.

GroupDocs.Parser untuk .NET menghilangkan poin‑poin sakit tersebut. Ia memungkinkan Anda membuka arsip secara langsung, menelusuri setiap entri, dan mengekstrak teks mentah (dan metadata) sepenuhnya di memori. Dalam artikel ini Anda akan mempelajari cara:

  • Menginstal paket NuGet Parser.
  • Mengambil teks dari arsip datar dalam satu kali proses.
  • Menelusuri arsip ZIP/RAR bersarang secara rekursif.
  • Menerapkan pengaturan praktik terbaik untuk pemrosesan yang kuat.

Mengapa Penguraian Arsip Dalam Memori Penting

Memproses arsip di memori memberi Anda:

  • Tidak ada file sementara – tidak ada sampah di disk, tidak ada file yang tertinggal.
  • Kecepatan – menghindari siklus baca/tulis tambahan untuk setiap entri.
  • Skalabilitas – menangani arsip besar atau aliran berbasis cloud di mana sistem file mungkin tidak tersedia.

Prasyarat

  • .NET 6.0 atau yang lebih baru.
  • GroupDocs.Parser untuk .NET (versi terbaru) – lihat lisensi sementara untuk evaluasi gratis.
  • Arsip ZIP atau RAR yang berisi dokumen yang didukung (PDF, DOCX, TXT, dll.).

Instalasi

dotnet add package GroupDocs.Parser

Tambahkan namespace yang diperlukan:

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

Langkah 1 – Membuka Arsip

Langkah pertama adalah membuat instance Parser yang mengarah ke file arsip. GetContainer() mengembalikan koleksi objek ContainerItem – satu per entri di dalam arsip.

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

Apa yang terjadi:

  • Konstruktor Parser memuat arsip tanpa mengekstraknya ke disk.
  • GetContainer() membaca direktori arsip secara malas dan memberikan Anda objek ContainerItem yang dapat diproses.

Langkah 2 – Memproses Setiap Entri

ExtractDataFromAttachments menelusuri daftar ContainerItem, mencetak metadata dasar, mendeteksi arsip bersarang, dan mengekstrak teks dari dokumen reguler. Metode ini sepenuhnya dapat digunakan kembali – panggil sekali untuk arsip tingkat atas dan lagi untuk setiap arsip bersarang yang Anda temukan.

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

Poin Penting

  • Akses metadata – item.Metadata memberi Anda nama file, ukuran, tanggal pembuatan, dll., tanpa membaca isi file.
  • Penanganan rekursif – Metode yang sama memanggil dirinya sendiri ketika menemukan ZIP/RAR lain, memberikan dukungan nesting tak terbatas.
  • Ketahanan terhadap kesalahan – UnsupportedDocumentFormatException ditangkap sehingga satu file yang buruk tidak menghentikan seluruh proses.

Langkah 3 – Menggabungkan Semua

Berikut adalah program minimal yang dapat disalin‑tempel yang menggabungkan dua potongan kode di atas. Program ini memperlihatkan alur lengkap end‑to‑end: instal, buka, proses, dan laporkan.

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

Jalankan program dengan path ke arsip Anda:

dotnet run -- ./Data/LegalDocs.zip

Praktik Terbaik & Tips

  • Batasi opsi parsing – Secara default Parser mengekstrak semua konten yang didukung. Jika Anda hanya membutuhkan teks, hindari memanggil metode berat tambahan seperti GetImages().
  • Arsip besar – Proses item secara berurutan seperti contoh; hindari memuat semua teks ke memori sekaligus.
  • Kinerja – Lewati arsip bersarang yang tidak Anda perlukan dengan memeriksa ekstensi file sebelum melakukan rekursi.
  • Penanganan kesalahan – Selalu tangkap UnsupportedDocumentFormatException; banyak arsip korporat berisi binary yang tidak dapat dibaca parser.

Kesimpulan

GroupDocs.Parser untuk .NET menyediakan cara bersih berbasis memori untuk membaca setiap dokumen di dalam arsip ZIP atau RAR, tidak peduli seberapa dalam nesting‑nya. Dengan hanya beberapa baris kode Anda dapat menggantikan pipeline unzip‑plus‑parse yang rumit, mengurangi beban I/O, dan membangun layanan ingest dokumen yang handal.

Langkah berikutnya

  • Jelajahi fitur perbandingan dokumen atau ekstraksi metadata.
  • Pelajari cara mengekstrak gambar dari file arsip dengan API yang sama.
  • Integrasikan teks yang diekstrak ke dalam indeks pencarian atau pipeline AI.

Sumber Daya Tambahan