IronOCR vs. Iris OCR: Welche OCR-Lösung sollten Entwicklerteams wählen?

Das asynchrone Abfragemuster

Die Asynchronitätsanforderung der Read-API hat strukturelle Konsequenzen für den Code. Die Bildanalyse mit AnalyzeAsync liefert sofort Ergebnisse, erfordert jedoch await; Die PDF-Verarbeitung über Form Recognizer erfordert WaitUntil.Completed, um zu blockieren, bis die Operation abgeschlossen ist, oder ein benutzerdefiniertes Abfragen mit UpdateStatusAsync für echtes asynchrones Verhalten. Die Ergebnishierarchie erfordert dann das Durchlaufen von Blöcken, Zeilen und Wörtern mittels verschachtelter Schleifen:

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

Die PDF-Verarbeitung erhöht die Komplexität weiter – ein separater DocumentAnalysisClient mit eigenem Endpunkt, AnalyzeDocumentAsync mit WaitUntil.Completed, und eine andere Ergebnisform unter Verwendung von result.Pages und page.Lines, die auf .Content anstelle von .Text zugreifen.

Detaillierter Funktionsvergleich

Azure-Computer-Vision-Ansatz

Azure berechnet pro Transaktion mit gestaffelten Preisen basierend auf dem Volumen. Konsultieren Sie die Azure Computer Vision Preisseite für aktuelle Tarife. Jede PDF-Seite entspricht einer Transaktion. Ein 10-seitiges PDF entspricht 10 abrechnungsfähigen Anrufen. Eine Freimenge von 5.000 Transaktionen pro Monat ist verfügbar.

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

Bei mittleren bis hohen Dokumentvolumina amortisiert sich die unbefristete Lizenz von IronOCR schnell im Vergleich zu den fortlaufenden Azure-Transaktionskosten, nach denen jedes zusätzliche Dokument Ersparnisse bedeutet.

IronOCR-Ansatz

Das Preismodell von IronOCR besteht aus einer einzigen Zahl. Installieren Sie das NuGet Paket, legen Sie den Lizenzschlüssel fest und verarbeiten Sie ein beliebiges Volumen ohne laufenden Zähler:

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

Keine Zählerablesung, keine Nutzungsverfolgung, keine Budgetwarnungen erforderlich. Vorhersehbare Kosten vom ersten Tag an. Eine vollständige Schritt-für-Schritt-Anleitung finden Sie im Tutorial "Text aus Bildern lesen" .

Azure-Computer-Vision-Ansatz

Selbst bei regionaler Endpunktauswahl und einer unterzeichneten Vereinbarung zur Auftragsverarbeitung ist der Datenfluss festgelegt:

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

Ein vom Netzwerk isoliertes Netzwerk kann die Endpunkt-URL überhaupt nicht erreichen – Azure Computer Visionverfügt über keinen Offline-Modus. Für Organisationen, die SCIFs, militärische Einrichtungen oder isolierte Verarbeitungsumgebungen betreiben, ist der Dienst unabhängig vom Preis architektonisch inkompatibel.

IronOCR-Ansatz

IronOCR verarbeitet Dokumente innerhalb des Anrufprozesses. Es besteht keine ausgehende Verbindung:

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

Durch die Docker-Bereitstellung entfallen die Anforderungen an ausgehende Netzwerkverbindungen vollständig.

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
#NeinAzure endpoint, no API key, no outbound network rules needed
ENTRYPOINT ["dotnet", "YourApp.dll"]

Für HIPAA-konforme Einrichtungen, ITAR-konforme Systeme oder FedRAMP-Air-Gap-Szenarien eliminiert IronOCR die gesamte Kategorie des Risikos durch Drittanbieter-Datenverarbeiter. Informationen zum Ausführen von IronOCR innerhalb der Azure-Infrastruktur unter Beibehaltung der Dokumente lokal auf der Compute-Instanz finden Sie im Azure-Bereitstellungsleitfaden , Informationen zur Containerkonfiguration im Docker-Bereitstellungsleitfaden .

Azure-Computer-Vision-Ansatz

Jeder Azure OCR-Aufruf erfordert await. Der Produktionscode fügt eine Wiederholungslogik für 429-Ratenbegrenzungsfehler und 5xx-Dienstfehler hinzu. Eine minimale Produktionsimplementierung sieht folgendermaßen aus:

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

Dies ist keine übertriebene Sicherheitsvorkehrung – es ist das absolute Minimum, das für jeden Azure-API-Aufruf in der Produktion erforderlich ist. Ratenbegrenzungen, Dienstausfälle und vorübergehende Fehler sind reale Zustände, mit denen jeder Azure-Nutzer konfrontiert wird.

IronOCR-Ansatz

Die lokale Verarbeitung eliminiert die Angriffsfläche des Netzwerks. Der Umfang der Fehlerbehandlung beschränkt sich auf das Dateisystem und die Eingabevalidierung:

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

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

Imports IronTesseract

Public Class OcrProcessor

    ' Neinasync 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

End Class

Kein RequestFailedException, keine erneuten Schleifen, keine Task.WhenAll-Koordination für Batch-Jobs. Wenn Sie asynchron für die Integration mit einer asynchronen Controller-Pipeline benötigen, umschließt Task.Run(() => ocr.Read(path)) den synchronen Anruf, ohne strukturelle Änderungen an der OCR-Logik selbst vorzunehmen. Die IronTesseract-API-Referenz beschreibt die vollständige synchrone Schnittstelle. Für Arbeitslasten, die tatsächlich asynchrone Muster erfordern, bietet IronOCR auch einen speziellen Leitfaden für asynchrone OCR an.

Azure-Computer-Vision-Ansatz

Die Azure-Einrichtungssequenz vor dem Schreiben von OCR-Code:

1. Erstellen Sie ein Azure-Konto, falls noch keines existiert.
2. Navigieren Sie zum Azure-Portal und erstellen Sie eine Cognitive Services-Ressource (oder eine Azure AI Services-Ressource).
3. Wählen Sie eine Preisstufe und eine Region.
4. Kopieren Sie die Endpunkt-URL (Format: https://your-resource.cognitiveservices.azure.com/).
5. Kopieren Sie einen der beiden API-Schlüssel.
6. Speichern Sie beide Werte sicher – in Umgebungsvariablen, Azure Key Vault oder appsettings.json (nur Nicht-Produktivumgebung).
7. Installieren Sie Azure.AI.Vision.ImageAnalysis über NuGet.
8. Initialisieren Sie ImageAnalysisClient mit dem Endpunkt und den Anmeldeinformationen.

Wiederholen Sie für die PDF-Verarbeitung die Schritte 2-8 für eine Form Recognizer Ressource mit einem anderen NuGet-Paket (Azure.AI.FormRecognizer) und einer anderen Client-Klasse (DocumentAnalysisClient).

Die appsettings.json speichert Endpunkt und Schlüssel:

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

Das Rotieren von API-Schlüsseln, das Verwalten des Ablaufs von Anmeldeinformationen und das Managen von Endpunkt-URLs in verschiedenen Umgebungen (Entwicklung, Staging, Produktion) sind laufende operative Aufgaben, für die es keine Entsprechung in der lokalen Verarbeitung gibt.

IronOCR-Ansatz

Die IronTesseract-Einrichtungsanleitung reduziert die Einrichtung auf zwei Schritte:

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

Der Lizenzschlüssel ist eine statische Zeichenkette. Es läuft nicht pro Anfrage ab, erfordert keine Rotation und ruft nach der Aktivierung keine Bestätigung beim Server ab. Für die Funktion der OCR-Texterkennung sind in den Bereitstellungsumgebungen keine ausgehenden Firewall-Regeln erforderlich.

Konformitätsanforderungen Block Cloud-Verarbeitung

Ein Softwareanbieter im Gesundheitswesen, der ein Dokumentenmanagementsystem entwickelt, beginnt mit Azure Computer Vision, da es sich schnell integrieren lässt. Dann kommt der erste Enterprise – ein Krankenhaussystem mit einem HIPAA-Sicherheitsbeauftragten, der zwei Fragen stellt: "Wohin gehen unsere PHI?" und "Können Sie uns die Vereinbarung zur Auftragsverarbeitung (Business Associate Agreement, BAA) für diesen Drittanbieter zeigen?" Azure hat eine BAA, aber die Antwort auf die erste Frage – "Microsoft-Rechenzentren" – löst eine langwierige Sicherheitsprüfung, eine Anfrage nach Microsoft-Prüfberichten und einen Compliance-Zeitplan aus, der den Vertrag verzögert. Der Wechsel zu IronOCR erübrigt sich vollständig. PHI verlässt niemals die Umgebung des Kunden. Der Geltungsbereich der Compliance bleibt auf die eigene Organisation des Kunden beschränkt.

Das steigende Transaktionsvolumen macht eine transaktionsbasierte Preisgestaltung unhaltbar.

Ein Betriebsteam startet eine Pipeline zur Rechnungsverarbeitung mit einer Kapazität von 5.000 Dokumenten pro Monat – und liegt damit problemlos innerhalb des kostenlosen Kontingents von Azure. Mit wachsendem Volumen summieren sich die Kosten pro Transaktion mit jedem verarbeiteten Dokument.IronOCR Professional ($2,999) ist ein einmaliger Kauf ohne Gebühren pro Dokument. Teams, die auch nur ein moderates Mengenwachstum erwarten, erreichen schnell die Gewinnschwelle, danach bedeutet jedes zusätzliche Dokument Einsparungen.

Netzwerklatenz beeinflusst die Verarbeitungs-SLAs

Ein Dokumentenverarbeitungsdienst strebt eine durchgängige Service-Level-Vereinbarung (SLA) von 2 Sekunden an. Azure Computer Visionfügt bei Anrufen innerhalb derselben Region eine Netzwerklatenz von 200-800 ms und bei regionsübergreifenden Bereitstellungen eine Latenz von 500-2000 ms hinzu – noch vor der eigentlichen OCR-Berechnung. Unter Last führt die Begrenzung der Transaktionsrate auf S1 auf 10 TPS zu einer Warteschlangenbildung, was die Latenz weiter erhöht.IronOCR verarbeitet ein einzelnes 300-DPI-Bild in 100–400 ms auf Standardserverhardware ohne Warteschlange, ohne Datenratenbegrenzung und ohne Netzwerk-Hops. Die Service-Level-Vereinbarung (SLA) ist vorhersehbar, da sie ausschließlich von der Hardware und nicht vom Zustand des Azure-Dienstes oder den Netzwerkbedingungen abhängt.

Anforderungen an eine Air-Gapped-Infrastruktur

Rüstungsunternehmen, Geheimdienste und Betreiber kritischer Infrastrukturen führen ihre Arbeitslasten standardmäßig in Netzwerken ohne Internetanbindung aus. Azure Computer Visionist technisch nicht mit diesen Umgebungen kompatibel – der Endpunkt kann nicht erreicht werden. Teams in diesen Sektoren benötigen eine Bibliothek, die als eigenständige Binärdatei bereitgestellt werden kann, ohne ausgehende Verbindung funktioniert und Sicherheitsprüfungen besteht, die die Übertragung von Cloud-Daten ausdrücklich verbieten. Dank der Linux-Bereitstellungs- und Docker-Unterstützung kann IronOCR ohne Modifikationen auch in eingeschränkten Umgebungen eingesetzt werden.

Vereinfachung der Bereitstellung in mehreren Umgebungen

Ein Team, das Entwicklungs-, Staging- und Produktionsumgebungen für eine SaaS-Anwendung verwaltet, verwendet drei Azure Cognitive Services-Ressourcen, drei Sätze von API-Schlüsseln und drei Endpunkt-URLs – jede erfordert sicheren Speicher, Rotationsrichtlinien und umgebungsspezifische Konfiguration. Jede Bereitstellungsumgebung benötigt ausgehenden Netzwerkzugriff auf Azure.IronOCR reduziert die pro-Umgebung Konfiguration auf eine Umgebungsvariable (IRONOCR_LICENSE), beseitigt die Anforderung des Netzwerkzugriffs und entfernt den betrieblichen Aufwand der Anmeldedatenverwaltung über Umgebungen hinweg.

Asynchrones zu synchronem Muster

Der Azure-Verbrauchscode ist async aus Notwendigkeit.IronOCR benötigt keine asynchrone Verarbeitung, der Übergang erfolgt jedoch mechanisch. Ersetzen Sie async Task<string>-Rückgabetypen durch string, entfernen Sie die await- und async-Schlüsselwörter und löschen Sie die Wiederholungsschleife. Wenn die aufrufende Methode ein ASP.NET Controller oder Dienst ist, der asynchron bleiben muss, umschließen Sie den IronOCR-Aufruf in 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

Normalisierung der Konfidenzskala

Azure Computer Vision gibt das Vertrauensniveau von Wörtern als float zwischen 0 und 1 zurück.IronOCR gibt das Vertrauensniveau als double auf einer Skala von 0-100 zurück. Jeglicher Code, der Schwellenwerte für Azure-Konfidenzwerte festlegt, muss angepasst werden:

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

Die OcrResult-API-Referenzdokumentation umfasst alle Ergebniseigenschaften einschließlich der Konfidenzskala. Die Anleitung zur Berechnung von Konfidenzwerten umfasst die Auswahl von Schwellenwerten und die Interpretation der einzelnen Elemente.

Konsolidierung von PDF-Verarbeitungsdiensten

Azure trennt die Bild-OCR und die PDF-OCR auf zwei separate Dienste mit separaten Clients, NuGet -Paketen und Endpunktkonfigurationen auf. Migration bedeutet, beide Wege in eine einzelne IronTesseract-Instanz zu konsolidieren. Die OcrInput.LoadPdf-Methode akzeptiert einen Dateipfad, einen Stream oder ein Byte-Array mit einem optionalen Password-Parameter für verschlüsselte Dateien – kein zweiter Client erforderlich:

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

// Durchsuchbare PDF-Ausgabe — 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);

// Durchsuchbare PDF-Ausgabe — 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)

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

    ' Durchsuchbare PDF-Ausgabe — no manual construction
    pdfResult.SaveAsSearchablePdf("searchable-output.pdf")
End Using

Die PDF-Eingabeanleitung behandelt die Auswahl von Seitenbereichen, die Stream-Eingabe und die native PDF-Rendering-Pipeline. Informationen zur Bildeingabe finden Sie in der Bildeingabeanleitung .

Strukturierte Datenextraktion ohne Formularerkennung

Teams, die Form Recognizers vorgefertigte Modelle (Rechnungen, Quittungen, Ausweisdokumente) zur Felderfassung verwenden, müssen diese Extraktionslogik in IronOCR mithilfe von regionsbasiertem OCR mit CropRectangle nachbilden. Die Positionsbestimmung erfolgt explizit und nicht modellbasiert:

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

Der regionsbasierte OCR-Leitfaden behandelt die Nutzung von CropRectangle im Detail. Für Workflows, die speziell auf Rechnungen zugeschnitten sind, demonstriert das Tutorial zur Rechnungs-OCR das vollständige Extraktionsmuster.