Wie man OCR in C# debuggt

This article was translated from English: Does it need improvement?
Translated
View the article in English

Mit IronOCR können Sie OCR-Fehler an der Quelle erkennen, die Erkennungsqualität auf Wort- und Zeichenebene bewerten und lang laufende Jobs in Echtzeit überwachen. Integrierte Tools wie die Protokollierung von Diagnosedateien, eine typisierte Ausnahmehierarchie, eine Konfidenzbewertung pro Ergebnis und das OcrProgress-Ereignis unterstützen diese Arbeitsabläufe in Produktionspipelines.

Dieser Leitfaden führt Sie durch praktische Beispiele für jeden einzelnen Punkt: Aktivieren der Diagnoseprotokollierung, Behandeln von typisierten Ausnahmen, Validieren der Ausgabe mit Konfidenzwerten, Überwachen des Jobfortschritts in Echtzeit und Isolieren von Fehlern in Batch-Pipelines.

Schnellstart: Vollständige OCR-Diagnoseprotokollierung aktivieren

Setzen Sie LogFilePath und LoggingModus in der Klasse Installation vor dem ersten Aufruf von Read. Es genügen zwei Eigenschaften, um die Initialisierung von Tesseract, das Laden von Sprachpaketen und Verarbeitungsdetails in einer Protokolldatei zu erfassen.

  1. Installieren Sie IronOCR mit NuGet Package Manager

    PM > Install-Package IronOcr
  2. Kopieren Sie diesen Codeausschnitt und führen Sie ihn aus.

    IronOcr.Installation.LogFilePath = "ocr.log"; IronOcr.Installation.LoggingModus = IronOcr.Installation.LoggingModes.All;
  3. Bereitstellen zum Testen in Ihrer Live-Umgebung

    Beginnen Sie noch heute, IronOCR in Ihrem Projekt zu verwenden, mit einer kostenlosen Testversion

    arrow pointer


Wie aktiviere ich die Diagnoseprotokollierung?

Die Klasse Installation stellt drei Protokollierungssteuerelemente bereit. Legen Sie diese fest, bevor Sie eine Read-Methode aufrufen.

:path=/static-assets/ocr/content-code-examples/how-to/debugging-enable-logging.cs
using IronOcr;

// Write logs to a specific file
Installation.LogFilePath = "logs/ocr_diagnostics.log";

// Enable all logging channels: file + debug output
Installation.LoggingMode = Installation.LoggingModes.All;

// Or pipe logs into your existing ILogger pipeline
Installation.CustomLogger = myLoggerInstance;
Imports IronOcr

' Write logs to a specific file
Installation.LogFilePath = "logs/ocr_diagnostics.log"

' Enable all logging channels: file + debug output
Installation.LoggingMode = Installation.LoggingModes.All

' Or pipe logs into your existing ILogger pipeline
Installation.CustomLogger = myLoggerInstance
$vbLabelText   $csharpLabel

LoggingModus akzeptiert Flag-Werte aus der Enumeration LoggingModuss:

Tabelle 1: Optionen für die Protokollierungsmodi
ModusAusgabezielAnwendungsfall
KeineDeaktiviertProduktion mit externer Überwachung
DebugIDE-Debug-AusgabefensterLokale Entwicklung
DateiLogFilePathserverseitige Protokollerfassung
AlleDebug + DateiVollständige Diagnoseerfassung

Die CustomLogger-Eigenschaft unterstützt jede Microsoft.Extensions.Logging.ILogger-Implementierung und ermöglicht es Ihnen, OCR-Diagnosedaten an Serilog, NLog oder andere strukturierte Protokollierungs-Sinks in Ihrer Pipeline weiterzuleiten. Verwenden Sie ClearLogFiles, um zwischen den Durchläufen angesammelte Protokolldaten zu entfernen.

Nachdem die Protokollierung eingerichtet ist, besteht der nächste Schritt darin, zu verstehen, welche Ausnahmen IronOCR auslösen kann und wie man jede einzelne behandelt.

Welche Ausnahmen wirft IronOCR ?

IronOCR definiert typisierte Ausnahmen unter dem Namespace IronOcr.Exceptions. Indem man diese Fehler gezielt abfängt, anstatt einen allgemeinen Fehlerblock zu verwenden, kann man jeden Fehlertyp dem richtigen Abhilfepfad zuweisen.

Tabelle 2: IronOCR -Ausnahmereferenz
AusnahmeGemeinsame UrsacheKorrektur
IronOcrInputAusnahmeBeschädigtes oder nicht unterstütztes Bild/PDFDatei vor dem Laden in OcrInput validieren.
IronOcrProductAusnahmeInterner Engine-Fehler während der OCR-AusführungProtokollierung aktivieren, Protokollausgabe prüfen, auf die neueste NuGet Version aktualisieren
IronOcrDictionaryAusnahmeFehlende oder beschädigte .traineddata -SprachdateiInstallieren Sie das Sprachpaket NuGet oder legen Sie LanguagePackDirectory fest.
IronOcrNativeAusnahmeInteroperabilitätsfehler in nativem C++Installieren Sie die Visual C++ Redistributable ; überprüfen Sie die AVX-Unterstützung.
IronOcrLicensingAusnahmeFehlender oder abgelaufener LizenzschlüsselSetzen Sie LicenseKey vor dem Aufruf Read
LanguagePackAusnahmeSprachpaket nicht im erwarteten Pfad gefundenÜberprüfen Sie LanguagePackDirectory oder installieren Sie das NuGet Sprachpaket neu.
IronOcrAssemblyVersionMismatchAusnahmeNach einer Teilaktualisierung traten Versionskonflikte in der Assembly auf.Leeren Sie den NuGet Cache, stellen Sie die Pakete wieder her und stellen Sie sicher, dass alle IronOCR Pakete übereinstimmen.

Verwenden Sie den folgenden try-catch-Block, um jeden Ausnahmetyp separat zu behandeln und Ausnahmefilter für die bedingte Protokollierung anzuwenden.

Eingabe

Eine einseitige Lieferantenrechnung von IronOCR Solutions an Acme Corporation, die über LoadPdf in OcrInput geladen wurde. Es umfasst vier Einzelposten, die Steuer und eine Gesamtsumme – genug Textvielfalt, um jedem Ausnahmebehandler eine realistische Übung zu bieten.

invoice_scan.pdf: Lieferantenrechnung (Nr. INV-2024-7829), die verwendet wird, um die einzelnen typisierten Ausnahmebehandlungsroutinen nacheinander zu demonstrieren.

:path=/static-assets/ocr/content-code-examples/how-to/debugging-exception-handling.cs
using IronOcr;
using IronOcr.Exceptions;

var ocr = new IronTesseract();

try
{
    using var input = new OcrInput();
    input.LoadPdf("invoice_scan.pdf");

    OcrResult result = ocr.Read(input);
    Console.WriteLine($"Text: {result.Text}");
    Console.WriteLine($"Confidence: {result.Confidence:P1}");
}
catch (IronOcrInputException ex)
{
    // File could not be loaded — corrupt, locked, or unsupported format
    Console.Error.WriteLine($"Input error: {ex.Message}");
}
catch (IronOcrDictionaryException ex)
{
    // Language pack missing — common in containerized deployments
    Console.Error.WriteLine($"Language pack error: {ex.Message}");
}
catch (IronOcrNativeException ex) when (ex.Message.Contains("AVX"))
{
    // CPU does not support AVX instructions
    Console.Error.WriteLine($"Hardware incompatibility: {ex.Message}");
}
catch (IronOcrLicensingException)
{
    Console.Error.WriteLine("License key is missing or invalid.");
}
catch (IronOcrProductException ex)
{
    // Catch-all for other IronOCR engine errors
    Console.Error.WriteLine($"OCR engine error: {ex.Message}");
    Console.Error.WriteLine($"Stack trace: {ex.StackTrace}");
}
Imports IronOcr
Imports IronOcr.Exceptions

Dim ocr As New IronTesseract()

Try
    Using input As New OcrInput()
        input.LoadPdf("invoice_scan.pdf")

        Dim result As OcrResult = ocr.Read(input)
        Console.WriteLine($"Text: {result.Text}")
        Console.WriteLine($"Confidence: {result.Confidence:P1}")
    End Using
Catch ex As IronOcrInputException
    ' File could not be loaded — corrupt, locked, or unsupported format
    Console.Error.WriteLine($"Input error: {ex.Message}")
Catch ex As IronOcrDictionaryException
    ' Language pack missing — common in containerized deployments
    Console.Error.WriteLine($"Language pack error: {ex.Message}")
Catch ex As IronOcrNativeException When ex.Message.Contains("AVX")
    ' CPU does not support AVX instructions
    Console.Error.WriteLine($"Hardware incompatibility: {ex.Message}")
Catch ex As IronOcrLicensingException
    Console.Error.WriteLine("License key is missing or invalid.")
Catch ex As IronOcrProductException
    ' Catch-all for other IronOCR engine errors
    Console.Error.WriteLine($"OCR engine error: {ex.Message}")
    Console.Error.WriteLine($"Stack trace: {ex.StackTrace}")
End Try
$vbLabelText   $csharpLabel

Ausgabe

Erfolgsergebnis

Die Rechnung wird fehlerfrei geladen und die Engine gibt die Zeichenanzahl sowie einen Konfidenzwert zurück.

Terminalausgabe zeigt erfolgreiches OCR-Lesen von invoice_scan.pdf mit Zeichenanzahl und Konfidenzwert an.

Fehlgeschlagene Ausgabe

Terminalausgabe mit der Meldung, dass beim Laden einer fehlenden PDF-Datei eine Ausnahme ausgelöst wurde.

Ordnen Sie die Fangblöcke von den spezifischsten zu den allgemeinsten. Die Klausel when auf IronOcrNativeAusnahme filtert AVX-bezogene Fehler heraus, ohne nicht damit zusammenhängende native Fehler zu erfassen. Jeder Handler protokolliert die Ausnahmemeldung; Der Catch-All-Block erfasst auch den Stack-Trace für die anschließende Analyse.

Das Abfangen der richtigen Ausnahme signalisiert, dass etwas schiefgelaufen ist, aber nicht, wie gut der Motor funktioniert hat, als er erfolgreich war. Verwenden Sie dazu Konfidenzwerte.

Wie validiere ich OCR-Ausgaben mit Konfidenzwerten?

Jedes OcrResult stellt eine Confidence-Eigenschaft bereit, einen Wert zwischen 0 und 1, der die statistische Sicherheit der Engine im Durchschnitt aller erkannten Zeichen angibt. Sie können darauf auf jeder Ebene der Ergebnishierarchie zugreifen: Dokument , Seite ,Absatz , Wort undZeichen .

Verwenden Sie ein schwellenwertbasiertes Muster, um zu verhindern, dass minderwertige Ergebnisse nachgelagert weitergegeben werden.

Eingabe

Ein Thermobeleg mit Einzelposten, Rabatten, Summen und einem BARCODE, geladen über LoadImage. Durch seine geringe Breite, die nichtproportionale Schriftart und die schwache Schrift eignet es sich hervorragend als Stresstest für Konfidenzschwellenwerte pro Wort.

Beispiel eines Thermobons von FoodMart mit Einzelaufstellung der Einkäufe, Gesamtsumme und als OCR-Eingabe verwendeten Bonuspunkten

receipt.png: Thermoquittungsscan, verwendet, um die Schwellenwert-gesteuerte Vertrauensvalidierung und die Genauigkeitsdurchdringung pro Wort für das Quittungsbild zu demonstrieren

:path=/static-assets/ocr/content-code-examples/how-to/debugging-confidence-scoring.cs
using IronOcr;

var ocr = new IronTesseract();
using var input = new OcrInput();
input.LoadImage("receipt.png");

OcrResult result = ocr.Read(input);
double confidence = result.Confidence;

Console.WriteLine($"Overall confidence: {confidence:P1}");

// Threshold-gated decision
if (confidence >= 0.90)
{
    Console.WriteLine("ACCEPT — high confidence, processing result.");
    ProcessResult(result.Text);
}
else if (confidence >= 0.70)
{
    Console.WriteLine("FLAG — moderate confidence, queuing for review.");
    QueueForReview(result.Text, confidence);
}
else
{
    Console.WriteLine("REJECT — low confidence, logging for investigation.");
    LogRejection("receipt.png", confidence);
}

// Drill into per-page and per-word confidence for diagnostics
foreach (var page in result.Pages)
{
    Console.WriteLine($"  Page {page.PageNumber}: {page.Confidence:P1}");

    var lowConfidenceWords = page.Words
        .Where(w => w.Confidence < 0.70)
        .ToList();

    foreach (var word in lowConfidenceWords)
    {
        Console.WriteLine($"    Low-confidence word: \"{word.Text}\" ({word.Confidence:P1})");
    }
}
Imports IronOcr

Dim ocr As New IronTesseract()
Using input As New OcrInput()
    input.LoadImage("receipt.png")

    Dim result As OcrResult = ocr.Read(input)
    Dim confidence As Double = result.Confidence

    Console.WriteLine($"Overall confidence: {confidence:P1}")

    ' Threshold-gated decision
    If confidence >= 0.9 Then
        Console.WriteLine("ACCEPT — high confidence, processing result.")
        ProcessResult(result.Text)
    ElseIf confidence >= 0.7 Then
        Console.WriteLine("FLAG — moderate confidence, queuing for review.")
        QueueForReview(result.Text, confidence)
    Else
        Console.WriteLine("REJECT — low confidence, logging for investigation.")
        LogRejection("receipt.png", confidence)
    End If

    ' Drill into per-page and per-word confidence for diagnostics
    For Each page In result.Pages
        Console.WriteLine($"  Page {page.PageNumber}: {page.Confidence:P1}")

        Dim lowConfidenceWords = page.Words _
            .Where(Function(w) w.Confidence < 0.7) _
            .ToList()

        For Each word In lowConfidenceWords
            Console.WriteLine($"    Low-confidence word: ""{word.Text}"" ({word.Confidence:P1})")
        Next
    Next
End Using
$vbLabelText   $csharpLabel

Ausgabe

Terminalausgabe mit Konfidenzbewertung, Entscheidung (Annehmen/Markieren/Ablehnen) und detaillierter Aufschlüsselung der einzelnen Wörter mit geringer Konfidenz für das Belegbild

Dieses Muster ist unerlässlich in Prozessabläufen, in denen OCR in die Dateneingabe, die Rechnungsverarbeitung oder Compliance-Workflows einfließt. Die detaillierte Analyse jedes einzelnen Wortes identifiziert genau die Bereiche des Quellbildes, die zu Bildfehlern geführt haben; Anschließend können Sie Bildqualitätsfilter oder Ausrichtungskorrekturen anwenden und das Bild erneut verarbeiten. Für einen detaillierteren Einblick in die Konfidenzbewertung siehe die Anleitung zu den Konfidenzstufen .

Bei langjährigen Jobs reicht Selbstvertrauen allein nicht aus. Sie müssen auch wissen, ob die Engine noch Fortschritte macht, und hier kommt das OcrProgress-Ereignis ins Spiel.

Wie kann ich den OCR-Fortschritt in Echtzeit überwachen?

Bei mehrseitigen Dokumenten wird das OcrProgress-Ereignis auf IronTesseract ausgelöst, sobald eine Seite vollständig geladen ist. Das OcrProgressEventArgs-Objekt gibt den Fortschritt in Prozent, die verstrichene Zeit, die Gesamtseitenzahl und die Anzahl der abgeschlossenen Seiten an. Das Beispiel verwendet diesen dreiseitigen Quartalsbericht als Grundlage: ein strukturiertes Geschäftsdokument, das eine Managementzusammenfassung, eine Umsatzaufschlüsselung und operative Kennzahlen umfasst.

Eingabe

Ein dreiseitiger Finanzbericht für das 1. Quartal 2024, geladen über LoadPdf. Seite eins enthält die Managementzusammenfassung mit KPI-Kennzahlen, Seite zwei enthält Umsatztabellen nach Produktlinie und Region, und Seite drei behandelt die operativen Verarbeitungsvolumina – jeder Seitentyp erzeugt eine unterschiedliche Zeit pro Seite, die Sie in den Fortschritts-Callbacks beobachten können.

quarterly_report.pdf: Three-page Q1 2024 financial report (executive summary, revenue breakdown, operational metrics) used to demonstrate real-time `OcrProgress` callbacks per page.

:path=/static-assets/ocr/content-code-examples/how-to/debugging-progress-monitoring.cs
using IronOcr;

var ocr = new IronTesseract();

ocr.OcrProgress += (sender, e) =>
{
    Console.WriteLine(
        $"[OCR] {e.ProgressPercent}% complete | " +
        $"Page {e.PagesComplete}/{e.TotalPages} | " +
        $"Elapsed: {e.Duration.TotalSeconds:F1}s"
    );
};

using var input = new OcrInput();
input.LoadPdf("quarterly_report.pdf");

OcrResult result = ocr.Read(input);
Console.WriteLine($"Finished in {result.Pages.Count()} pages, confidence: {result.Confidence:P1}");
Imports IronOcr

Dim ocr = New IronTesseract()

AddHandler ocr.OcrProgress, Sub(sender, e)
    Console.WriteLine(
        $"[OCR] {e.ProgressPercent}% complete | " &
        $"Page {e.PagesComplete}/{e.TotalPages} | " &
        $"Elapsed: {e.Duration.TotalSeconds:F1}s"
    )
End Sub

Using input As New OcrInput()
    input.LoadPdf("quarterly_report.pdf")

    Dim result As OcrResult = ocr.Read(input)
    Console.WriteLine($"Finished in {result.Pages.Count()} pages, confidence: {result.Confidence:P1}")
End Using
$vbLabelText   $csharpLabel

Ausgabe

Terminalausgabe mit Anzeige der OcrProgress-Ereignis-Callbacks pro Seite, inklusive Fortschrittsanzeige in Prozent und verstrichener Zeit für ein dreiseitiges PDF

Integrieren Sie dieses Ereignis in Ihre Protokollierungsinfrastruktur, um die Dauer von OCR-Aufträgen zu verfolgen und Unterbrechungen zu erkennen. Wenn die verstrichene Zeit einen Schwellenwert überschreitet, ohne dass der Fortschritt in Prozent ansteigt, kann die Pipeline den Auftrag zur Untersuchung kennzeichnen. Dies ist besonders nützlich für die Stapelverarbeitung von PDFs, bei der eine einzige fehlerhafte Seite den gesamten Vorgang zum Stillstand bringen kann.

Die Fortschrittsüberwachung zeigt den Ausführungsstatus an, aber ein Fehler auf Dateiebene kann die gesamte Batchverarbeitung vorzeitig stoppen, wenn er nicht isoliert wird.

Wie gehe ich mit Fehlern in Batch-OCR-Pipelines um?

Im Produktionsbetrieb sollte der Fehler einer einzelnen Datei nicht den gesamten Batch stoppen. Isolieren Sie Fehler pro Datei, protokollieren Sie Fehler mit Kontext und erstellen Sie am Ende einen zusammenfassenden Bericht. Das Beispiel verarbeitet einen Ordner mit gescannten Dokumenten, der eine Rechnung, eine Bestellung, einen Dienstleistungsvertrag und eine absichtlich beschädigte Datei enthält, um den Fehlerpfad zu aktivieren. Nachfolgend ist ein repräsentatives Beispiel dargestellt:

Eingabe

Ein Ordner mit PDF-Dateien, der an Directory.GetFiles übergeben wurde – eine Rechnung, eine Bestellung, ein Dienstleistungsvertrag und eine absichtlich beschädigte Datei. Die beiden repräsentativen Beispiele unten zeigen die Vielfalt der Dokumente, die die Pipeline in einem einzigen Durchlauf verarbeitet.

:path=/static-assets/ocr/content-code-examples/how-to/debugging-batch-pipeline.cs
using IronOcr;
using IronOcr.Exceptions;

var ocr = new IronTesseract();
Installation.LogFilePath = "batch_debug.log";
Installation.LoggingMode = Installation.LoggingModes.File;

string[] files = Directory.GetFiles("scans/", "*.pdf");
int succeeded = 0, failed = 0;
double totalConfidence = 0;
var failures = new List<(string File, string Error)>();

foreach (string file in files)
{
    try
    {
        using var input = new OcrInput();
        input.LoadPdf(file);

        OcrResult result = ocr.Read(input);
        totalConfidence += result.Confidence;
        succeeded++;

        Console.WriteLine($"OK: {Path.GetFileName(file)} — {result.Confidence:P1}");
    }
    catch (IronOcrInputException ex)
    {
        failed++;
        failures.Add((file, $"Input error: {ex.Message}"));
        Console.Error.WriteLine($"FAIL: {Path.GetFileName(file)} — {ex.Message}");
    }
    catch (IronOcrProductException ex)
    {
        failed++;
        failures.Add((file, $"Engine error: {ex.Message}"));
        Console.Error.WriteLine($"FAIL: {Path.GetFileName(file)} — {ex.Message}");
    }
    catch (Exception ex)
    {
        failed++;
        failures.Add((file, $"Unexpected: {ex.Message}"));
        Console.Error.WriteLine($"FAIL: {Path.GetFileName(file)} — {ex.GetType().Name}: {ex.Message}");
    }
}

// Summary report
Console.WriteLine($"\n--- Batch Summary ---");
Console.WriteLine($"Total: {files.Length} | Passed: {succeeded} | Failed: {failed}");
if (succeeded > 0)
    Console.WriteLine($"Average confidence: {totalConfidence / succeeded:P1}");

foreach (var (f, err) in failures)
    Console.WriteLine($"  {Path.GetFileName(f)}: {err}");
Imports IronOcr
Imports IronOcr.Exceptions
Imports System.IO

Dim ocr As New IronTesseract()
Installation.LogFilePath = "batch_debug.log"
Installation.LoggingMode = Installation.LoggingModes.File

Dim files As String() = Directory.GetFiles("scans/", "*.pdf")
Dim succeeded As Integer = 0
Dim failed As Integer = 0
Dim totalConfidence As Double = 0
Dim failures As New List(Of (File As String, Error As String))()

For Each file As String In files
    Try
        Using input As New OcrInput()
            input.LoadPdf(file)

            Dim result As OcrResult = ocr.Read(input)
            totalConfidence += result.Confidence
            succeeded += 1

            Console.WriteLine($"OK: {Path.GetFileName(file)} — {result.Confidence:P1}")
        End Using
    Catch ex As IronOcrInputException
        failed += 1
        failures.Add((file, $"Input error: {ex.Message}"))
        Console.Error.WriteLine($"FAIL: {Path.GetFileName(file)} — {ex.Message}")
    Catch ex As IronOcrProductException
        failed += 1
        failures.Add((file, $"Engine error: {ex.Message}"))
        Console.Error.WriteLine($"FAIL: {Path.GetFileName(file)} — {ex.Message}")
    Catch ex As Exception
        failed += 1
        failures.Add((file, $"Unexpected: {ex.Message}"))
        Console.Error.WriteLine($"FAIL: {Path.GetFileName(file)} — {ex.GetType().Name}: {ex.Message}")
    End Try
Next

' Summary report
Console.WriteLine(vbCrLf & "--- Batch Summary ---")
Console.WriteLine($"Total: {files.Length} | Passed: {succeeded} | Failed: {failed}")
If succeeded > 0 Then
    Console.WriteLine($"Average confidence: {totalConfidence / succeeded:P1}")
End If

For Each failure In failures
    Console.WriteLine($"  {Path.GetFileName(failure.File)}: {failure.Error}")
Next
$vbLabelText   $csharpLabel

Ausgabe

Terminalausgabe mit den Ergebnissen der Batch-Pipeline, einschließlich der Zeichenanzahl pro Datei, der Konfidenzwerte, eines Fehlers aufgrund einer beschädigten PDF-Datei und einer Zusammenfassungszeile.

Der äußere Catch-Block behandelt unvorhergesehene Fehler wie Netzwerk-Timeouts bei gemeinsam genutztem Speicher, Berechtigungsprobleme oder Speichermangel bei großen TIFF-Dateien. Bei jedem Fehler werden der Dateipfad und die Fehlermeldung für die Zusammenfassung protokolliert, während die Schleife die Verarbeitung der verbleibenden Dateien fortsetzt. Die Logdatei unter batch_debug.log erfasst Details auf Engine-Ebene für jede Datei, die interne Diagnosen auslöst.

Für die nicht blockierende Ausführung in Diensten oder Webanwendungen unterstützt IronOCR ReadAsync, das dieselbe try-catch-Struktur verwendet.

Wenn die Pipeline fehlerfrei läuft, der extrahierte Text aber trotzdem fehlerhaft ist, liegt die Ursache fast immer in der Bildqualität und nicht im Code. So lässt sich das Problem lösen.

Wie kann ich die Genauigkeit der OCR-Texturierung verbessern?

Sind die Konfidenzwerte durchgehend niedrig, liegt das Problem am Quellbild und nicht am OCR-System. IronOCR bietet Vorverarbeitungswerkzeuge, um dieses Problem zu beheben:

Für spezifische Bereitstellungsprobleme unterhält IronOCR spezielle Leitfäden zur Fehlerbehebung für Azure Functions , Docker und Linux sowie zur allgemeinen Einrichtung der Umgebung .

Wohin soll ich als Nächstes reisen?

Nachdem Sie nun wissen, wie man IronOCR zur Laufzeit debuggt, erkunden Sie Folgendes:

Für den produktiven Einsatz müssen Sie eine Lizenz erwerben, um Wasserzeichen zu entfernen und die volle Funktionalität zu nutzen.

Häufig gestellte Fragen

Welche häufigen Probleme treten beim Debuggen von OCR in C# auf?

Häufige Probleme sind fehlerhafte OCR-Ergebnisse, niedrige Konfidenzwerte und unerwartete Ausnahmen. IronOCR bietet Tools wie Protokollierung und Konfidenzbewertung, um diese Probleme zu identifizieren und zu beheben.

Wie unterstützt IronOCR die Fehlerbehandlung in C#?

IronOCR bietet typisierte Ausnahmen und detaillierte Fehlermeldungen, die das Verständnis und die effektive Behandlung von Fehlern während der OCR-Operation in C#-Anwendungen erleichtern.

Welche Protokollierungsfunktionen bietet IronOCR für die Fehlersuche?

IronOCR verfügt über integrierte Protokollierungsfunktionen, die dabei helfen, OCR-Prozesse zu verfolgen und potenzielle Probleme zu identifizieren, indem detaillierte Informationen über die OCR-Operationen protokolliert werden.

Wie kann die Bewertung des Vertrauens die Ergebnisse der OCR verbessern?

Die Konfidenzbewertung in IronOCR hilft dabei, die Genauigkeit des erkannten Textes zu bestimmen, sodass sich die Entwickler auf Bereiche mit geringer Konfidenz konzentrieren und die OCR-Ergebnisse verbessern können.

Kann ich den Fortschritt von OCR-Aufgaben mit IronOCR verfolgen?

Ja, IronOCR bietet Funktionen zur Fortschrittsverfolgung, die es Entwicklern ermöglichen, den Status und die Dauer von OCR-Aufgaben zu überwachen und so ein besseres Ressourcenmanagement und eine Leistungsoptimierung zu ermöglichen.

Welche try-catch-Blöcke werden für die Fehlerbehandlung bei der OCR-Texturierung empfohlen?

IronOCR empfiehlt die Verwendung von produktionsreifen try-catch-Mustern, um Ausnahmen elegant zu behandeln und so sicherzustellen, dass OCR-Anwendungen robust und wartbar bleiben.

Wie können die in IronOCR integrierten Tools das OCR-Debugging verbessern?

Die Tools von IronOCR, wie z. B. Protokollierung, typisierte Ausnahmen und Konfidenzbewertung, bieten umfassende Unterstützung bei der Identifizierung und Behebung von Problemen und verbessern so den Debugging-Prozess.

Warum ist die Fehlerprotokollierung in OCR-Anwendungen wichtig?

Die Fehlerprotokollierung ist von entscheidender Bedeutung, da sie Aufschluss darüber gibt, was während der OCR-Verarbeitung schiefgelaufen ist, und es Entwicklern ermöglicht, Probleme in ihren Anwendungen schnell zu diagnostizieren und zu beheben.

Welche Rolle spielen typisierte Ausnahmen beim Debuggen von IronOCR?

Typisierte Ausnahmen in IronOCR liefern spezifische Fehlerinformationen und erleichtern es Entwicklern, die Art des Problems zu verstehen und während der Fehlersuche geeignete Lösungen anzuwenden.

Wie können Entwickler von den Debugging-Funktionen von IronOCR profitieren?

Entwickler können die Debugging-Funktionen von IronOCR nutzen, um Probleme effizient zu beheben, die Stabilität der Anwendung zu erhöhen und die Gesamtqualität der OCR-Ergebnisse zu verbessern.

Curtis Chau
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen
Bereit anzufangen?
Nuget Downloads 5,896,332 | Version: 2026.5 just released
Still Scrolling Icon

Scrollst du immer noch?

Sie brauchen schnell einen Beweis? PM > Install-Package IronOcr
Führen Sie ein Beispiel aus und beobachten Sie, wie Ihr Bild zu durchsuchbarem Text wird.