IRONSOFTWAREHOME
IRONSUITEAlle 10 für den Preis von 2
DOKUMENTBEARBEITUNG
BILD & ERKENNUNG
VERKAUFSKONTAKT
NACH UNTERNEHMEN
KOSTENLOSE WERKZEUGE
VIDEOS

Umstellung von RapidOCR.NET auf IronOCR

Kannaopat Udonpant
Kannapat Udonpant
Updated: 1. August 2026

Diese Anleitung beschreibt den vollständigen Migrationspfad von RapidOCR.NET (RapidOcrNet) zu IronOCR for .NET-Entwickler, die das Management von ONNX-Modell-Dateien aus ihrer OCR-Pipeline entfernen müssen. Es wird der Paketersatz, die Code-Übersetzung und die betrieblichen Änderungen erläutert, die auftreten, wenn externe Modellabhängigkeiten vollständig entfernt werden.

Warum von RapidOCR.NET migrieren?

RapidOCR.NET funktioniert – für eine begrenzte Anzahl von Anwendungsfällen in kontrollierten Umgebungen, in denen das Problem der Modellverteilung bereits gelöst wurde. Wenn sich eine dieser Bedingungen ändert, werden die architektonischen Einschränkungen der Bibliothek zu Entwicklungskosten.

ONNX-Modell-Dateien sind ein Bereitstellungsartefakt, kein Paket. RapidOCR.NET benötigt vier externe Dateien — det.onnx, cls.onnx, rec.onnx und ein Zeichenwörterbuch — bevor ein einzelnes Zeichen erkannt werden kann. Diese Dateien sind nicht im NuGet-Paket enthalten. Sie befinden sich auf GitHub-Release-Seiten, müssen manuell heruntergeladen werden, erfordern eine explizite Pfadkonfiguration im Code und benötigen benutzerdefinierte MSBuild-Regeln zum Kopieren beim Build. Jeder neue Entwickler, jede CI-Pipeline, jede Bereitstellungsumgebung wiederholt diesen Vorgang.

Ein Sprachwechsel bedeutet das Ersetzen von Dateien, nicht eine Konfiguration. Der Wechsel von englischer OCR zu chinesischer OCR in RapidOCR.NET erfordert das Herunterladen eines anderen Erkennungsmodells und eines anderen Zeichenwörterbuchs sowie das anschließende Neuaufbauen der Engine-Instanz. Für Spanisch, Französisch, Deutsch, Russisch, Arabisch und mehr als 100 weitere Sprachen gibt es im RapidOCR-Modellkatalog überhaupt kein Modell. Eine Anwendung, die Dokumente in verschiedenen Sprachen verarbeiten muss, hat in RapidOCR.NET keine praktikable Lösung für die nicht unterstützten Sprachen.

Versionsaktualisierungen der Modellversionen erfordern manuelle Eingriffe. Wenn das vorgelagerte RapidOCR-Projekt verbesserte Modellgewichte veröffentlicht, müssen Teams neue Dateien herunterladen, diese in jeder Umgebung ersetzen, Pfade validieren und neu bereitstellen. Es gibt keinen Schritt zur Paketwiederherstellung, der dies automatisch übernimmt. In einer Umgebung mit mehreren Umgebungen (Entwicklung, Staging und Produktion) ist diese Übertragung jedes Mal ein manueller Vorgang.

Die ONNX-Laufzeitabhängigkeit erhöht die Plattformkomplexität. RapidOCR.NET hängt von Microsoft.ML.OnnxRuntime ab, einem Paket mit plattformspezifischen nativen Binärdateien. CPU- und GPU-Varianten erfordern unterschiedliche Pakete. Ein Container-Image, das für linux/amd64 gebaut wird, benötigt andere Binärdateien als eines, das für linux/arm64 gebaut wird. Für jedes Bereitstellungsziel muss überprüft werden, ob die richtige Laufzeitvariante vorhanden und mit den installierten Modelldateien kompatibel ist.

Kaltstart-Latenz und Speicherbedarf sind Fixkosten. Das Laden der drei ONNX-Modelle beim Start dauert 2–5 Sekunden und beansprucht während des gesamten Vorgangs 300–500 MB Speicherplatz. Diese Kosten fallen unabhängig vom OCR-Volumen an, wodurch sich die Bibliothek schlecht für serverlose Funktionen, leichtgewichtige Container oder Dienste mit geringem Datenverkehr eignet, bei denen die Startverzögerung in keinem Verhältnis zum Durchsatz steht.

Kein kommerzieller Support. RapidOCR.NET wird von einem einzelnen Community-Entwickler unter der Apache 2.0-Lizenz gepflegt. Produktionsvorfälle – Konflikte zwischen ONNX-Runtime-Versionen, Inferenzfehler bei ungewöhnlichen Bildformaten, Speicheranstieg unter Dauerbelastung – werden an eine GitHub-Issues-Warteschlange weitergeleitet, ohne garantierten Antwortzeitraum und ohne SLA.

Das grundsätzliche Problem

Drei ONNX-Modelldateien Plus ein Zeichenwörterbuch, die alle separat heruntergeladen und über den Pfad konfiguriert werden:

// RapidOcrNet: 4 external files required before any OCR can execute
var engine = new RapidOcrEngine(new RapidOcrOptions
{
    DetModelPath = "./models/det.onnx",     // ~3 MB — downloaded from GitHub
    ClsModelPath = "./models/cls.onnx",     // ~1 MB — downloaded from GitHub
    RecModelPath = "./models/rec_en.onnx",  // ~2-10 MB — language-specific download
    KeysPath     = "./models/en_keys.txt"   // character dictionary — language-specific
});
C#

IronOCR benötigt keine Modelldateien, keine Pfadkonfiguration und keinen Download-Schritt:

// IronOCR: install the NuGet package, write one line
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";
var text = new IronTesseract().Read("document.jpg").Text;
C#

##IronOCR vs. RapidOCR.NET: Funktionsvergleich

IronOCR und RapidOCR.NET überschneiden sich im Bereich der grundlegenden Bild-OCR. Die Lücke öffnet sich bei jedem damit verbundenen Anliegen.

FeatureRapidOCR.NETIronOCR
NuGet -InstallationJa (RapidOcrNet)Ja (IronOcr)
Externe Modelldateien erforderlichJa (4 Dateien, manueller Download)Nein
Pfadkonfiguration erforderlichJaNein
MSBuild-Kopierregeln erforderlichJaNein
Funktioniert sofort nach der NuGet -InstallationNeinJa
ONNX-Runtime-AbhängigkeitJa (~30–50 MB)Nein
Unterstützte Sprachen~5 (nur CJK + Englisch)Über 125 Sprachpakete via NuGet
SprachwechselDateiaustausch + Engine-NeuerstellungEigenschaftszuweisung
Unterstützung europäischer SprachenNeinJa (30+)
Unterstützung für Arabisch / HebräischNeinJa
Unterstützung für kyrillische Zeichen (Russisch, Ukrainisch)NeinJa
Native PDF-EingabeNeinJa
Passwortgeschützte PDF-EingabeNeinJa
Durchsuchbare PDF-AusgabeNeinJa
Mehrseitige TIFF-EingabeNeinJa
Eingabe von Datenströmen und Byte-ArraysBeschränktJa
Integrierte BildvorverarbeitungNeinJa (automatische + manuelle Filter)
Filter für Schräglagenkorrektur / Rauschunterdrückung / KontrastNeinJa
Strukturierte Ausgabe (Absätze, Zeilen, Wörter)Teilweise (nur Blöcke)Ja, mit Koordinaten
Vertrauenswerte pro WortJa (pro Block)Ja
Barcode-Lesung während der OCRNeinJa
hOCR-ExportNeinJa
Threadsichere ParallelverarbeitungBeschränktJa (eine Instanz pro Thread)
Plattformübergreifende BereitstellungErfordert ONNX-Runtime-Binärdateien pro PlattformJa (Windows, Linux, macOS, Docker)
Docker-EinsatzAnweisungen zum manuellen Modell COPY erforderlichSofort einsatzbereit
Kaltstart-Overhead2–5 Sekunden (Modellladen)Minimal
Kommerzielle UnterstützungNeinJa
LizenzApache 2.0 (kostenlos)Unbefristet ($999 Lite, 1.499 $ Pro, 2.999 $ Enterprise)

Schnellstart: Migration von RapidOCR.NET zu IronOCR

Schritt 1: Ersetzen des NuGet-Pakets

Entfernen Sie RapidOCR.NET und die Abhängigkeit von ONNX Runtime:

dotnet remove package RapidOcrNet
dotnet remove package Microsoft.ML.OnnxRuntime
SHELL

Installieren Sie IronOCR über NuGet :

> dotnet add package IronOcr

Schritt 2: Namespaces aktualisieren

Ersetzen Sie den RapidOCR.NET-Namespace durch den IronOCR-Namespace:

// Before (RapidOCR.NET)
using RapidOcrNet;

// After (IronOCR)
using IronOcr;
C#

Schritt 3: Lizenz initialisieren

Fügen Sie die Lizenzinitialisierung bei Anwendungsstart hinzu, bevor beliebige IronTesseract Aufrufe erfolgen:

IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

Auf der IronOCR -Lizenzseite ist ein kostenloser Testschlüssel erhältlich.

Beispiele für die Code-Migration

Entfernung der ONNX-Modellpfadkonfiguration

Die mechanischste Änderung in dieser Migration ist das Löschen des RapidOcrOptions Konfigurationsblocks und dessen Ersetzung durch einen Null-Argument-Konstruktor.

Ansatz von RapidOCR.NET:

using RapidOcrNet;

// Startup validation — written because a missing model crashes at runtime, not at install
private static void EnsureModelsPresent(string modelDir)
{
    var required = new[]
    {
        Path.Combine(modelDir, "det.onnx"),
        Path.Combine(modelDir, "cls.onnx"),
        Path.Combine(modelDir, "rec_en.onnx"),
        Path.Combine(modelDir, "en_keys.txt")
    };

    var missing = required.Where(f => !File.Exists(f)).ToList();
    if (missing.Any())
        throw new FileNotFoundException(
            $"Missing model files: {string.Join(", ", missing)}\n" +
            "Download from: https://github.com/RapidAI/RapidOCR/releases");
}

// Engine factory — called once at startup, held for lifetime of service
public RapidOcrEngine CreateEngine(string modelDir)
{
    EnsureModelsPresent(modelDir);
    return new RapidOcrEngine(new RapidOcrOptions
    {
        DetModelPath = Path.Combine(modelDir, "det.onnx"),
        ClsModelPath = Path.Combine(modelDir, "cls.onnx"),
        RecModelPath = Path.Combine(modelDir, "rec_en.onnx"),
        KeysPath     = Path.Combine(modelDir, "en_keys.txt"),
        UseGpu       = false,
        NumThreads   = Environment.ProcessorCount
    });
}
C#

IronOCR Ansatz:

using IronOcr;

//Neinmodel validation, no path configuration, no GPU flags
// IronTesseract is thread-safe; create one per thread or on demand
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";
var ocr = new IronTesseract();
C#

Die gesamte EnsureModelsPresent Validierungsmethode, das RapidOcrOptions Konfigurationsobjekt und die Engine-Fabrikklasse können gelöscht werden. Es gibt keine Modelldateien zur Validierung, da IronOCR seine Engine intern als Teil des NuGet-Pakets ausliefert. Die IronTesseract-Einrichtungsanleitung behandelt Initialisierungsoptionen und die Platzierung des Lizenzschlüssels im Detail.

Konsolidierung der Pipeline für Erkennung, Klassifizierung und Identifizierung

RapidOCR.NET führt eine dreistufige ONNX-Pipeline durch – Erkennung, Richtungsklassifizierung und anschließend Erkennung – und gibt eine ungeordnete flache Liste von Textblöcken zurück, die der Aufrufer sortieren und zusammenfügen muss.IronOCR bietet einen einzigen .Read() Aufruf, der durch seine interne Tesseract 5-Engine unterstützt wird, und gibt strukturierten Output mit bereits angewandter Lesereihenfolge zurück.

Ansatz von RapidOCR.NET:

using RapidOcrNet;

public class InvoiceTextExtractor
{
    private readonly RapidOcrEngine _engine;

    public InvoiceTextExtractor(string modelDir)
    {
        // Three separate ONNX models run in sequence on every call
        _engine = new RapidOcrEngine(new RapidOcrOptions
        {
            DetModelPath = Path.Combine(modelDir, "det.onnx"),   // Stage 1: detect text regions
            ClsModelPath = Path.Combine(modelDir, "cls.onnx"),   // Stage 2: classify direction
            RecModelPath = Path.Combine(modelDir, "rec_en.onnx"),// Stage 3: recognize characters
            KeysPath     = Path.Combine(modelDir, "en_keys.txt")
        });
    }

    public string ExtractInvoiceText(string imagePath)
    {
        var result = _engine.Run(imagePath);

        // Blocks are unordered — must sort by vertical position, then horizontal
        var orderedBlocks = result.TextBlocks
            .OrderBy(b => b.BoundingBox.Top)
            .ThenBy(b => b.BoundingBox.Left)
            .ToList();

        // Manual assembly — no paragraph or line structure
        return string.Join(Environment.NewLine,
            orderedBlocks.Select(b => b.Text));
    }
}
C#

IronOCR Ansatz:

using IronOcr;

public class InvoiceTextExtractor
{
    private readonly IronTesseract _ocr = new IronTesseract();

    public string ExtractInvoiceText(string imagePath)
    {
        // Single call — detection, recognition, reading order all internal
        var result = _ocr.Read(imagePath);
        return result.Text; // Already in reading order
    }

    public IEnumerable<string> ExtractInvoiceParagraphs(string imagePath)
    {
        var result = _ocr.Read(imagePath);
        // Structured paragraphs with coordinates — no sorting or assembly needed
        foreach (var page in result.Pages)
            foreach (var paragraph in page.Paragraphs)
                yield return paragraph.Text;
    }
}
C#

Die dreistufige Pipeline ist vollständig in IronOCR integriert. Die result.TextBlocks Liste mit ihrer manuellen OrderBy Kette reduziert sich auf result.Text. Für Aufrufer, die Bounding-Box-Daten von TextBlocks benötigten, stellen die result.Pages[i].Paragraphs, .Lines und .Words Sammlungen gleichwertige Koordinaten durch eine strukturierte API bereit. Die Seite mit den Anleitungen zu den Leseergebnissen und den OCR-Ergebnissen dokumentiert das vollständige strukturierte Ausgabemodell.

Ersatz für das Laden benutzerdefinierter Modelle

Anwendungen, die die OCR-Konfiguration zur Laufzeit umschalten müssen — zum Beispiel, um Dokumente je nach Dokumenttyp durch unterschiedliche Erkennungsparameter zu leiten — müssen die gesamte RapidOcrEngine in RapidOCR.NET neu erstellen, da die Konfiguration an den Konstruktor gebunden ist.IronOCR stellt die Engine-Konfiguration als Eigenschaften bereit, die pro Lesevorgang auf einer einzelnen Instanz angepasst werden können.

Ansatz von RapidOCR.NET:

using RapidOcrNet;

public class DocumentRouter
{
    private readonly string _modelDir;

    public DocumentRouter(string modelDir) => _modelDir = modelDir;

    // Must create separate engine instances per configuration
    // Each engine holds ~300-500 MB of loaded model weights
    private RapidOcrEngine BuildEnglishEngine() =>
        new RapidOcrEngine(new RapidOcrOptions
        {
            DetModelPath = Path.Combine(_modelDir, "det.onnx"),
            ClsModelPath = Path.Combine(_modelDir, "cls.onnx"),
            RecModelPath = Path.Combine(_modelDir, "en_rec.onnx"),
            KeysPath     = Path.Combine(_modelDir, "en_keys.txt")
        });

    private RapidOcrEngine BuildChineseEngine() =>
        new RapidOcrEngine(new RapidOcrOptions
        {
            DetModelPath = Path.Combine(_modelDir, "det.onnx"),
            ClsModelPath = Path.Combine(_modelDir, "cls.onnx"),
            RecModelPath = Path.Combine(_modelDir, "ch_rec.onnx"),  // separate download
            KeysPath     = Path.Combine(_modelDir, "ch_keys.txt")   // separate download
        });

    public string ProcessDocument(string imagePath, string language)
    {
        // Rebuild engine for each language — model reload cost on every switch
        using var engine = language == "chinese"
            ? BuildChineseEngine()
            : BuildEnglishEngine();

        var result = engine.Run(imagePath);
        return string.Join("\n", result.TextBlocks
            .OrderBy(b => b.BoundingBox.Top)
            .Select(b => b.Text));
    }
}
C#

IronOCR Ansatz:

using IronOcr;

public class DocumentRouter
{
    // One instance handles all languages — language is a property, not a constructor param
    private readonly IronTesseract _ocr = new IronTesseract();

    public string ProcessDocument(string imagePath, string language)
    {
        // Language switch requires no model reload, no rebuild
        _ocr.Language = language switch
        {
            "chinese"  => OcrLanguage.ChineseSimplified,
            "japanese" => OcrLanguage.Japanese,
            "arabic"   => OcrLanguage.Arabic,
            "russian"  => OcrLanguage.Russian,
            _          => OcrLanguage.English
        };

        return _ocr.Read(imagePath).Text;
    }
}
C#

Kein Neuaufbau der Engine, kein Neuladen des Modells, kein separater Download pro Sprache. Sprachpakete für nicht-englische Zielgeräte werden über NuGet installiert — dotnet add package IronOcr.Languages.ChineseSimplified — und der Wiederherstellungsschritt kümmert sich automatisch um die Bereitstellung. Die mehrsprachige Anleitung behandelt die Installation von Sprachpaketen, und der Sprachenindex listet alle über 125 verfügbaren Pakete auf.

Migration der Stapelverarbeitung

RapidOCR.NET bietet keine Thread-Sicherheit auf einer einzigen RapidOcrEngine Instanz. Die Stapelverarbeitung erfordert entweder eine Single-Thread-Warteschlange oder die Instanziierung einer Engine pro Thread, wobei jede einen eigenen Modell-Footprint von 300–500 MB mit sich bringt.IronOCR ist ausdrücklich thread-sicher: Erstellen Sie eine IronTesseract pro Thread und führen Sie sie ohne Sperren gleichzeitig aus.

Ansatz von RapidOCR.NET:

using RapidOcrNet;

public class BatchOcrProcessor
{
    private readonly string _modelDir;

    public BatchOcrProcessor(string modelDir) => _modelDir = modelDir;

    // Thread-pool processing — each thread needs its own engine copy
    // 4 threads × 300-500 MB model footprint = 1.2-2 GB RAM minimum
    public Dictionary<string, string> ProcessBatch(IReadOnlyList<string> imagePaths)
    {
        var results = new System.Collections.Concurrent.ConcurrentDictionary<string, string>();

        Parallel.ForEach(imagePaths, new ParallelOptions { MaxDegreeOfParallelism = 4 },
            imagePath =>
            {
                // Each thread must create its own engine — not safe to share
                using var engine = new RapidOcrEngine(new RapidOcrOptions
                {
                    DetModelPath = Path.Combine(_modelDir, "det.onnx"),
                    ClsModelPath = Path.Combine(_modelDir, "cls.onnx"),
                    RecModelPath = Path.Combine(_modelDir, "rec_en.onnx"),
                    KeysPath     = Path.Combine(_modelDir, "en_keys.txt")
                });

                var result = engine.Run(imagePath);
                results[imagePath] = string.Join("\n",
                    result.TextBlocks
                          .OrderBy(b => b.BoundingBox.Top)
                          .Select(b => b.Text));
            });

        return new Dictionary<string, string>(results);
    }
}
C#

IronOCR Ansatz:

using IronOcr;

public class BatchOcrProcessor
{
    // Thread-safe: create IronTesseract per thread, no shared state required
    public Dictionary<string, string> ProcessBatch(IReadOnlyList<string> imagePaths)
    {
        var results = new System.Collections.Concurrent.ConcurrentDictionary<string, string>();

        Parallel.ForEach(imagePaths, imagePath =>
        {
            // Lightweight construction — no model loading overhead per thread
            var ocr = new IronTesseract();
            var result = ocr.Read(imagePath);
            results[imagePath] = result.Text;
        });

        return new Dictionary<string, string>(results);
    }
}
C#

Die pro-Thread RapidOcrEngine Instanziierung entfällt. IronOCR-Thread-Instanzen sind ressourcenschonend – es erfolgt keine externe Modellladung bei der Erstellung. Das Multithreading-Beispiel veranschaulicht Muster für die parallele Verarbeitung in Pipelines mit hohem Durchsatz.

Mehrbild-TIFF-Verarbeitung

RapidOCR.NET akzeptiert nur einzelne Bilddateien. Die Verarbeitung eines mehrseitigen TIFFs — das Standardformat für per Fax empfangene Dokumente und gescannte Archive — erfordert das Zerlegen in einzelne Rahmen mit einer separaten Bildverarbeitungsbibliothek, das Speichern dieser Rahmen in temporären Dateien, das Ausführen von engine.Run() auf jedem und das anschließende Bereinigen.IronOCR verarbeitet mehrseitige TIFFs nativ über OcrInput.LoadImageFrames.

Ansatz von RapidOCR.NET:

using RapidOcrNet;
// Also requires: SixLabors.ImageSharp or System.Drawing for TIFF frame extraction

public class TiffOcrProcessor
{
    private readonly RapidOcrEngine _engine;

    public TiffOcrProcessor(string modelDir)
    {
        _engine = new RapidOcrEngine(new RapidOcrOptions
        {
            DetModelPath = Path.Combine(modelDir, "det.onnx"),
            ClsModelPath = Path.Combine(modelDir, "cls.onnx"),
            RecModelPath = Path.Combine(modelDir, "rec_en.onnx"),
            KeysPath     = Path.Combine(modelDir, "en_keys.txt")
        });
    }

    public string ProcessMultiPageTiff(string tiffPath)
    {
        var pageTexts = new List<string>();
        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
        Directory.CreateDirectory(tempDir);

        try
        {
            // External library required to split TIFF frames
            var framePaths = SplitTiffIntoFrames(tiffPath, tempDir); // not in RapidOcrNet

            foreach (var framePath in framePaths)
            {
                var result = _engine.Run(framePath);
                pageTexts.Add(string.Join("\n",
                    result.TextBlocks
                          .OrderBy(b => b.BoundingBox.Top)
                          .Select(b => b.Text)));
            }
        }
        finally
        {
            // Clean up temp frame files
            Directory.Delete(tempDir, recursive: true);
        }

        return string.Join("\n\n", pageTexts);
    }

    private IEnumerable<string> SplitTiffIntoFrames(string tiffPath, string outputDir)
    {
        // Requires external library — implementation depends on what is installed
        throw new NotImplementedException("Add SixLabors.ImageSharp or similar");
    }
}
C#

IronOCR Ansatz:

using IronOcr;

public class TiffOcrProcessor
{
    private readonly IronTesseract _ocr = new IronTesseract();

    public string ProcessMultiPageTiff(string tiffPath)
    {
        using var input = new OcrInput();
        input.LoadImageFrames(tiffPath); // All frames loaded — no external library needed

        var result = _ocr.Read(input);
        return result.Text; // Pages assembled in order automatically
    }

    public IEnumerable<(int PageNumber, string Text, double Confidence)> ProcessTiffWithPageData(string tiffPath)
    {
        using var input = new OcrInput();
        input.LoadImageFrames(tiffPath);

        var result = _ocr.Read(input);

        foreach (var page in result.Pages)
            yield return (page.PageNumber, page.Text, page.Confidence);
    }
}
C#

Keine externe Bildbearbeitungsbibliothek, keine temporären Dateien, keine Bereinigungslogik. LoadImageFrames liest alle TIFF-Rahmen in die OcrInput Pipeline in einem einzigen Aufruf ein. Die Anleitung zur TIFF- und GIF-Eingabe behandelt die Auswahl von Frames, die Filterung von Seitenbereichen und den speichereffizienten Umgang mit großen Dokumenten mit mehreren Frames.

Extraktion strukturierter Daten aus gescannten Formularen

RapidOCR.NET gibt Textblöcke mit Begrenzungsrahmen zurück, jedoch ohne übergeordnete Dokumentstruktur – es gibt keine Unterscheidung zwischen Absätzen, Zeilen oder Wörtern. Das Extrahieren einzelner Felder aus einem gescannten Formular erfordert das Schreiben einer Logik zur Koordinatenschnittpunktbestimmung anhand der rohen Blockliste.IronOCR liefert einen strukturierten Ergebnisbaum bis auf Zeichenebene, mit Koordinaten auf jeder Ebene.

Ansatz von RapidOCR.NET:

using RapidOcrNet;

public class FormFieldExtractor
{
    private readonly RapidOcrEngine _engine;

    public FormFieldExtractor(string modelDir)
    {
        _engine = new RapidOcrEngine(new RapidOcrOptions
        {
            DetModelPath = Path.Combine(modelDir, "det.onnx"),
            ClsModelPath = Path.Combine(modelDir, "cls.onnx"),
            RecModelPath = Path.Combine(modelDir, "rec_en.onnx"),
            KeysPath     = Path.Combine(modelDir, "en_keys.txt")
        });
    }

    // Extract text within a defined region by filtering block coordinates manually
    public string ExtractFieldByRegion(string imagePath, float regionLeft, float regionTop,
                                        float regionRight, float regionBottom)
    {
        var result = _engine.Run(imagePath);

        // Filter blocks whose bounding box intersects the target region
        var blocksInRegion = result.TextBlocks
            .Where(b =>
                b.BoundingBox.Left   < regionRight  &&
                b.BoundingBox.Right  > regionLeft   &&
                b.BoundingBox.Top    < regionBottom &&
                b.BoundingBox.Bottom > regionTop)
            .OrderBy(b => b.BoundingBox.Top)
            .ThenBy(b => b.BoundingBox.Left);

        return string.Join(" ", blocksInRegion.Select(b => b.Text));
    }
}
C#

IronOCR Ansatz:

using IronOcr;

public class FormFieldExtractor
{
    private readonly IronTesseract _ocr = new IronTesseract();

    // Use CropRectangle to OCR only the target region — no post-filter needed
    public string ExtractFieldByRegion(string imagePath, int x, int y, int width, int height)
    {
        var region = new CropRectangle(x, y, width, height);

        using var input = new OcrInput();
        input.LoadImage(imagePath, region);

        return _ocr.Read(input).Text;
    }

    // Extract all fields with their coordinates from a full-page scan
    public IEnumerable<(string Text, int X, int Y, double Confidence)> ExtractAllWords(string imagePath)
    {
        var result = _ocr.Read(imagePath);

        foreach (var page in result.Pages)
            foreach (var word in page.Words)
                yield return (word.Text, word.X, word.Y, word.Confidence);
    }
}
C#

CropRectangle beschränkt die OCR auf das exakte Interessengebiet, was schneller und genauer ist als die Ausführung einer Vollseiten-OCR und das anschließende Filtern der Ergebnisse. Pro-Wort-Koordinaten und Vertrauenswerte sind direkt auf result.Pages[i].Words verfügbar, ohne dass manuelle Bounding-Box-Überschneidung erforderlich ist. Die Anleitung zur regionenbasierten OCR und das Beispiel zum Zuschneide-Rechteck behandeln dieses Muster ausführlich.

RapidOCR.NET-API-zu-IronOCR-Mapping-Referenz

RapidOCR.NETIronOCR-Äquivalent
using RapidOcrNetusing IronOcr
new RapidOcrEngine(new RapidOcrOptions { ... })new IronTesseract()
RapidOcrOptions.DetModelPathNicht erforderlich – intern gebündelt
RapidOcrOptions.ClsModelPathNicht erforderlich – intern gebündelt
RapidOcrOptions.RecModelPathNicht erforderlich – intern gebündelt
RapidOcrOptions.KeysPathNicht erforderlich – intern gebündelt
RapidOcrOptions.UseGpuNicht zutreffend – intern CPU-optimiert
RapidOcrOptions.NumThreadsVerwenden Sie Parallel.ForEach mit einem IronTesseract pro Thread
engine.Run(imagePath)ocr.Read(imagePath)
engine.Dispose()using var ocr = new IronTesseract()
result.TextBlocksresult.Pages[i].Words / .Lines / .Paragraphs
result.TextBlocks[i].Textresult.Words[i].Text
result.TextBlocks[i].Confidenceresult.Words[i].Confidence
result.TextBlocks[i].BoundingBox.Topresult.Words[i].Y
result.TextBlocks[i].BoundingBox.Leftresult.Words[i].X
Manuelle OrderBy(b => b.BoundingBox.Top) SortierungNicht erforderlich — result.Text ist in Lesereihenfolge
string.Join("\n", result.TextBlocks.Select(b => b.Text))result.Text
Sprachdatei austauschen (anderes Modell herunterladen)ocr.Language = OcrLanguage.French
Engine-Neuerstellung für SprachwechselNicht erforderlich — ocr.Language pro Aufruf einstellen
PDF-zu-Bild + engine.Run() Schleifeocr.Read("document.pdf")
Manuelle Bildaufteilung bei Multi-Frame-TIFF-Dateieninput.LoadImageFrames("document.tiff")
Keine durchsuchbare PDF-Funktionresult.SaveAsSearchablePdf("output.pdf")
Keine BarCode-Funktionalitätocr.Configuration.ReadBarCodes = true

Gängige Migrationsprobleme und Lösungen

Problem 1: Das Verzeichnis "Models" ist nach der Migration weiterhin vorhanden

RapidOCR.NET: Das models/ Verzeichnis im Projekt enthält det.onnx, cls.onnx, rec_en.onnx und en_keys.txt sowie MSBuild <Content> Einträge, die sie beim Erstellen kopieren. Nach dem Wechsel zu IronOCR bleiben dieses Verzeichnis und diese Einträge bestehen und vergrößern weiterhin die Build-Ausgabe.

Lösung: Löschen Sie das models/ Verzeichnis, entfernen Sie die entsprechenden <ItemGroup> aus .csproj und entfernen Sie jegliche Startüberprüfungslogik, die auf fehlende Dateien prüfte. Entfernen Sie auch den Microsoft.ML.OnnxRuntime NuGet-Verweis, wenn er separat installiert war. Die veröffentlichte Ausgabe einer .NET-Anwendung, die IronOCR verwendet, enthält keine externen Modelldateien.

<!-- Remove this entire block from .csproj -->
<ItemGroup>
  <Content Include="models\**\*.*">
    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
  </Content>
</ItemGroup>
XML

Thema 2: Konstruktionsmuster für pro-Thread-Engines

RapidOCR.NET: Parallelverarbeitungscode, der einen neuen RapidOcrEngine pro Thread erstellte, um Probleme mit gemeinsam genutzten Zuständen zu vermeiden, trug einen erheblichen Speicherverbrauch: Jede Engine-Instanz lud unabhängig voneinander 300–500 MB ONNX-Modellgewichte.

**Lösung:**IronOCRIronTesseract Instanzen sind threadsicher und leichtgewichtig. Erstellen Sie eine pro Thread in einem Parallel.ForEach, ohne sich Sorgen über Kosten für die Modellladung pro Instanz zu machen. Der IronOCR-Ansatz ist identisch mit dem Beispiel zur Batch-Verarbeitungsmigration oben — IronTesseract behandelt dieses Szenario mit demselben pro-Thread-Konstruktionsmuster, jedoch ohne die 300–500 MB Modellladungskosten, die jede RapidOcrEngine-Instanz trug. Das Multithreading-Beispiel zeigt das Standardmuster für Pipelines mit hohem Durchsatz.

Problem 3: Ausnahme "Sprache wird nicht unterstützt"

RapidOCR.NET: Code, der Nicht-CJK-Dokumente über RapidOCR.NET leitete – oder versuchte, eine Engine mit einem nicht vorhandenen Spanisch-/Französisch-/Deutsch-Modell zu erstellen –, würde zur Laufzeit einen "Datei nicht gefunden"-Fehler auslösen oder leere Ergebnisse liefern.

Lösung: Installieren Sie das entsprechende Sprachpaket-NuGet-Paket und setzen Sie ocr.Language auf den Zielwert des OcrLanguage-Enums. Kein Modell-Download, kein Engine-Neuaufbau, kein zusätzlicher Codepfad für jede Sprache:

> dotnet add package IronOcr.Languages.Spanish, IronOcr.Languages.French, IronOcr.Languages.Arabic

var ocr = new IronTesseract();
ocr.Language = OcrLanguage.Spanish;
var result = ocr.Read("spanish-document.jpg");
C#

Der Leitfaden zu benutzerdefinierten Sprachpaketen behandelt erweiterte Sprachkonfigurationen, die über die standardmäßigen mehr als 125 Pakete hinausgehen.

Problem 4: Die Sortierlogik für Textblöcke funktioniert nach der Migration nicht mehr

RapidOCR.NET: Da result.TextBlocks eine ungeordnete flache Liste war, enthielten Codebasen typischerweise .OrderBy(b => b.BoundingBox.Top).ThenBy(b => b.BoundingBox.Left)-Ketten, die im gesamten Ergebnisverarbeitungscode verstreut waren.

Lösung: Diese Sortierlogik vollständig entfernen. result.Text in IronOCR ist bereits in natürlicher Lesereihenfolge zusammengesetzt. Für Code, der auch von den sortierten Blöcken Bounding-Box-Koordinaten verbrauchte, ersetzen Sie die Blockreferenz durch result.Pages[i].Words[j]:

// Before: manual sort + coordinate extraction
var sorted = result.TextBlocks
    .OrderBy(b => b.BoundingBox.Top)
    .ThenBy(b => b.BoundingBox.Left);

foreach (var block in sorted)
    Console.WriteLine($"{block.Text} at ({block.BoundingBox.Left}, {block.BoundingBox.Top})");

// After: structured access, already in order
foreach (var page in result.Pages)
    foreach (var word in page.Words)
        Console.WriteLine($"{word.Text} at ({word.X}, {word.Y})");
C#

Problem 5: CI/CD-Pipeline schlägt fehl, nachdem Modelldateien entfernt wurden

RapidOCR.NET: Build-Pipelines, die das models/ Verzeichnis als separaten Schritt cachieren oder abrufen – entweder aus einem Artefaktstore, einem gemeinsamen S3-Bucket oder einem Git LFS-Repository – werden fehlschlagen, wenn diese Schritte nichts zur Wiederherstellung finden nach der Migration.

Lösung: Entfernen Sie die Schritte zum Abrufen und Zwischenspeichern der Modelldatei vollständig aus der CI-Pipeline. IronOCRs Engine wird als Teil des Standard-dotnet restore Schritts wiederhergestellt. Es sind keine zusätzlichen Pipeline-Stufen erforderlich. Für containerisierte Bereitstellungen entfernen Sie alle COPY models/ ./models/ Docker-Anweisungen — der Docker-Bereitstellungsleitfaden von IronOCR dokumentiert das eine erforderliche Systempaket (libgdiplus auf Debian/Ubuntu-Images) und sonst nichts.

Problem 6: ONNX-Runtime-Versionskonflikte nach teilweiser Migration

RapidOCR.NET: Anwendungen, die auch andere ONNX-basierte ML-Pakete (ML.NET, ONNX-Objekterkennung usw.) verwendeten, könnten Microsoft.ML.OnnxRuntime auf eine bestimmte Version fixiert haben, um RapidOCR.NET-Kompatibilität sicherzustellen. Das Entfernen von RapidOCR.NET kann Versionskonflikte in diesen anderen Paketen aufdecken.

Lösung: Entfernen Sie Microsoft.ML.OnnxRuntime aus der expliziten Paketliste.IronOCR hat keine ONNX-Runtime-Abhängigkeit, sodass die Entfernung des RapidOCR.NET-Verweises die Versionsfixierung vollständig eliminiert. Andere ML-Pakete, die tatsächlich ONNX Runtime benötigen, können dann ihre eigene kompatible Version über die standardmäßige NuGet-Abhängigkeitsauflösung ohne die Einschränkung durch RapidOCR.NET ermitteln.

RapidOCR.NET-Migrationscheckliste

Vor der Migration anfallende Aufgaben

Überprüfen Sie den Code auf alle Verwendungen von RapidOCR.NET, bevor Sie Änderungen vornehmen:

# Find all files that reference RapidOcrNet
grep -r "RapidOcrNet\|RapidOcrEngine\|RapidOcrOptions" --include="*.cs" .

# Find model path configuration
grep -r "DetModelPath\|ClsModelPath\|RecModelPath\|KeysPath" --include="*.cs" .

# Find MSBuild model copy entries
grep -r "det\.onnx\|cls\.onnx\|rec.*\.onnx\|keys\.txt" --include="*.csproj" .

# Find model validation logic
grep -r "ValidateModel\|models/" --include="*.cs" .

# Find ONNX Runtime references
grep -r "OnnxRuntime\|Microsoft\.ML" --include="*.csproj" .

# Find language-switching patterns (multiple engine instances per language)
grep -r "CreateEnglishEngine\|CreateChineseEngine\|rec_en\|ch_rec\|en_keys\|ch_keys" --include="*.cs" .
SHELL

Inventarisieren Sie die Ergebnisse: Notieren Sie jede Stelle, an der eine Engine erstellt wird, jede Stelle, an der Modellpfade konfiguriert werden, jede Stelle, an der Textblöcke sortiert werden, und jede Stelle, an der PDF-zu-Bild-Konvertierung in engine.Run() eingespeist wird.

Aufgaben der Code-Aktualisierung

  1. Entfernen Sie den RapidOcrNet NuGet-Paketverweis aus allen .csproj Dateien.
  2. Entfernen Sie den Microsoft.ML.OnnxRuntime NuGet-Paketverweis aus allen .csproj Dateien.
  3. Installieren Sie das IronOcr NuGet-Paket.
  4. Installieren Sie NuGet-Pakete für Sprachpakete für alle nicht-englischen Sprachen, die die Anwendung benötigt.
  5. Löschen Sie das models/ Verzeichnis aus dem Projekt und dem Repository.
  6. Entfernen Sie <Content Include="models\**\*.*"> MSBuild-Einträge aus allen .csproj Dateien.
  7. Entfernen Sie Startmodell-Validierungsmethoden (die EnsureModelsPresent-Stil-Methoden).
  8. Ersetzen Sie using RapidOcrNet mit using IronOcr in allen Quelldateien.
  9. Ersetzen Sie new RapidOcrEngine(new RapidOcrOptions { ... })with new IronTesseract().
  10. Ersetzen Sie engine.Run(imagePath) mit ocr.Read(imagePath).
  11. Ersetzen Sie die result.TextBlocks Assembly-Ketten (.OrderBy().Select(b => b.Text)) mit result.Text.
  12. Ersetzen Sie die Feldextraktion zur Koordinatenfilterung durch CropRectangle Regionseingabe.
  13. Ersetzen Sie die pro-Thread-Engine-Konstruktion durch pro-Thread IronTesseract Konstruktion.
  14. Ersetzen Sie sprachspezifische Engine-Fabrikenmethoden durch ocr.Language = OcrLanguage.X Zuweisungen.
  15. Entfernen Sie PDF-zu-Bild-Konvertierungscode und ersetzen Sie ihn durch direkte ocr.Read("file.pdf") Aufrufe.
  16. Entfernen Sie den Mehrbild-TIFF-Rahmenteilungscode und ersetzen Sie ihn durch input.LoadImageFrames("file.tiff").
  17. Fügen Sie IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY" beim Start der Anwendung hinzu.
  18. Entfernen Sie die Schritte zum Abrufen und Zwischenspeichern von Modelldateien aus den CI/CD-Pipeline-Definitionen.
  19. Entfernen Sie ONNX-Modell COPY Anweisungen aus Dockerfiles.

Post-Migrationstests

  • Stellen Sie sicher, dass alle bestehenden Bild-OCR-Pfade Text mit einer Genauigkeit zurückgeben, die der von RapidOCR.NET entspricht oder diese übertrifft.
  • Bestätigen Sie, dass die result.Text Lesereihenfolge der erwarteten Feldreihenfolge für jeden Dokumenttyp entspricht.
  • Testen Sie sprachumschaltbare Lesevorgänge für jeden OcrLanguage Wert, den die Anwendung verwendet.
  • Führen Sie den parallelen Batch-Prozessor aus und stellen Sie sicher, dass keine Thread-Konfliktfehler oder Probleme mit veralteten Ergebnissen auftreten.
  • Überprüfen Sie, ob die Verarbeitung von TIFF-Dateien mit mehreren Frames die richtige Anzahl von Seiten mit korrektem Text pro Seite zurückgibt.
  • Testen Sie die Formularfeldeextraktion über CropRectangle gegen die erwarteten Koordinatenregionen.
  • Bestätigen Sie, dass das models/ Verzeichnis im Build-Output und in den Bereitstellungspaketen nicht vorhanden ist.
  • Führen Sie die CI-Pipeline durch und stellen Sie sicher, dass keine Modellabrufschritte mehr vorhanden sind.
  • Erstellen und führen Sie einen Docker-Container aus und bestätigen Sie, dass keine COPY models/ Schicht oder Datei-nicht-gefunden-Fehler beim Start auftreten.
  • Testen Sie die Startzeitmessung, um zu überprüfen, ob die Latenz beim Kaltstart gesunken ist.

Wichtigste Vorteile der Migration zu IronOCR

Die Bereitstellung ist jetzt deterministisch. dotnet restore und dotnet publish erzeugen eine vollständige, funktionierende OCR-Bereitstellung ohne externe Dateiabhängigkeiten. Der gleiche NuGet-Restore, der die Paketversion installiert, installiert alles, was die Engine zum Laufen benötigt. Es gibt keine Modelldateien, die separat versioniert werden müssen, keine CI-Cache-Schritte, die konfiguriert werden müssen, und keine Skripte zur Validierung der Bereitstellung, die gepflegt werden müssen. Die Pipeline ist so einfach wie jede andere .NET-Paketabhängigkeit.

Die Sprachabdeckung skaliert mit den Geschäftsanforderungen. Die Unterstützung für eine neue Dokumentsprache hinzuzufügen bedeutet, dotnet add package IronOcr.Languages.X auszuführen und ocr.Language einzustellen. Es erfolgt keine Überprüfung der Verfügbarkeit von Upstream-Modellen, kein Herunterladen von Modellen und keine Refaktorisierung der Engine. Teams, die mit englischer OCR beginnen und später deutsche Verträge, arabische Rechnungen oder russische Bestellungen verarbeiten müssen, erweitern den Anwendungsbereich, ohne die Anwendungsarchitektur zu verändern. Alle über 125 Sprachpakete folgen dem gleichen Installationsmuster.

Strukturierter Output beseitigt Koordinatenassembly-Code. Die result.Pages, .Paragraphs, .Lines, .Words und .Characters Hierarchie ersetzt die flache TextBlocks Liste und die Sortierlogik, die ohne Struktur arbeitete. Code, der Text in Lesereihenfolge durch Sortieren von Blockkoordinaten extrahiert hat, wurde entfernt. Code, der pro-Wort Bounding-Boxen benötigte, erhält diese von word.X, word.Y, word.Width, word.Height ohne Überschneidungsfilterung. Die Seite mit den OCR-Ergebnissen dokumentiert das vollständige Ausgabemodell.

Für die Verarbeitung von PDF- und TIFF-Dateien sind keine externen Bibliotheken erforderlich. Die beiden gängigsten Dokumentformate neben Einzelbild-JPGs – mehrseitige PDFs und mehrseitige TIFFs – werden von IronOCR nativ verarbeitet. Jede externe Bibliothek, die dem Abhängigkeitsbaum hinzugefügt wurde, um engine.Run() mit PDF oder TIFF-Eingaben zu unterstützen, kann entfernt werden. Das Ergebnis: weniger zu aktualisierende Pakete, weniger Versionskompatibilitätsprobleme und einfachere Projektdateien. Die Anleitungen zur PDF-Eingabe und zur TIFF-Eingabe behandeln beide Formate ausführlich.

Produktionsvorfälle haben einen Support-Pfad. Kommerzielle Lizenzen beinhalten direkten E-Mail-Support mit einem Ansprechpartner für Probleme, die nicht auf eine Antwort über GitHub warten können. Teams mit SLA-Verpflichtungen oder geschäftskritischen Dokumentenverarbeitungsprozessen können Vorfälle an die Entwickler eskalieren, die die Bibliothek warten, anstatt auf eine Antwort der Community zu warten. Der IronOCR-Dokumentationshub bietet neben diesem Support-Pfad auch Referenzdokumentation.

Die $999 unbefristete Lizenz ist eine einmalige Kosten. Es gibt keine pro-Seiten-Preisgestaltung, keine pro-Transaktionsabrechnung und keine jährliche Verlängerung, die das Kostengespräch erneut eröffnet. Entwicklungsteams, die die für Modellverwaltung, PDF-Konvertierungs-Workarounds, CI-Pipeline-Wartung und Eskalationen bei nicht unterstützten Sprachen aufgewendeten Entwicklungsstunden kalkuliert haben, kommen im Vergleich zu den Lizenzkosten durchweg zu einem positiven Ergebnis.

Hinweis:: RapidOCR und Tesseract sind eingetragene Marken ihrer jeweiligen Eigentümer. Diese Seite steht nicht in Verbindung mit, wird nicht von Google oder RapidOCR unterstützt oder gesponsert. Alle Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Eigentümer. Vergleiche dienen nur zu Informationszwecken und spiegeln öffentlich zugängliche Informationen zum Zeitpunkt des Schreibens wider.
Kannaopat Udonpant
Kannapat Udonpant
Software Ingenieur

Verwandte Artikel

Key in blue circle

Holen Sie sich sofort Ihren kostenlosen 30-Tage-Testschlüssel.

Your trial license will be sent to your email address

Keine Einschränkungen. 100 % freigeschaltet. Keine Kreditkarte.

bullet_checkedIhr Testlizenzschlüssel wurde Ihnen per E-Mail gesendet.Keine Einschränkungen. 100 % freigeschaltet. Keine Kreditkarte.
  • Logo Aetna
  • Logo NASA
  • Logo GE
  • Logo Porsche
  • Logo USDA
  • Logo Qatar
Join Millions of Engineers who’ve tried IronPDF
Erhalten Sie Ihre unverbindliche Beratung
Füllen Sie das Formular unten aus oder senden Sie eine E-Mail an sales@ironsoftware.com
Ihre Daten werden immer vertraulich behandelt.
Von Millionen von Ingenieur*innen weltweit vertraut
Kundenlogos von Iron Software
Erhalten Sie sofort Ihren kostenlosen 30-Tage-Testschlüssel.
Ihr Testlizenzschlüssel wurde Ihnen per E-Mail gesendet.