Cómo depurar el OCR en C#

Updated: 9 de mayo de 2026

IronOCR le permite detectar fallos de OCR en la fuente, evaluar la calidad de reconocimiento a nivel de palabra y carácter, y monitorear trabajos de larga duración en tiempo real. Herramientas integradas como el registro de archivos de diagnóstico, una jerarquía de excepciones tipadas, puntuación de confianza por resultado, y el evento OcrProgress apoyan estos flujos de trabajo en los canales de producción.

Esta guía repasa ejemplos prácticos para cada uno de ellos: habilitar el registro de diagnóstico, gestionar excepciones tipadas, validar la salida con puntuaciones de confianza, supervisar el progreso de los trabajos en tiempo real y aislar errores en canalizaciones por lotes.

Inicio rápido: Habilitar el registro de diagnóstico OCR completo

Establezca LogFilePath y LoggingModo en la clase Installation antes de la primera llamada de Read. Solo se necesitan dos propiedades para capturar la inicialización de Tesseract, la carga del paquete de idiomas y los detalles del procesamiento en un archivo de registro.

1Install IronOCR with NuGet Package Manager
PM > Install-Package IronOcr
```
Install-Package IronOcr
```

2Copie y ejecute este fragmento de código.

IronOcr.Installation.LogFilePath = "ocr.log"; IronOcr.Installation.LoggingModo = IronOcr.Installation.LoggingModos.All;

IronOcr.Installation.LogFilePath = "ocr.log"; IronOcr.Installation.LoggingModo = IronOcr.Installation.LoggingModos.All;

3Despliegue para probar en su entorno real

Comienza a usar IronOCR en tu proyecto hoy mismo con una prueba gratuita

Flujo de trabajo mínimo (5 pasos)

Descargar una biblioteca C# para la depuración de OCR
Establezca LogFilePath en una ruta de archivo en la que se pueda escribir
Establezca LoggingModo en Todo para una captura de diagnóstico completa
Ejecute su operación de OCR y reproduzca el problema
Revisa el archivo de registro generado para ver las advertencias del motor y los detalles del procesamiento

¿Cómo activo el registro de diagnóstico?

La clase Installation expone tres controles de registro. Establezca estos antes de llamar a cualquier método de Read.

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;

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

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

LoggingModo accepts flag values from the LoggingModos enum:

Tabla 1: Opciones de LoggingModos
Modo	Texto de salida	Caso de uso
`Ninguna`	Desactivado	Producción con supervisión externa
`Depuración`	Ventana de salida de depuración del IDE	Desarrollo local
`Archivo`	`LogFilePath`	Recopilación de registros del lado del servidor
`Todo`	Depuración + Archivo	Captura de diagnóstico completa

La propiedad CustomLogger admite cualquier implementación de Microsoft.Extensions.Logging.ILogger, permitiéndole dirigir diagnósticos de OCR a Serilog, NLog, u otros sumideros de registro estructurado en su canal. Use ClearLogFiles para eliminar los datos de registro acumulados entre ejecuciones.

Una vez habilitado el registro, el siguiente paso es comprender qué excepciones puede lanzar IronOCR y cómo gestionar cada una de ellas.

¿Qué excepciones lanza IronOCR?

IronOCR define excepciones tipadas bajo el espacio de nombres IronOcr.Exceptions. Detectar estos casos de forma específica, en lugar de utilizar un bloque de captura general, permite dirigir cada tipo de fallo a la ruta de corrección adecuada.

Tabla 2: Referencia de excepciones de IronOCR
Excepción	Causa común	Corregir
`IronOcrInputException`	Imagen/PDF dañada o no compatible	Validar el archivo antes de cargarlo en `OcrInput`
`IronOcrProductException`	Error interno del motor durante la ejecución del OCR	Habilitar el registro, comprobar la salida del registro, actualizar a la última versión de NuGet
`IronOcrDictionaryException`	Faltan o están dañados los archivos de idioma `.traineddata`	Reinstala el paquete de idiomas NuGet o configura `LanguagePackDirectory`
`IronOcrNativeException`	Error de interoperabilidad nativa de C++	Instala Visual C++ Redistributable; comprueba la compatibilidad con AVX
`IronOcrLicensingException`	Clave de licencia perdida o caducada	Establezca `LicenseKey` antes de llamar a `Read`
`LanguagePackException`	No se ha encontrado el paquete de idioma en la ruta esperada	Comprueba `LanguagePackDirectory` o reinstala el paquete de idiomas de NuGet
`IronOcrAssemblyVersionMismatchException`	Versiones de ensamblado no coincidentes tras una actualización parcial	Borrar la caché de NuGet, restaurar los paquetes y asegurarse de que todos los paquetes de IronOCR coincidan

Utilice el siguiente bloque try-catch para gestionar cada tipo de excepción por separado, aplicando filtros de excepciones para el registro condicional.

Entrada

Una factura de proveedor de una sola página de IronOCR Solutions a Acme Corporation, cargada a través de LoadPdf en OcrInput. Incluye cuatro partidas, impuestos y un total general: suficiente variedad de texto para que cada gestor de excepciones tenga un ejercicio realista.

invoice_scan.PDF: Factura del proveedor (n.º INV-2024-7829) utilizada para demostrar cada controlador de excepciones tipado en secuencia.

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

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 = New IronTesseract()

Try
    Using input = 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

Imports IronOcr
Imports IronOcr.Exceptions

Dim ocr = New IronTesseract()

Try
    Using input = 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

Resultado

Resultado satisfactorio

La factura se carga correctamente y el motor devuelve un recuento de caracteres junto con una puntuación de confianza.

Salida de terminal que muestra la lectura OCR correcta de invoice_scan.PDF con recuento de caracteres y puntuación de confianza

Resultado fallido

Salida de terminal que muestra la excepción lanzada al cargar un archivo PDF que no se encuentra

Ordena los bloques catch de más específico a más general. La cláusula when en IronOcrNativeException filtra fallos relacionados con AVX sin capturar errores nativos no relacionados. Cada controlador registra el mensaje de excepción; El bloque catch-all también captura el seguimiento de la pila para el análisis posterior.

Detectar la excepción correcta te indica que algo ha salido mal, pero no te dice cómo funcionó el motor cuando sí tuvo éxito. Para ello, utilice puntuaciones de confianza.

¿Cómo puedo validar el resultado del OCR con puntuaciones de confianza?

Cada OcrResult expone una propiedad Confidence, un valor entre 0 y 1 que representa la certeza estadística del motor promediada a lo largo de todos los caracteres reconocidos. Puede acceder a esto en todos los niveles de la jerarquía de resultados: documento, página, párrafo, WORD y carácter.

Utilice un patrón de control de umbral para evitar que los resultados de baja calidad se propaguen a las etapas posteriores.

Entrada

Un recibo térmico con productos detallados, descuentos, totales, y un código de barras, cargado a través de LoadImage. Su anchura reducida, su fuente monoespaciada y su letra tenue lo convierten en una prueba de estrés práctica para los umbrales de confianza por palabra.

receipt.png: Escaneo de recibo térmico utilizado para demostrar la validación de confianza con umbral y la precisión por palabra para la imagen del recibo

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

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

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

Resultado

Salida de terminal que muestra la puntuación de confianza, la decisión de aceptar/marcar/rechazar y un desglose por palabra de baja confianza para la imagen del recibo

Este patrón es esencial en los flujos de trabajo en los que el OCR alimenta procesos de introducción de datos, procesamiento de facturas o flujos de trabajo de cumplimiento normativo. El desglose por palabra identifica exactamente qué regiones de la imagen original causaron la degradación; A continuación, puede aplicar filtros de calidad de imagen o correcciones de orientación y volver a procesar. Para obtener más información sobre la puntuación de confianza, consulte la guía práctica sobre los niveles de confianza.

Para trabajos de larga duración, la confianza por sí sola no es suficiente. También necesita saber si el motor aún está haciendo progreso, y ahí es donde entra el evento OcrProgress.

¿Cómo puedo supervisar el progreso del OCR en tiempo real?

Para documentos de múltiples páginas, el evento OcrProgress en IronTesseract se activa después de completar cada página. El objeto OcrProgressEventArgs expone el porcentaje de progreso, duración transcurrida, total de páginas, y páginas completadas. El ejemplo utiliza como entrada este informe trimestral de tres páginas: un documento empresarial estructurado que incluye un resumen ejecutivo, un desglose de ingresos y métricas operativas.

Entrada

Un informe financiero del primer trimestre de 2024 de tres páginas cargado a través de LoadPdf. La primera página incluye el resumen ejecutivo con métricas de KPI, la segunda contiene tablas de ingresos por línea de productos y región, y la tercera abarca los volúmenes de procesamiento operativo; cada tipo de página genera un tiempo de procesamiento por página distinto que se puede observar en las llamadas de progreso.

quarterly_report.pdf: Informe financiero del primer trimestre de 2024 de tres páginas (resumen ejecutivo, desglose de ingresos, métricas operativas) utilizado para demostrar las devoluciones de llamada de OcrProgress en tiempo real por página.

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

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 As 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

Imports IronOcr

Dim ocr As 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

Resultado

Salida de terminal que muestra las llamadas de retorno del evento OcrProgress por página con el porcentaje completado y el tiempo transcurrido para un PDF de tres páginas

Integre este evento en su infraestructura de registro para realizar un seguimiento de la duración de los trabajos de OCR y detectar atascos. Si el tiempo transcurrido supera un umbral sin que el porcentaje de progreso avance, el canal puede marcar el trabajo para su investigación. Esto resulta especialmente útil para el procesamiento por lotes de archivos PDF, donde una sola página malformada puede paralizar todo el trabajo.

El seguimiento del progreso muestra el estado de ejecución, pero un error a nivel de archivo puede detener todo el lote si no se aísla.

¿Cómo gestiono los errores en los procesos de OCR por lotes?

En producción, un error en un solo archivo no debe detener todo el lote. Aísle los errores por archivo, registre los fallos con su contexto y elabore un informe resumido al final. El ejemplo procesa una carpeta de documentos escaneados que contiene una factura, una orden de compra, un contrato de servicio, y un archivo intencionalmente dañado para activar la ruta de error. A continuación se muestra un ejemplo representativo:

Entrada

Una carpeta de PDFs pasada a Directory.GetFiles — una factura, una orden de compra, un contrato de servicio, y un archivo intencionalmente corrupto. Los dos ejemplos representativos a continuación muestran la variedad de documentos que el canal procesa en una sola ejecución.

batch-scan-01.PDF: Factura de Bright Horizon Ltd. (INV-2024-001) — OCR realizado con éxito.

batch-scan-02.PDF: Orden de compra para TechSupply Inc. (PO-2024-042) — segundo tipo de documento en la misma tanda.

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

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

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, 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

Imports IronOcr
Imports IronOcr.Exceptions

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, 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

Resultado

El bloque catch externo gestiona errores imprevistos, como tiempos de espera de red en el almacenamiento compartido, problemas de permisos o situaciones de falta de memoria en archivos TIFF de gran tamaño. Cada error registra la ruta del archivo y el mensaje de error para el resumen, mientras que el bucle continúa procesando los archivos restantes. El archivo de registro en batch_debug.log captura detalles a nivel del motor para cualquier archivo que active diagnósticos internos.

Para ejecución no bloqueante en servicios o aplicaciones web, IronOCR admite ReadAsync, que usa la misma estructura try-catch.

Si el proceso se ejecuta sin errores pero el texto extraído sigue siendo incorrecto, la causa principal suele ser casi siempre la calidad de la imagen, más que el código. A continuación se explica cómo abordar esto.

¿Cómo puedo depurar la precisión del OCR?

Si las puntuaciones de confianza son sistemáticamente bajas, el problema radica en la imagen original y no en el motor de OCR. IronOCR proporciona herramientas de preprocesamiento para solucionar esto:

Aplica filtros de calidad de imagen, como nitidez, eliminación de ruido, dilatación y erosión, para mejorar la claridad del texto
Utilice la corrección de orientación para enderezar y rotar automáticamente los documentos escaneados
Ajusta la configuración de DPI para las imágenes de baja resolución antes de procesarlas
Utilizar la visión artificial para detectar y aislar regiones de texto en diseños complejos
La utilidad IronOCR te permite probar visualmente combinaciones de filtros y exportar la configuración óptima de C#

Para cuestiones específicas de implementación, IronOCR ofrece guías de resolución de problemas específicas para Azure Functions, Docker y Linux, así como para la configuración general del Entorno.

¿Qué paso debo dar a continuación?

Ahora que ya sabes cómo depurar IronOCR en tiempo de ejecución, explora:

Navegación por la estructura de los resultados del OCR y los metadatos, incluyendo páginas, bloques, párrafos, palabras y coordenadas
Comprensión de la puntuación de confianza en cada nivel de la jerarquía de resultados
Usando async y multithreading con ReadAsync para canales de alto rendimiento.
Navegar por la referencia completa de API para obtener la lista completa de propiedades

Para el uso en producción, recuerde obtener una licencia para eliminar las marcas de agua y acceder a la funcionalidad completa.

Preguntas Frecuentes

¿Cuáles son los problemas más comunes al depurar el OCR en C#?

Entre los problemas habituales se incluyen resultados de OCR incorrectos, puntuaciones de confianza bajas y excepciones inesperadas. IronOCR proporciona herramientas como el registro y la puntuación de confianza para ayudar a identificar y resolver estos problemas.

¿Cómo ayuda IronOCR en la gestión de errores en C#?

IronOCR ofrece excepciones tipadas y mensajes de error detallados, lo que ayuda a comprender y gestionar los errores de forma eficaz durante la operación de OCR en aplicaciones C#.

¿Qué funciones de registro ofrece IronOCR para la depuración?

IronOCR incluye capacidades de registro integradas que ayudan a realizar un seguimiento de los procesos de OCR e identificar posibles problemas mediante el registro de información detallada sobre las operaciones de OCR.

¿Cómo puede la puntuación de confianza mejorar los resultados del OCR?

La puntuación de confianza de IronOCR ayuda a determinar la precisión del texto reconocido, lo que permite a los desarrolladores centrarse en las áreas de baja confianza y mejorar los resultados del OCR.

¿Puedo realizar un seguimiento del progreso de las tareas de OCR utilizando IronOCR?

Sí, IronOCR ofrece funciones de seguimiento del progreso que permiten a los desarrolladores supervisar el estado y la duración de las tareas de OCR, lo que facilita una mejor gestión de los recursos y la optimización del rendimiento.

¿Qué patrones try-catch se recomiendan para la gestión de errores de OCR?

IronOCR sugiere utilizar patrones try-catch listos para producción para gestionar las excepciones de forma elegante, garantizando que las aplicaciones de OCR sigan siendo robustas y fáciles de mantener.

¿Cómo pueden las herramientas integradas de IronOCR mejorar la depuración del OCR?

Las herramientas de IronOCR, como el registro, las excepciones tipificadas y la puntuación de confianza, proporcionan un soporte completo para identificar y resolver problemas, mejorando así el proceso de depuración.

¿Por qué es importante el registro de errores en las aplicaciones de OCR?

El registro de errores es crucial, ya que proporciona información sobre lo que ha fallado durante el procesamiento OCR, lo que permite a los desarrolladores diagnosticar y solucionar rápidamente los problemas en sus aplicaciones.

¿Qué papel desempeñan las excepciones tipadas en la depuración de IronOCR?

Las excepciones tipadas en IronOCR proporcionan información específica sobre los errores, lo que facilita a los desarrolladores comprender la naturaleza del problema y aplicar las soluciones adecuadas durante la depuración.

¿Cómo pueden beneficiarse los desarrolladores de las funciones de depuración de IronOCR?

Los desarrolladores pueden aprovechar las funciones de depuración de IronOCR para resolver problemas de forma eficiente, mejorar la estabilidad de las aplicaciones y aumentar la calidad general de los resultados del OCR.

Curtis Chau

Chatea con el equipo de ingeniería ahora

Escritor Técnico

Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien estructurados y visualmente atractivos.

...