IronOCR vs Iris OCR: ¿Qué solución de OCR deberían elegir los equipos de ingeniería?

El patrón de sondeo asíncrono

El requisito de asincronía de la API de lectura genera consecuencias estructurales en el código. El análisis de imágenes usando AnalyzeAsync devuelve inmediatamente pero requiere await; El procesamiento de PDF a través de Form Recognizer requiere WaitUntil.Completed para bloquear hasta que la operación termine, o una encuesta personalizada con UpdateStatusAsync para un comportamiento asincrónico real. La jerarquía de resultados requiere entonces recorrer bloques, líneas y palabras a través de bucles anidados:

// Azure Computer Vision: image OCR
// Requires: Azure subscription + Cognitive Services resource + endpoint + API key
using Azure;
using Azure.AI.Vision.ImageAnalysis;

public class AzureOcrService
{
    private readonly ImageAnalysisClient _client;

    public AzureOcrService(string endpoint, string apiKey)
    {
        // Endpoint and key provisioned in Azure portal
        _client = new ImageAnalysisClient(
            new Uri(endpoint),
            new AzureKeyCredential(apiKey));
    }

    public async Task<string> ExtractTextAsync(string imagePath)
    {
        // Document is uploaded to Microsoft Azure
        using var stream = File.OpenRead(imagePath);
        var imageData = BinaryData.FromStream(stream);

        var result = await _client.AnalyzeAsync(
            imageData,
            VisualFeatures.Read);

        var text = new StringBuilder();
        foreach (var block in result.Value.Read.Blocks)
        {
            foreach (var line in block.Lines)
            {
                text.AppendLine(line.Text);
            }
        }

        return text.ToString();
    }
}

// Azure Computer Vision: image OCR
// Requires: Azure subscription + Cognitive Services resource + endpoint + API key
using Azure;
using Azure.AI.Vision.ImageAnalysis;

public class AzureOcrService
{
    private readonly ImageAnalysisClient _client;

    public AzureOcrService(string endpoint, string apiKey)
    {
        // Endpoint and key provisioned in Azure portal
        _client = new ImageAnalysisClient(
            new Uri(endpoint),
            new AzureKeyCredential(apiKey));
    }

    public async Task<string> ExtractTextAsync(string imagePath)
    {
        // Document is uploaded to Microsoft Azure
        using var stream = File.OpenRead(imagePath);
        var imageData = BinaryData.FromStream(stream);

        var result = await _client.AnalyzeAsync(
            imageData,
            VisualFeatures.Read);

        var text = new StringBuilder();
        foreach (var block in result.Value.Read.Blocks)
        {
            foreach (var line in block.Lines)
            {
                text.AppendLine(line.Text);
            }
        }

        return text.ToString();
    }
}

Imports Azure
Imports Azure.AI.Vision.ImageAnalysis
Imports System.IO
Imports System.Text
Imports System.Threading.Tasks

Public Class AzureOcrService
    Private ReadOnly _client As ImageAnalysisClient

    Public Sub New(endpoint As String, apiKey As String)
        ' Endpoint and key provisioned in Azure portal
        _client = New ImageAnalysisClient(
            New Uri(endpoint),
            New AzureKeyCredential(apiKey))
    End Sub

    Public Async Function ExtractTextAsync(imagePath As String) As Task(Of String)
        ' Document is uploaded to Microsoft Azure
        Using stream = File.OpenRead(imagePath)
            Dim imageData = BinaryData.FromStream(stream)

            Dim result = Await _client.AnalyzeAsync(
                imageData,
                VisualFeatures.Read)

            Dim text = New StringBuilder()
            For Each block In result.Value.Read.Blocks
                For Each line In block.Lines
                    text.AppendLine(line.Text)
                Next
            Next

            Return text.ToString()
        End Using
    End Function
End Class

El procesamiento de PDF aumenta aún más la complejidad — un DocumentAnalysisClient separado con su propio endpoint, AnalyzeDocumentAsync con WaitUntil.Completed, y una forma de resultado diferente utilizando result.Pages y page.Lines accediendo a .Content en lugar de .Text.

Comparación detallada de características

Enfoque de Azure Computer Vision

Azure factura por transacción usando precios escalonados basados en volumen. Consulte la página de precios de Azure Computer Vision para tarifas actuales. Cada página del PDF es una transacción. Un PDF de 10 páginas equivale a 10 llamadas facturables. Está disponible un nivel gratuito de 5,000 transacciones por mes.

// Azure bills per transaction — costs grow with every document processed
// Free tier: 5,000 transactions/month
// Volume tiers apply at higher usage levels
// (Every PDF page multiplies the bill)

// Azure bills per transaction — costs grow with every document processed
// Free tier: 5,000 transactions/month
// Volume tiers apply at higher usage levels
// (Every PDF page multiplies the bill)

' Azure bills per transaction — costs grow with every document processed
' Free tier: 5,000 transactions/month
' Volume tiers apply at higher usage levels
' (Every PDF page multiplies the bill)

A volúmenes de documentos moderados a altos, la licencia perpetua de IronOCR se amortiza rápidamente en comparación con los costos de transacción continuos de Azure, después de lo cual cada documento adicional es ahorro.

Enfoque de IronOCR

El modelo de precios de IronOCR es una tarifa única. Instala el paquete NuGet, configura la clave de licencia y procesa cualquier volumen sin que el contador se active:

// Install: dotnet add package IronOcr
// License: one-time, perpetual

IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

var ocr = new IronTesseract();

// Process 1 document or 1 million — same cost
foreach (var path in documentPaths)
{
    var result = ocr.Read(path);
    Console.WriteLine($"Processed: {path}");
}

// Multi-page PDFs — no per-page billing
foreach (var path in pdfPaths)
{
    // 1 page or 100 pages, still no extra cost
    var result = ocr.Read(path);
    Console.WriteLine($"{path}: {result.Pages.Length} pages processed");
}

// Install: dotnet add package IronOcr
// License: one-time, perpetual

IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

var ocr = new IronTesseract();

// Process 1 document or 1 million — same cost
foreach (var path in documentPaths)
{
    var result = ocr.Read(path);
    Console.WriteLine($"Processed: {path}");
}

// Multi-page PDFs — no per-page billing
foreach (var path in pdfPaths)
{
    // 1 page or 100 pages, still no extra cost
    var result = ocr.Read(path);
    Console.WriteLine($"{path}: {result.Pages.Length} pages processed");
}

' Install: dotnet add package IronOcr
' License: one-time, perpetual

IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE")

Dim ocr As New IronTesseract()

' Process 1 document or 1 million — same cost
For Each path In documentPaths
    Dim result = ocr.Read(path)
    Console.WriteLine($"Processed: {path}")
Next

' Multi-page PDFs — no per-page billing
For Each path In pdfPaths
    ' 1 page or 100 pages, still no extra cost
    Dim result = ocr.Read(path)
    Console.WriteLine($"{path}: {result.Pages.Length} pages processed")
Next

No se necesita medición, seguimiento del uso ni alertas de presupuesto. Costes predecibles desde el primer día. Consulte el tutorial sobre lectura de texto a partir de imágenes para obtener una guía completa de introducción.

Enfoque de Azure Computer Vision

Incluso con la selección de puntos finales regionales y un acuerdo de socio comercial firmado, el flujo de datos es fijo:

// Azure: data flow for every OCR call
// 1. Your application reads the file
// 2. File is serialized to BinaryData
// 3. HTTPS transmission to Azure data center
// 4. Microsoft infrastructure processes the document
// 5. Result returned over HTTPS
// 6. You parse the result

using var stream = File.OpenRead(imagePath);
var imageData = BinaryData.FromStream(stream);  // Document in memory

// This call transmits your document to Azure
var result = await _client.AnalyzeAsync(
    imageData,           // Document leaves your network here
    VisualFeatures.Read);

// Azure: data flow for every OCR call
// 1. Your application reads the file
// 2. File is serialized to BinaryData
// 3. HTTPS transmission to Azure data center
// 4. Microsoft infrastructure processes the document
// 5. Result returned over HTTPS
// 6. You parse the result

using var stream = File.OpenRead(imagePath);
var imageData = BinaryData.FromStream(stream);  // Document in memory

// This call transmits your document to Azure
var result = await _client.AnalyzeAsync(
    imageData,           // Document leaves your network here
    VisualFeatures.Read);

Imports System.IO
Imports Azure.AI.FormRecognizer.DocumentAnalysis

' Azure: data flow for every OCR call
' 1. Your application reads the file
' 2. File is serialized to BinaryData
' 3. HTTPS transmission to Azure data center
' 4. Microsoft infrastructure processes the document
' 5. Result returned over HTTPS
' 6. You parse the result

Using stream As FileStream = File.OpenRead(imagePath)
    Dim imageData As BinaryData = BinaryData.FromStream(stream) ' Document in memory

    ' This call transmits your document to Azure
    Dim result = Await _client.AnalyzeAsync(
        imageData,           ' Document leaves your network here
        VisualFeatures.Read)
End Using

Una red aislada (air-gapped) no puede acceder en absoluto a la URL del punto final: Visión por computadora de Azure no dispone de modo sin conexión. Para las organizaciones que gestionan SCIF, instalaciones militares o entornos de procesamiento aislados, el servicio es arquitectónicamente incompatible, independientemente del precio.

Enfoque de IronOCR

IronOCR procesa documentos dentro del proceso de llamada. No hay conexión saliente:

// IronOCR: data never leaves your infrastructure
using IronOcr;

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

    public string ExtractText(string imagePath)
    {
        // Runs entirely in-process
        // No network call, no serialization to external endpoint
        var result = _ocr.Read(imagePath);
        return result.Text;
    }

    public string ExtractFromPdf(string pdfPath)
    {
        // PDF processed entirely on-premise, native support
        using var input = new OcrInput();
        input.LoadPdf(pdfPath);
        return _ocr.Read(input).Text;
    }

    public string ExtractFromEncryptedPdf(string pdfPath, string password)
    {
        // Encrypted PDFs also stay local
        using var input = new OcrInput();
        input.LoadPdf(pdfPath, Password: password);
        return _ocr.Read(input).Text;
    }
}

// IronOCR: data never leaves your infrastructure
using IronOcr;

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

    public string ExtractText(string imagePath)
    {
        // Runs entirely in-process
        // No network call, no serialization to external endpoint
        var result = _ocr.Read(imagePath);
        return result.Text;
    }

    public string ExtractFromPdf(string pdfPath)
    {
        // PDF processed entirely on-premise, native support
        using var input = new OcrInput();
        input.LoadPdf(pdfPath);
        return _ocr.Read(input).Text;
    }

    public string ExtractFromEncryptedPdf(string pdfPath, string password)
    {
        // Encrypted PDFs also stay local
        using var input = new OcrInput();
        input.LoadPdf(pdfPath, Password: password);
        return _ocr.Read(input).Text;
    }
}

Imports IronOcr

Public Class OnPremiseOcrService
    Private ReadOnly _ocr As New IronTesseract()

    Public Function ExtractText(imagePath As String) As String
        ' Runs entirely in-process
        ' No network call, no serialization to external endpoint
        Dim result = _ocr.Read(imagePath)
        Return result.Text
    End Function

    Public Function ExtractFromPdf(pdfPath As String) As String
        ' PDF processed entirely on-premise, native support
        Using input As New OcrInput()
            input.LoadPdf(pdfPath)
            Return _ocr.Read(input).Text
        End Using
    End Function

    Public Function ExtractFromEncryptedPdf(pdfPath As String, password As String) As String
        ' Encrypted PDFs also stay local
        Using input As New OcrInput()
            input.LoadPdf(pdfPath, Password:=password)
            Return _ocr.Read(input).Text
        End Using
    End Function
End Class

La implementación de Docker elimina por completo los requisitos de red de salida:

FROM mcr.microsoft.com/dotnet/aspnet:8.0
RUN apt-get update && apt-get install -y libgdiplus
WORKDIR /app
COPY --from=build /app/publish .
ENV IRONOCR_LICENSE=your-key
# No Azure endpoint, no API key, no outbound network rules needed
ENTRYPOINT ["dotnet", "YourApp.dll"]

Para entidades sujetas a la HIPAA, el cumplimiento de ITAR o escenarios FedRAMP con aislamiento físico,IronOCR elimina por completo el riesgo asociado a los procesadores de datos de terceros. Consulte la guía de implementación de Azure para ejecutar IronOCR dentro de la infraestructura de Azure manteniendo los documentos en la instancia de computación, y la guía de implementación de Docker para la configuración de contenedores.

Enfoque de Azure Computer Vision

Cada llamada OCR de Azure requiere await. El código de producción añade lógica de reintento para los errores de límite de velocidad 429 y los errores de servicio 5xx. Una implementación mínima de producción tendría este aspecto:

public async Task<string> RobustExtractAsync(string imagePath)
{
    const int maxRetries = 3;
    int attempt = 0;

    while (attempt < maxRetries)
    {
        try
        {
            using var stream = File.OpenRead(imagePath);
            var imageData = BinaryData.FromStream(stream);

            var result = await _client.AnalyzeAsync(
                imageData,
                VisualFeatures.Read);

            return string.Join("\n",
                result.Value.Read.Blocks
                    .SelectMany(b => b.Lines)
                    .Select(l => l.Text));
        }
        catch (RequestFailedException ex) when (ex.Status == 429)
        {
            // Rate limited — Azure caps S1 at 10 TPS
            attempt++;
            await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)));
        }
        catch (RequestFailedException ex) when (ex.Status >= 500)
        {
            // Azure service error
            attempt++;
            await Task.Delay(TimeSpan.FromSeconds(1));
        }
        catch (RequestFailedException ex)
        {
            // Client error — bad credential, invalid endpoint
            throw new Exception($"Azure OCR failed: {ex.Message}", ex);
        }
    }

    throw new Exception("Max retries exceeded for Azure OCR");
}

public async Task<string> RobustExtractAsync(string imagePath)
{
    const int maxRetries = 3;
    int attempt = 0;

    while (attempt < maxRetries)
    {
        try
        {
            using var stream = File.OpenRead(imagePath);
            var imageData = BinaryData.FromStream(stream);

            var result = await _client.AnalyzeAsync(
                imageData,
                VisualFeatures.Read);

            return string.Join("\n",
                result.Value.Read.Blocks
                    .SelectMany(b => b.Lines)
                    .Select(l => l.Text));
        }
        catch (RequestFailedException ex) when (ex.Status == 429)
        {
            // Rate limited — Azure caps S1 at 10 TPS
            attempt++;
            await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)));
        }
        catch (RequestFailedException ex) when (ex.Status >= 500)
        {
            // Azure service error
            attempt++;
            await Task.Delay(TimeSpan.FromSeconds(1));
        }
        catch (RequestFailedException ex)
        {
            // Client error — bad credential, invalid endpoint
            throw new Exception($"Azure OCR failed: {ex.Message}", ex);
        }
    }

    throw new Exception("Max retries exceeded for Azure OCR");
}

Imports System.IO
Imports System.Threading.Tasks

Public Async Function RobustExtractAsync(imagePath As String) As Task(Of String)
    Const maxRetries As Integer = 3
    Dim attempt As Integer = 0

    While attempt < maxRetries
        Try
            Using stream = File.OpenRead(imagePath)
                Dim imageData = BinaryData.FromStream(stream)

                Dim result = Await _client.AnalyzeAsync(
                    imageData,
                    VisualFeatures.Read)

                Return String.Join(vbCrLf,
                    result.Value.Read.Blocks _
                        .SelectMany(Function(b) b.Lines) _
                        .Select(Function(l) l.Text))
            End Using
        Catch ex As RequestFailedException When ex.Status = 429
            ' Rate limited — Azure caps S1 at 10 TPS
            attempt += 1
            Await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)))
        Catch ex As RequestFailedException When ex.Status >= 500
            ' Azure service error
            attempt += 1
            Await Task.Delay(TimeSpan.FromSeconds(1))
        Catch ex As RequestFailedException
            ' Client error — bad credential, invalid endpoint
            Throw New Exception($"Azure OCR failed: {ex.Message}", ex)
        End Try
    End While

    Throw New Exception("Max retries exceeded for Azure OCR")
End Function

No se trata de una ingeniería excesiva por precaución, sino del mínimo requerido para cualquier llamada a la API de Azure en producción. Los límites de velocidad, las interrupciones del servicio y los errores transitorios son situaciones reales a las que se enfrentará cualquier usuario de Azure.

Enfoque de IronOCR

El procesamiento local elimina la superficie de fallo de la red. El ámbito del manejo de errores se limita al sistema de archivos y a la validación de entradas:

// No async required — local processing returns synchronously
public string ExtractText(string imagePath)
{
    var result = new IronTesseract().Read(imagePath);
    return result.Text;
}

// One line for simple cases
public string OneLineOcr(string imagePath)
{
    return new IronTesseract().Read(imagePath).Text;
}

// Confidence-aware extraction
public (string Text, double Confidence) ExtractWithConfidence(string imagePath)
{
    var result = new IronTesseract().Read(imagePath);
    return (result.Text, result.Confidence);
}

// No async required — local processing returns synchronously
public string ExtractText(string imagePath)
{
    var result = new IronTesseract().Read(imagePath);
    return result.Text;
}

// One line for simple cases
public string OneLineOcr(string imagePath)
{
    return new IronTesseract().Read(imagePath).Text;
}

// Confidence-aware extraction
public (string Text, double Confidence) ExtractWithConfidence(string imagePath)
{
    var result = new IronTesseract().Read(imagePath);
    return (result.Text, result.Confidence);
}

Public Function ExtractText(imagePath As String) As String
    Dim result = New IronTesseract().Read(imagePath)
    Return result.Text
End Function

Public Function OneLineOcr(imagePath As String) As String
    Return New IronTesseract().Read(imagePath).Text
End Function

Public Function ExtractWithConfidence(imagePath As String) As (Text As String, Confidence As Double)
    Dim result = New IronTesseract().Read(imagePath)
    Return (result.Text, result.Confidence)
End Function

No RequestFailedException, no hay bucles de reintento, no hay coordinación Task.WhenAll para trabajos por lotes. Si necesita asincronía para la integración con un pipeline de controladores asincrónicos, Task.Run(() => ocr.Read(path)) envuelve la llamada sincrónica sin cambios estructurales a la lógica OCR en sí. La referencia de la API de IronTesseract cubre toda la interfaz síncrona. Para cargas de trabajo que realmente necesitan patrones asíncronos,IronOCR también ofrece una guía dedicada al OCR asíncrono.

Enfoque de Azure Computer Vision

La secuencia de configuración de Azure antes de escribir cualquier código OCR:

1. Crea una cuenta de Azure si aún no tienes una.
2. Acceda al portal de Azure y cree un recurso de Cognitive Services (o un recurso de Azure AI Services).
3. Selecciona un nivel de precios y una región.
4. Copie la URL del endpoint (formato: https://your-resource.cognitiveservices.azure.com/).
5. Copie una de las dos claves API.
6. Almacene ambos valores de forma segura — en variables de entorno, Azure Key Vault o appsettings.json (solo no producción).
7. Instale Azure.AI.Vision.ImageAnalysis mediante NuGet.
8. Inicialice ImageAnalysisClient con el endpoint y la credencial.

Para el procesamiento de PDF, repita los pasos 2-8 para un recurso de Form Recognizer con un paquete NuGet diferente (Azure.AI.FormRecognizer) y una clase de cliente diferente (DocumentAnalysisClient).

El appsettings.json almacena el endpoint y la clave:

{
  "Azure": {
    "ComputerVision": {
      "Endpoint": "https://your-resource.cognitiveservices.azure.com/",
      "ApiKey": "your-api-key"
    }
  }
}

La rotación de claves API, la gestión de la caducidad de credenciales y la gestión de las URL de los puntos finales en distintos entornos (desarrollo, staging, producción) son tareas operativas continuas que no tienen equivalente en el procesamiento local.

Enfoque de IronOCR

La guía de configuración de IronTesseract reduce la instalación a dos pasos:

dotnet add package IronOcr

// Set once at application startup — environment variable recommended
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

// Then use immediately — no endpoint, no credential rotation, no portal setup
var text = new IronTesseract().Read("document.jpg").Text;

// Set once at application startup — environment variable recommended
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

// Then use immediately — no endpoint, no credential rotation, no portal setup
var text = new IronTesseract().Read("document.jpg").Text;

Imports System

' Set once at application startup — environment variable recommended
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE")

' Then use immediately — no endpoint, no credential rotation, no portal setup
Dim text As String = (New IronTesseract()).Read("document.jpg").Text

La clave de licencia es una cadena estática. No caduca por solicitud, no requiere rotación y no realiza llamadas al servidor para validación tras la activación. Los entornos de implementación no necesitan reglas de firewall de salida para que el OCR funcione.

Requisitos de cumplimiento del procesamiento en la nube

Un proveedor independiente de software (ISV) del sector sanitario que está creando un sistema de gestión de documentos empieza con Visión por computadora de Azure porque es rápido de integrar. Entonces llega el primer cliente empresarial: un sistema hospitalario con un responsable de seguridad de la HIPAA que plantea dos preguntas: "¿A dónde va nuestra información médica protegida (PHI)?" y "¿Pueden mostrarnos el acuerdo de socio comercial (BAA) que cubre a ese tercero?". Azure tiene un BAA, pero la respuesta a la primera pregunta —"los centros de datos de Microsoft"— desencadena una larga revisión de seguridad, una solicitud de los informes de auditoría de Microsoft y un calendario de cumplimiento que retrasa el contrato. Cambiar a IronOCR elimina por completo la duda. La información médica protegida (PHI) nunca sale del entorno del cliente. El ámbito de cumplimiento se limita a la propia organización del cliente.

El crecimiento del volumen hace insostenible la tarificación por transacción

Un equipo de operaciones pone en marcha un proceso de tramitación de facturas de 5000 documentos al mes, lo que se ajusta perfectamente al nivel gratuito de Azure. A medida que aumenta el volumen, los costos por transacción se acumulan con cada documento procesado.IronOCR Professional ($2,999) es una compra única sin tarifas por documento. Los equipos que prevén un crecimiento del volumen, aunque sea moderado, alcanzan el umbral de rentabilidad rápidamente, tras lo cual cada documento adicional supone un ahorro.

La latencia de la red afecta a los SLA de procesamiento

Un servicio de procesamiento de documentos tiene como objetivo un SLA de extremo a extremo de 2 segundos. Visión por computadora de Azure añade entre 200 y 800 ms de latencia de red para las llamadas dentro de la misma región y entre 500 y 2000 ms para las implementaciones entre regiones, antes del cálculo del OCR propiamente dicho. Bajo carga, el límite de 10 TPS en S1 obliga a poner en cola, lo que aumenta aún más la latencia.IronOCR procesa una sola imagen de 300 ppp en 100-400 ms en hardware de servidor estándar sin colas, sin límite de velocidad y sin saltos de red. El SLA se vuelve predecible porque depende únicamente del hardware, no del estado del servicio de Azure ni de las condiciones de la red.

Requisitos de infraestructura aislada

Los contratistas de defensa, las agencias de inteligencia y los operadores de infraestructuras críticas ejecutan cargas de trabajo en redes diseñadas sin conexión a Internet. Visión por computadora de Azure es técnicamente incompatible con estos entornos: no se puede acceder al punto de conexión. Los equipos de estos sectores necesitan una biblioteca que se implemente como un binario autónomo, funcione sin ninguna conexión saliente y supere las revisiones de seguridad que prohíben explícitamente la transmisión de datos a la nube. La implementación en Linux y la compatibilidad con Docker de IronOCR permiten su implementación en entornos restringidos sin necesidad de modificaciones.

Simplificación de la implementación en múltiples entornos

Un equipo que gestiona entornos de desarrollo, staging y producción para una aplicación SaaS cuenta con tres recursos de Azure Cognitive Services, tres conjuntos de claves API y tres URL de punto final, cada uno de los cuales requiere almacenamiento seguro, políticas de rotación y configuración específica para cada entorno. Todos los entornos de implementación necesitan acceso de red saliente a Azure.IronOCR reduce la configuración por entorno a una sola variable de entorno (IRONOCR_LICENSE), elimina el requisito de acceso a la red y elimina la sobrecarga operativa de la gestión de credenciales entre entornos.

Patrón de asíncrono a síncrono

El código del consumidor de Azure es async por necesidad.IronOCR no requiere async, pero la transición es mecánica. Reemplace los tipos de devolución async Task<string> con string, quite las palabras clave await y async, y elimine el bucle de reintento. Si el método de llamada es un controlador ASP.NET o servicio que debe permanecer asincrónico, envuelva la llamada de IronOCR en Task.Run:

// Before: Azure async chain
public async Task<string> ReadTextAsync(string imagePath)
{
    using var stream = File.OpenRead(imagePath);
    var data = BinaryData.FromStream(stream);
    var result = await _client.AnalyzeAsync(data, VisualFeatures.Read);
    return string.Join("\n", result.Value.Read.Blocks
        .SelectMany(b => b.Lines)
        .Select(l => l.Text));
}

// After:IronOCR synchronous
public string ReadText(string imagePath)
{
    return new IronTesseract().Read(imagePath).Text;
}

// If async signature must be preserved for interface compatibility
public Task<string> ReadTextAsync(string imagePath)
{
    return Task.Run(() => new IronTesseract().Read(imagePath).Text);
}

// Before: Azure async chain
public async Task<string> ReadTextAsync(string imagePath)
{
    using var stream = File.OpenRead(imagePath);
    var data = BinaryData.FromStream(stream);
    var result = await _client.AnalyzeAsync(data, VisualFeatures.Read);
    return string.Join("\n", result.Value.Read.Blocks
        .SelectMany(b => b.Lines)
        .Select(l => l.Text));
}

// After:IronOCR synchronous
public string ReadText(string imagePath)
{
    return new IronTesseract().Read(imagePath).Text;
}

// If async signature must be preserved for interface compatibility
public Task<string> ReadTextAsync(string imagePath)
{
    return Task.Run(() => new IronTesseract().Read(imagePath).Text);
}

Imports System.IO
Imports System.Threading.Tasks
Imports System.Linq

' Before: Azure async chain
Public Async Function ReadTextAsync(imagePath As String) As Task(Of String)
    Using stream = File.OpenRead(imagePath)
        Dim data = BinaryData.FromStream(stream)
        Dim result = Await _client.AnalyzeAsync(data, VisualFeatures.Read)
        Return String.Join(vbLf, result.Value.Read.Blocks _
            .SelectMany(Function(b) b.Lines) _
            .Select(Function(l) l.Text))
    End Using
End Function

' After: IronOCR synchronous
Public Function ReadText(imagePath As String) As String
    Return New IronTesseract().Read(imagePath).Text
End Function

' If async signature must be preserved for interface compatibility
Public Function ReadTextAsync(imagePath As String) As Task(Of String)
    Return Task.Run(Function() New IronTesseract().Read(imagePath).Text)
End Function

Normalización de la escala de confianza

Azure Computer Vision devuelve la confianza de la palabra como un float entre 0 y 1.IronOCR devuelve la confianza como un double en una escala de 0-100. Cualquier código que utilice los valores de confianza de Azure como umbral debe ajustarse:

// Azure: confidence is 0.0 - 1.0
foreach (var word in line.Words)
{
    if (word.Confidence > 0.85f) { /* high confidence */ }
}

// IronOCR: confidence is 0 - 100
var result = new IronTesseract().Read(imagePath);
foreach (var word in result.Words)
{
    if (word.Confidence > 85.0) { /* equivalent threshold */ }
}
Console.WriteLine($"Overall: {result.Confidence}%");

// Azure: confidence is 0.0 - 1.0
foreach (var word in line.Words)
{
    if (word.Confidence > 0.85f) { /* high confidence */ }
}

// IronOCR: confidence is 0 - 100
var result = new IronTesseract().Read(imagePath);
foreach (var word in result.Words)
{
    if (word.Confidence > 85.0) { /* equivalent threshold */ }
}
Console.WriteLine($"Overall: {result.Confidence}%");

Imports IronOcr

' Azure: confidence is 0.0 - 1.0
For Each word In line.Words
    If word.Confidence > 0.85F Then
        ' high confidence
    End If
Next

' IronOCR: confidence is 0 - 100
Dim result = New IronTesseract().Read(imagePath)
For Each word In result.Words
    If word.Confidence > 85.0 Then
        ' equivalent threshold
    End If
Next
Console.WriteLine($"Overall: {result.Confidence}%")

La documentación de referencia de la API OcrResult documenta todas las propiedades de los resultados, incluida la escala de confianza. La guía práctica sobre puntuaciones de confianza abarca la selección de umbrales y la interpretación por elemento.

Consolidación del servicio de procesamiento de PDF

Azure divide el OCR de imágenes y el OCR de PDF en dos servicios independientes con clientes, paquetes NuGet y configuraciones de puntos de conexión distintos. La migración significa consolidar ambos caminos en una sola instancia de IronTesseract. El método OcrInput.LoadPdf acepta una ruta de archivo, flujo o matriz de bytes, con un parámetro Password opcional para archivos cifrados — no se requiere un segundo cliente:

// Before: Two separate Azure clients for images vs PDFs
// Image: ImageAnalysisClient + AnalyzeAsync
// PDF:   DocumentAnalysisClient + AnalyzeDocumentAsync(WaitUntil.Completed, ...)

// After: One IronTesseract instance handles both
var ocr = new IronTesseract();

// Image
var imageResult = ocr.Read("document.jpg");

// PDF (same client, same Read method)
using var pdfInput = new OcrInput();
pdfInput.LoadPdf("document.pdf");
var pdfResult = ocr.Read(pdfInput);

// Password-protected PDF
using var encInput = new OcrInput();
encInput.LoadPdf("secured.pdf", Password: "secret");
var encResult = ocr.Read(encInput);

// Salida en PDF con capacidad de búsqueda — no manual construction
pdfResult.SaveAsSearchablePdf("searchable-output.pdf");

// Before: Two separate Azure clients for images vs PDFs
// Image: ImageAnalysisClient + AnalyzeAsync
// PDF:   DocumentAnalysisClient + AnalyzeDocumentAsync(WaitUntil.Completed, ...)

// After: One IronTesseract instance handles both
var ocr = new IronTesseract();

// Image
var imageResult = ocr.Read("document.jpg");

// PDF (same client, same Read method)
using var pdfInput = new OcrInput();
pdfInput.LoadPdf("document.pdf");
var pdfResult = ocr.Read(pdfInput);

// Password-protected PDF
using var encInput = new OcrInput();
encInput.LoadPdf("secured.pdf", Password: "secret");
var encResult = ocr.Read(encInput);

// Salida en PDF con capacidad de búsqueda — no manual construction
pdfResult.SaveAsSearchablePdf("searchable-output.pdf");

Imports IronOcr

' Before: Two separate Azure clients for images vs PDFs
' Image: ImageAnalysisClient + AnalyzeAsync
' PDF:   DocumentAnalysisClient + AnalyzeDocumentAsync(WaitUntil.Completed, ...)

' After: One IronTesseract instance handles both
Dim ocr As New IronTesseract()

' Image
Dim imageResult = ocr.Read("document.jpg")

' PDF (same client, same Read method)
Using pdfInput As New OcrInput()
    pdfInput.LoadPdf("document.pdf")
    Dim pdfResult = ocr.Read(pdfInput)

    ' Salida en PDF con capacidad de búsqueda — no manual construction
    pdfResult.SaveAsSearchablePdf("searchable-output.pdf")
End Using

' Password-protected PDF
Using encInput As New OcrInput()
    encInput.LoadPdf("secured.pdf", Password:="secret")
    Dim encResult = ocr.Read(encInput)
End Using

La guía de entrada de PDF abarca la selección de rangos de páginas, la entrada de flujos y el proceso de renderización nativo de PDF. Para entradas de imágenes, consulte la guía de entrada de imágenes.

Extracción de datos estructurados sin Form Recognizer

Los equipos que usan modelos preconstruidos de Form Recognizer (facturas, recibos, documentos de identidad) para la extracción de campos necesitan replicar esa lógica de extracción en IronOCR usando OCR basado en regiones con CropRectangle. La extracción posicional es explícita en lugar de basada en modelos:

// Form Recognizer extracted named fields automatically
// IronOCR: define extraction zones for known document layouts
var ocr = new IronTesseract();

// Define regions matching the document template
var vendorZone   = new CropRectangle(0,   0,   300, 100);
var invoiceDate  = new CropRectangle(400, 0,   200, 50);
var totalAmount  = new CropRectangle(400, 500, 200, 100);

string vendor, date, total;

using (var input = new OcrInput())
{
    input.LoadImage("invoice.jpg", vendorZone);
    vendor = ocr.Read(input).Text.Trim();
}

using (var input = new OcrInput())
{
    input.LoadImage("invoice.jpg", invoiceDate);
    date = ocr.Read(input).Text.Trim();
}

using (var input = new OcrInput())
{
    input.LoadImage("invoice.jpg", totalAmount);
    total = ocr.Read(input).Text.Trim();
}

// Form Recognizer extracted named fields automatically
// IronOCR: define extraction zones for known document layouts
var ocr = new IronTesseract();

// Define regions matching the document template
var vendorZone   = new CropRectangle(0,   0,   300, 100);
var invoiceDate  = new CropRectangle(400, 0,   200, 50);
var totalAmount  = new CropRectangle(400, 500, 200, 100);

string vendor, date, total;

using (var input = new OcrInput())
{
    input.LoadImage("invoice.jpg", vendorZone);
    vendor = ocr.Read(input).Text.Trim();
}

using (var input = new OcrInput())
{
    input.LoadImage("invoice.jpg", invoiceDate);
    date = ocr.Read(input).Text.Trim();
}

using (var input = new OcrInput())
{
    input.LoadImage("invoice.jpg", totalAmount);
    total = ocr.Read(input).Text.Trim();
}

Imports IronOcr

' Form Recognizer extracted named fields automatically
' IronOCR: define extraction zones for known document layouts
Dim ocr As New IronTesseract()

' Define regions matching the document template
Dim vendorZone As New CropRectangle(0, 0, 300, 100)
Dim invoiceDate As New CropRectangle(400, 0, 200, 50)
Dim totalAmount As New CropRectangle(400, 500, 200, 100)

Dim vendor As String
Dim [date] As String
Dim total As String

Using input As New OcrInput()
    input.LoadImage("invoice.jpg", vendorZone)
    vendor = ocr.Read(input).Text.Trim()
End Using

Using input As New OcrInput()
    input.LoadImage("invoice.jpg", invoiceDate)
    [date] = ocr.Read(input).Text.Trim()
End Using

Using input As New OcrInput()
    input.LoadImage("invoice.jpg", totalAmount)
    total = ocr.Read(input).Text.Trim()
End Using

La guía OCR basada en región cubre el uso de CropRectangle en detalle. Para flujos de trabajo específicos de facturas, el tutorial OCR de facturas muestra el patrón de extracción completo.