IronOCR与 Iris OCR：工程团队应该选择哪种 OCR 解决方案？

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

// 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)

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

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

// 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
        // 否 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
        ' 否 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

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

// 否 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);
}

' 否 async required — local processing returns synchronously
Public Function ExtractText(imagePath As String) As String
    Dim result = New IronTesseract().Read(imagePath)
    Return result.Text
End Function

' One line for simple cases
Public Function OneLineOcr(imagePath As String) As String
    Return New IronTesseract().Read(imagePath).Text
End Function

' Confidence-aware extraction
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

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

// 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:IronOCRsynchronous
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 IronOcr

' 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

// 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}%")

// 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);

// 可搜索的 PDF 输出 — no manual construction
pdfResult.SaveAsSearchablePdf("searchable-output.pdf");

IRON VB CONVERTER ERROR developers@ironsoftware.com

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