Wie man OCR in C# debuggt
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.
-
Installieren Sie IronOCR mit NuGet Package Manager
PM > Install-Package IronOcr -
Kopieren Sie diesen Codeausschnitt und führen Sie ihn aus.
IronOcr.Installation.LogFilePath = "ocr.log"; IronOcr.Installation.LoggingModus = IronOcr.Installation.LoggingModes.All; -
Bereitstellen zum Testen in Ihrer Live-Umgebung
Beginnen Sie noch heute, IronOCR in Ihrem Projekt zu verwenden, mit einer kostenlosen Testversion
Minimaler Arbeitsablauf (5 Schritte)
- Laden Sie eine C#-Bibliothek zum Debuggen von OCR herunter.
- Legen Sie
LogFilePathauf einen beschreibbaren Dateipfad fest - Stellen Sie
LoggingModusaufAlle, um eine vollständige Diagnoseerfassung zu ermöglichen. - Führen Sie Ihre OCR-Operation aus und reproduzieren Sie das Problem.
- Überprüfen Sie die generierte Protokolldatei auf Engine-Warnungen und Verarbeitungsdetails.
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
LoggingModus akzeptiert Flag-Werte aus der Enumeration LoggingModuss:
| Modus | Ausgabeziel | Anwendungsfall |
|---|---|---|
Keine | Deaktiviert | Produktion mit externer Überwachung |
Debug | IDE-Debug-Ausgabefenster | Lokale Entwicklung |
Datei | LogFilePath | serverseitige Protokollerfassung |
Alle | Debug + Datei | Vollstä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.
| Ausnahme | Gemeinsame Ursache | Korrektur |
|---|---|---|
IronOcrInputAusnahme | Beschädigtes oder nicht unterstütztes Bild/PDF | Datei vor dem Laden in OcrInput validieren. |
IronOcrProductAusnahme | Interner Engine-Fehler während der OCR-Ausführung | Protokollierung aktivieren, Protokollausgabe prüfen, auf die neueste NuGet Version aktualisieren |
IronOcrDictionaryAusnahme | Fehlende oder beschädigte .traineddata -Sprachdatei | Installieren Sie das Sprachpaket NuGet oder legen Sie LanguagePackDirectory fest. |
IronOcrNativeAusnahme | Interoperabilitätsfehler in nativem C++ | Installieren Sie die Visual C++ Redistributable ; überprüfen Sie die AVX-Unterstützung. |
IronOcrLicensingAusnahme | Fehlender oder abgelaufener Lizenzschlüssel | Setzen Sie LicenseKey vor dem Aufruf Read |
LanguagePackAusnahme | Sprachpaket nicht im erwarteten Pfad gefunden | Überprüfen Sie LanguagePackDirectory oder installieren Sie das NuGet Sprachpaket neu. |
IronOcrAssemblyVersionMismatchAusnahme | Nach 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
Ausgabe
Erfolgsergebnis
Die Rechnung wird fehlerfrei geladen und die Engine gibt die Zeichenanzahl sowie einen Konfidenzwert zurück.
Fehlgeschlagene Ausgabe
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.
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
Ausgabe
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
Ausgabe
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.
batch-scan-01.pdf: Rechnung für Bright Horizon Ltd. (INV-2024-001) — OCR-Durchlauf erfolgreich.
batch-scan-02.pdf: Bestellung für TechSupply Inc. (PO-2024-042) — zweiter Dokumenttyp im selben Scanlauf.
: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
Ausgabe
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:
- Wenden Sie Bildqualitätsfilter wie Schärfen, Rauschen entfernen, Dilatieren und Erodieren an, um die Textverständlichkeit zu verbessern.
- Verwenden Sie die Ausrichtungskorrektur , um gescannte Dokumente automatisch zu begradigen und zu drehen.
- Passen Sie die DPI-Einstellung für niedrig auflösende Bilder vor der Verarbeitung an.
- Computer Vision nutzen, um Textbereiche in komplexen Layouts zu erkennen und zu isolieren
- Mit dem IronOCR Dienstprogramm können Sie Filterkombinationen visuell testen und die optimale C#-Konfiguration exportieren.
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:
- Navigation durch die Struktur und Metadaten der OCR-Ergebnisse, einschließlich Seiten, Blöcke, Absätze, Wörter und Koordinaten
- Verständnis der Konfidenzbewertung auf jeder Ebene der Ergebnishierarchie
- Verwendung von Asynchronität und Multithreading mit
ReadAsyncfür Pipelines mit hohem Durchsatz - Durchsuchen Sie die vollständige API-Referenz für die vollständige Liste der Eigenschaften
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.

