Das Per-Page-Preismodell von AWS Textractkann bei niedrigem Volumen kostengünstig wirken, aber die Kosten summieren sich unbegrenzt im großen Maßstab. Jedes Dokument, das Ihre Anwendung bearbeitet, verlässt Ihr Netzwerk, reist zu einem Amazon-Datenzentrum, wird von der Amazon-Infrastruktur verarbeitet und die Rechnung summiert sich unbegrenzt. Für Teams, die OCR-Optionen in .NET evaluieren, stellt sich nicht nur die Frage, ob Textract genaue Ergebnisse liefert – was es tut –, sondern auch, ob das Seitenkostenmodell, die obligatorische Cloud-Übertragung und die asynchrone Abfragearchitektur für mehrseitige Dokumente den tatsächlichen Anforderungen Ihrer Anwendung entsprechen.

AWS Textractverstehen

AWS Textract ist Amazons verwalteter Dokumentenanalyse-Dienst, zugänglich über das AWS SDK for .NET durch das AWSSDK.Textract NuGet-Paket. Es funktioniert als Cloud-API: Ihre Anwendung sendet Dokumentdaten an die Infrastruktur von Amazon und erhält strukturierte Ergebnisse. Für den Dienst sind ein AWS-Konto, IAM-Anmeldedaten mit Textract-Berechtigungen sowie eine Internetverbindung für jeden einzelnen OCR-Vorgang erforderlich.

Textract bietet mehrere unterschiedliche Analysemodi an, die jeweils separat berechnet werden:

• DetectDocumentText: Grundlegende Textextraktion (siehe AWS Textract Preisgestaltung für aktuelle Per-Page-Konditionen)
• AnalyzeDocument (Tables): Strukturiertes Tabellenauszug zu einem höheren Per-Page-Preis als bei der grundlegenden Texterkennung
• AnalyzeDocument (Forms): Schlüssel-Wert-Formularauszug zu einem höheren Per-Seiten Preis als bei Tabellenauszug
• AnalyzeExpense: Analyse von Rechnungen und Belegen für 0,01 $ pro Seite
• AnalyzeID: Extraktion von Ausweisdaten für 0,025 $ pro Seite
• StartDocumentTextDetection / StartDocumentAnalysis: Asynchrone API, die für jede mehrseitige PDF-Datei erforderlich ist und einen S3-Staging-Bucket, Job-Abfrage sowie eine Paginierung der Ergebnisse voraussetzt

Das Ergebnismodell verwendet eine flache Liste von Block Objekten mit Beziehungs-IDs, die durchlaufen werden müssen, um Tabellen, Formulare oder jegliche strukturierte Ausgabe zu rekonstruieren. Eine einfache Tabellenextraktion erfordert das Iterieren von BlockType.TABLE Blöcken, das Finden von Kinder-BlockType.CELL Blöcken über RelationshipType.CHILD Beziehungs-IDs und das Abrufen von BlockType.WORD Blöcken für den Text jeder Zelle. Dieses Beziehungsgraphenmodell verarbeitet komplexe Dokumentstrukturen, ist jedoch nicht besonders ressourcenschonend.

Die S3-Async-Pipeline

Einzelbild-OCR über DetectDocumentTextAsync kann Dokumentbytes direkt in der Anfrage übergeben. Mehrseitige PDFs können dies nicht. Jedes PDF erfordert die vollständige asynchrone Pipeline:

// AWS Textract: Mehrseitiges PDF requires S3 + async job
public async Task<string> ProcessPdfAsync(string pdfPath)
{
    // Step 1: Upload to S3 — credentials for two services required
    var key = $"uploads/{Guid.NewGuid()}.pdf";
    using (var fileStream = File.OpenRead(pdfPath))
    {
        await _s3Client.PutObjectAsync(new PutObjectRequest
        {
            BucketName = _bucketName,
            Key = key,
            InputStream = fileStream
        });
    }

    try
    {
        // Step 2: Start async Textract job
        var startResponse = await _textractClient.StartDocumentTextDetectionAsync(
            new StartDocumentTextDetectionRequest
            {
                DocumentLocation = new DocumentLocation
                {
                    S3Object = new S3Object { Bucket = _bucketName, Name = key }
                }
            });

        var jobId = startResponse.JobId;

        // Step 3: Poll every 5 seconds until complete
        GetDocumentTextDetectionResponse getResponse;
        do
        {
            await Task.Delay(5000);
            getResponse = await _textractClient.GetDocumentTextDetectionAsync(
                new GetDocumentTextDetectionRequest { JobId = jobId });
        } while (getResponse.JobStatus == JobStatus.IN_PROGRESS);

        if (getResponse.JobStatus != JobStatus.SUCCEEDED)
            throw new Exception($"Textract job failed: {getResponse.StatusMessage}");

        // Step 4: Paginate through result blocks
        var allText = new StringBuilder();
        string nextToken = null;
        do
        {
            var pageResponse = await _textractClient.GetDocumentTextDetectionAsync(
                new GetDocumentTextDetectionRequest
                {
                    JobId = jobId,
                    NextToken = nextToken
                });

            foreach (var block in pageResponse.Blocks.Where(b => b.BlockType == BlockType.LINE))
                allText.AppendLine(block.Text);

            nextToken = pageResponse.NextToken;
        } while (nextToken != null);

        return allText.ToString();
    }
    finally
    {
        // Step 5: Stets clean up S3
        await _s3Client.DeleteObjectAsync(_bucketName, key);
    }
}

// AWS Textract: Mehrseitiges PDF requires S3 + async job
public async Task<string> ProcessPdfAsync(string pdfPath)
{
    // Step 1: Upload to S3 — credentials for two services required
    var key = $"uploads/{Guid.NewGuid()}.pdf";
    using (var fileStream = File.OpenRead(pdfPath))
    {
        await _s3Client.PutObjectAsync(new PutObjectRequest
        {
            BucketName = _bucketName,
            Key = key,
            InputStream = fileStream
        });
    }

    try
    {
        // Step 2: Start async Textract job
        var startResponse = await _textractClient.StartDocumentTextDetectionAsync(
            new StartDocumentTextDetectionRequest
            {
                DocumentLocation = new DocumentLocation
                {
                    S3Object = new S3Object { Bucket = _bucketName, Name = key }
                }
            });

        var jobId = startResponse.JobId;

        // Step 3: Poll every 5 seconds until complete
        GetDocumentTextDetectionResponse getResponse;
        do
        {
            await Task.Delay(5000);
            getResponse = await _textractClient.GetDocumentTextDetectionAsync(
                new GetDocumentTextDetectionRequest { JobId = jobId });
        } while (getResponse.JobStatus == JobStatus.IN_PROGRESS);

        if (getResponse.JobStatus != JobStatus.SUCCEEDED)
            throw new Exception($"Textract job failed: {getResponse.StatusMessage}");

        // Step 4: Paginate through result blocks
        var allText = new StringBuilder();
        string nextToken = null;
        do
        {
            var pageResponse = await _textractClient.GetDocumentTextDetectionAsync(
                new GetDocumentTextDetectionRequest
                {
                    JobId = jobId,
                    NextToken = nextToken
                });

            foreach (var block in pageResponse.Blocks.Where(b => b.BlockType == BlockType.LINE))
                allText.AppendLine(block.Text);

            nextToken = pageResponse.NextToken;
        } while (nextToken != null);

        return allText.ToString();
    }
    finally
    {
        // Step 5: Stets clean up S3
        await _s3Client.DeleteObjectAsync(_bucketName, key);
    }
}

Dies ist die minimale funktionsfähige Implementierung für eine zuverlässige PDF-Verarbeitung — fünf verschiedene Phasen, zwei AWS Dienst-Clients und Aufräumlogik in einem finally Block. Die vollständige Produktionsversion mit korrekter Fehlerbehandlung, Logik für Wiederholungsversuche bei Ratenbegrenzung und Zeitüberschreitungsmanagement umfasst 150–300 Zeilen.

##IronOCR verstehen

IronOCR ist eine kommerzielle .NET-OCR-Bibliothek, die vollständig auf Ihrer Infrastruktur läuft. Sie umfasst eine optimierte Tesseract 5-Engine mit automatischer Bildvorverarbeitung, nativer PDF-Unterstützung und einer synchronen API, die Ergebnisse direkt ohne externe Dienstaufrufe oder Zwischenschritte liefert.

Wichtige Merkmale der IronOCR-Architektur:

• Nur lokale Verarbeitung: Es verlassen keine Dokumentdaten den Rechner, auf dem Ihre Anwendung läuft
• Einzelnes NuGet-Paket: dotnet add package IronOcr installiert alles, einschließlich nativer Binärdateien
• Automatische Vorverarbeitung: Entzerrung, Rauschunterdrückung, Kontrastverbesserung, Binarisierung und Auflösungsskalierung erfolgen automatisch bei Eingaben von schlechter Qualität
• Native PDF-Unterstützung: Liest PDFs direkt über Dateipfad oder Stream ohne S3-Staging oder asynchrone Jobs
• Thread-sicher: Eine einzelne IronTesseract Instanz behandelt gleichzeitige Anfragen über Threads ohne Konflikt
• Unbefristete Lizenzierung: $999 Lite / $1,499 Plus / $2,399 Professional / $4,799 Unlimited — eine Zahlung, keine Gebühren pro Seite, keine Nutzungsmessung
• Über 125 Sprachpakete: Als separate NuGet-Pakete installiert, lokal geladen, keine Netzwerkaufrufe

Funktionsvergleich

Detaillierter Funktionsvergleich

Kosten im Maßstab

Das Preismodell pro Seite ist die bestimmende strukturelle Einschränkung von AWS Textract. Kosten, die pro Seite klein erscheinen, summieren sich erheblich im Rahmen eines realen Dokumentenablaufs.

AWS Textract-Ansatz

// Every call to this method costs money — per page, permanently
public async Task<string> DetectTextAsync(string imagePath)
{
    var imageBytes = File.ReadAllBytes(imagePath);  // Image leaves your network

    var request = new DetectDocumentTextRequest
    {
        Document = new Document
        {
            Bytes = new MemoryStream(imageBytes)
        }
    };

    var response = await _client.DetectDocumentTextAsync(request);  // per-page charge

    return string.Join("\n", response.Blocks
        .Where(b => b.BlockType == BlockType.LINE)
        .Select(b => b.Text));
}

// Every call to this method costs money — per page, permanently
public async Task<string> DetectTextAsync(string imagePath)
{
    var imageBytes = File.ReadAllBytes(imagePath);  // Image leaves your network

    var request = new DetectDocumentTextRequest
    {
        Document = new Document
        {
            Bytes = new MemoryStream(imageBytes)
        }
    };

    var response = await _client.DetectDocumentTextAsync(request);  // per-page charge

    return string.Join("\n", response.Blocks
        .Where(b => b.BlockType == BlockType.LINE)
        .Select(b => b.Text));
}

Imports System.IO
Imports System.Threading.Tasks

' Every call to this method costs money — per page, permanently
Public Async Function DetectTextAsync(imagePath As String) As Task(Of String)
    Dim imageBytes = File.ReadAllBytes(imagePath)  ' Image leaves your network

    Dim request = New DetectDocumentTextRequest With {
        .Document = New Document With {
            .Bytes = New MemoryStream(imageBytes)
        }
    }

    Dim response = Await _client.DetectDocumentTextAsync(request)  ' per-page charge

    Return String.Join(vbLf, response.Blocks _
        .Where(Function(b) b.BlockType = BlockType.LINE) _
        .Select(Function(b) b.Text))
End Function

Imports System.IO
Imports System.Threading.Tasks

' Every call to this method costs money — per page, permanently
Public Async Function DetectTextAsync(imagePath As String) As Task(Of String)
    Dim imageBytes = File.ReadAllBytes(imagePath)  ' Image leaves your network

    Dim request = New DetectDocumentTextRequest With {
        .Document = New Document With {
            .Bytes = New MemoryStream(imageBytes)
        }
    }

    Dim response = Await _client.DetectDocumentTextAsync(request)  ' per-page charge

    Return String.Join(vbLf, response.Blocks _
        .Where(Function(b) b.BlockType = BlockType.LINE) _
        .Select(Function(b) b.Text))
End Function

Konsultieren Sie die AWS Textract Preisgestaltungsseite für aktuelle Per-Seiten-Tarife. Unterschiedliche API-Features (grundlegende Textdetektion, Tabellenauszug, Formularauszug) haben unterschiedliche Tarife. Ein Dokument, das Tabellen und Formularfelder enthält, zieht höhere Gebühren als die Grundtextdetektion nach sich, und Kosten wachsen mit dem Volumen ohne Obergrenze und ohne Möglichkeit, im Voraus zu zahlen.

Bei hohem Seitenvolumen können die Gesamtkosten über drei Jahre erheblich sein, und das Zählen läuft weiter.

IronOCR-Ansatz

// One license.Neinper-page cost. Same code handles 1 page or 1,000,000.
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

var text = new IronTesseract().Read("document.jpg").Text;

// One license.Neinper-page cost. Same code handles 1 page or 1,000,000.
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

var text = new IronTesseract().Read("document.jpg").Text;

Die $2,399 Professional-Lizenz deckt 10 Entwickler, unbegrenzte Projekte und unbegrenztes Seitenvolumen ab. Nach dem ersten Jahr fallen keine weiteren Kosten mehr für die Verarbeitung der Seiten an. Für Teams, die erhebliche Seitenvolumina bearbeiten, zahlt sich die IronOCR-Lizenz schnell im Vergleich zu fortlaufenden Cloud-Kosten pro Seite aus.

Die IronOCR -Lizenzseite enthält Informationen zu den Lizenzstufen, SaaS-Abonnementoptionen für nutzungsbasierte Abrechnungsszenarien und OEM-Weitervertriebsbedingungen.

Datensouveränität und Compliance

Die Architektur von AWS Textractmacht eine Garantie unmöglich: dass Ihre Dokumente innerhalb Ihrer Infrastruktur bleiben. Bei jedem OCR-Vorgang werden Dokumentinhalte an die Server von Amazon übertragen.

AWS Textract-Ansatz

// This code sends PHI, legal documents, financial records — whatever is in
// the file — to Amazon Web Services infrastructure
public async Task<string> ProcessSensitiveDocumentAsync(string documentPath)
{
    var imageBytes = File.ReadAllBytes(documentPath);

    // Data crosses your security perimeter here
    var request = new DetectDocumentTextRequest
    {
        Document = new Document
        {
            Bytes = new MemoryStream(imageBytes)
        }
    };

    // Amazon processes it; you receive text back
    var response = await _client.DetectDocumentTextAsync(request);

    return string.Join("\n", response.Blocks
        .Where(b => b.BlockType == BlockType.LINE)
        .Select(b => b.Text));
}

// This code sends PHI, legal documents, financial records — whatever is in
// the file — to Amazon Web Services infrastructure
public async Task<string> ProcessSensitiveDocumentAsync(string documentPath)
{
    var imageBytes = File.ReadAllBytes(documentPath);

    // Data crosses your security perimeter here
    var request = new DetectDocumentTextRequest
    {
        Document = new Document
        {
            Bytes = new MemoryStream(imageBytes)
        }
    };

    // Amazon processes it; you receive text back
    var response = await _client.DetectDocumentTextAsync(request);

    return string.Join("\n", response.Blocks
        .Where(b => b.BlockType == BlockType.LINE)
        .Select(b => b.Text));
}

Imports System.IO
Imports System.Threading.Tasks
Imports Amazon.Textract
Imports Amazon.Textract.Model

Public Class DocumentProcessor
    Private _client As AmazonTextractClient

    Public Sub New(client As AmazonTextractClient)
        _client = client
    End Sub

    ' This code sends PHI, legal documents, financial records — whatever is in
    ' the file — to Amazon Web Services infrastructure
    Public Async Function ProcessSensitiveDocumentAsync(documentPath As String) As Task(Of String)
        Dim imageBytes = File.ReadAllBytes(documentPath)

        ' Data crosses your security perimeter here
        Dim request As New DetectDocumentTextRequest With {
            .Document = New Document With {
                .Bytes = New MemoryStream(imageBytes)
            }
        }

        ' Amazon processes it; you receive text back
        Dim response = Await _client.DetectDocumentTextAsync(request)

        Return String.Join(vbLf, response.Blocks _
            .Where(Function(b) b.BlockType = BlockType.LINE) _
            .Select(Function(b) b.Text))
    End Function
End Class

Imports System.IO
Imports System.Threading.Tasks
Imports Amazon.Textract
Imports Amazon.Textract.Model

Public Class DocumentProcessor
    Private _client As AmazonTextractClient

    Public Sub New(client As AmazonTextractClient)
        _client = client
    End Sub

    ' This code sends PHI, legal documents, financial records — whatever is in
    ' the file — to Amazon Web Services infrastructure
    Public Async Function ProcessSensitiveDocumentAsync(documentPath As String) As Task(Of String)
        Dim imageBytes = File.ReadAllBytes(documentPath)

        ' Data crosses your security perimeter here
        Dim request As New DetectDocumentTextRequest With {
            .Document = New Document With {
                .Bytes = New MemoryStream(imageBytes)
            }
        }

        ' Amazon processes it; you receive text back
        Dim response = Await _client.DetectDocumentTextAsync(request)

        Return String.Join(vbLf, response.Blocks _
            .Where(Function(b) b.BlockType = BlockType.LINE) _
            .Select(Function(b) b.Text))
    End Function
End Class

AWS bietet eine HIPAA-Geschäftspartnervereinbarung für betroffene Einrichtungen an, und GovCloud-Regionen bieten eine FedRAMP High-Autorisierung. Diese Frameworks ändern nichts an der grundlegenden Architektur: Dokumente verlassen bei jeder Operation Ihre Infrastruktur. Bei ITAR-kontrollierten technischen Daten handelt es sich nicht um eine Frage der Compliance, sondern um ein Verbot. Für CMMC Level 3-Workloads mit CUI erfordert die Cloud-Übertragung spezielle Autorisierungen, über die die meisten Rüstungsunternehmen nicht verfügen. Für luftabgeschottete Systeme – Forschungsnetzwerke, industrielle Kontrollumgebungen, klassifizierte Einrichtungen – ist Textract schlichtweg nicht verfügbar.

AWS Textract ist in sechs Regionen verfügbar: us-east-1, us-west-2, eu-west-1, eu-west-2, ap-southeast-1 und ap-southeast-2. Organisationen, deren Datenspeicherungsanforderungen außerhalb dieser Regionen liegen, haben keine konforme Option.

IronOCR-Ansatz

// IronOCR: document bytes never leave this process
public string ProcessSensitiveDocument(string documentPath)
{
    // Processes entirely on local hardware — no network call
    var ocr = new IronTesseract();
    return ocr.Read(documentPath).Text;
}

// IronOCR: document bytes never leave this process
public string ProcessSensitiveDocument(string documentPath)
{
    // Processes entirely on local hardware — no network call
    var ocr = new IronTesseract();
    return ocr.Read(documentPath).Text;
}

' IronOCR: document bytes never leave this process
Public Function ProcessSensitiveDocument(documentPath As String) As String
    ' Processes entirely on local hardware — no network call
    Dim ocr As New IronTesseract()
    Return ocr.Read(documentPath).Text
End Function

' IronOCR: document bytes never leave this process
Public Function ProcessSensitiveDocument(documentPath As String) As String
    ' Processes entirely on local hardware — no network call
    Dim ocr As New IronTesseract()
    Return ocr.Read(documentPath).Text
End Function

Da IronOCR lokal ausgeführt wird, fügt es sich nahtlos in Arbeitsabläufe im Gesundheitswesen ein, die PHI verarbeiten, in Rechtsdokumentensysteme, die vertrauliche Kommunikation handhaben, in Finanzanwendungen, die Zahlungskartenbilder verarbeiten, und in die Pipelines von Verteidigungsunternehmen, die CUI verarbeiten. Es gibt keinen externen Prozessor, der geprüft werden müsste, keine BAA, die ausgehandelt werden müsste, und keine Datenresidenzbeschränkungen, die erfüllt werden müssten. Der Geltungsbereich der Compliance bezieht sich auf die Infrastruktur Ihres Unternehmens.

Für Teams, die auf AWS-Infrastruktur arbeiten, aber eine lokale Verarbeitung benötigen, läuft IronOCRauf AWS EC2 und Lambda ohne Abhängigkeit von Textract – die Verarbeitung findet innerhalb der Grenzen Ihres eigenen AWS-Kontos statt und nicht im verwalteten Dienst von Amazon.

Asynchrones Polling vs. synchrone Verarbeitung

Die architektonische Trennung zwischen den synchronen (Einzelbild) und asynchronen (mehrseitigen PDF) APIs von Textract ist kein unbedeutendes API-Detail. Es prägt die Art und Weise, wie Dienste entwickelt werden, wie mit Fehlern umgegangen wird und wie viel Code die Wartungsfachleute lesen und analysieren müssen.

AWS Textract-Ansatz

// Full production-grade async processor for Textract PDF handling
public class TextractAsyncProcessor
{
    private readonly AmazonTextractClient _textractClient;
    private readonly AmazonS3Client _s3Client;
    private readonly string _bucketName;
    private readonly TimeSpan _pollInterval = TimeSpan.FromSeconds(5);
    private readonly TimeSpan _maxWaitTime = TimeSpan.FromMinutes(10);

    public async Task<DocumentResult> ProcessDocumentAsync(
        string localFilePath,
        CancellationToken cancellationToken = default)
    {
        var s3Key = $"textract-uploads/{Guid.NewGuid()}{Path.GetExtension(localFilePath)}";

        try
        {
            // Phase 1: Upload to S3
            await UploadToS3Async(localFilePath, s3Key, cancellationToken);

            // Phase 2: Start Textract job
            var jobId = await StartTextractJobAsync(s3Key, cancellationToken);

            // Phase 3: Poll until complete (up to 10 minutes)
            var pollResult = await PollForCompletionAsync(jobId, cancellationToken);

            if (!pollResult.Success)
                throw new Exception($"Textract job failed: {pollResult.ErrorMessage}");

            // Phase 4: Retrieve paginated results
            return await GetAllResultsAsync(jobId, cancellationToken);
        }
        finally
        {
            // Phase 5: S3 cleanup — must succeed or storage costs accumulate
            await DeleteFromS3Async(s3Key, cancellationToken);
        }
    }

    private async Task<(bool Success, string ErrorMessage)> PollForCompletionAsync(
        string jobId, CancellationToken cancellationToken)
    {
        var startTime = DateTime.UtcNow;
        int pollCount = 0;

        while (DateTime.UtcNow - startTime < _maxWaitTime)
        {
            cancellationToken.ThrowIfCancellationRequested();

            var response = await _textractClient.GetDocumentTextDetectionAsync(
                new GetDocumentTextDetectionRequest { JobId = jobId }, cancellationToken);

            pollCount++;

            switch (response.JobStatus)
            {
                case JobStatus.SUCCEEDED: return (true, null);
                case JobStatus.FAILED: return (false, response.StatusMessage ?? "Unknown error");
                case JobStatus.IN_PROGRESS:
                    await Task.Delay(_pollInterval, cancellationToken);
                    break;
                default:
                    throw new Exception($"Unknown job status: {response.JobStatus}");
            }
        }

        return (false, "Job timed out");
    }
}

// Full production-grade async processor for Textract PDF handling
public class TextractAsyncProcessor
{
    private readonly AmazonTextractClient _textractClient;
    private readonly AmazonS3Client _s3Client;
    private readonly string _bucketName;
    private readonly TimeSpan _pollInterval = TimeSpan.FromSeconds(5);
    private readonly TimeSpan _maxWaitTime = TimeSpan.FromMinutes(10);

    public async Task<DocumentResult> ProcessDocumentAsync(
        string localFilePath,
        CancellationToken cancellationToken = default)
    {
        var s3Key = $"textract-uploads/{Guid.NewGuid()}{Path.GetExtension(localFilePath)}";

        try
        {
            // Phase 1: Upload to S3
            await UploadToS3Async(localFilePath, s3Key, cancellationToken);

            // Phase 2: Start Textract job
            var jobId = await StartTextractJobAsync(s3Key, cancellationToken);

            // Phase 3: Poll until complete (up to 10 minutes)
            var pollResult = await PollForCompletionAsync(jobId, cancellationToken);

            if (!pollResult.Success)
                throw new Exception($"Textract job failed: {pollResult.ErrorMessage}");

            // Phase 4: Retrieve paginated results
            return await GetAllResultsAsync(jobId, cancellationToken);
        }
        finally
        {
            // Phase 5: S3 cleanup — must succeed or storage costs accumulate
            await DeleteFromS3Async(s3Key, cancellationToken);
        }
    }

    private async Task<(bool Success, string ErrorMessage)> PollForCompletionAsync(
        string jobId, CancellationToken cancellationToken)
    {
        var startTime = DateTime.UtcNow;
        int pollCount = 0;

        while (DateTime.UtcNow - startTime < _maxWaitTime)
        {
            cancellationToken.ThrowIfCancellationRequested();

            var response = await _textractClient.GetDocumentTextDetectionAsync(
                new GetDocumentTextDetectionRequest { JobId = jobId }, cancellationToken);

            pollCount++;

            switch (response.JobStatus)
            {
                case JobStatus.SUCCEEDED: return (true, null);
                case JobStatus.FAILED: return (false, response.StatusMessage ?? "Unknown error");
                case JobStatus.IN_PROGRESS:
                    await Task.Delay(_pollInterval, cancellationToken);
                    break;
                default:
                    throw new Exception($"Unknown job status: {response.JobStatus}");
            }
        }

        return (false, "Job timed out");
    }
}

Imports System
Imports System.IO
Imports System.Threading
Imports System.Threading.Tasks
Imports Amazon.Textract
Imports Amazon.S3
Imports Amazon.Textract.Model

' Full production-grade async processor for Textract PDF handling
Public Class TextractAsyncProcessor
    Private ReadOnly _textractClient As AmazonTextractClient
    Private ReadOnly _s3Client As AmazonS3Client
    Private ReadOnly _bucketName As String
    Private ReadOnly _pollInterval As TimeSpan = TimeSpan.FromSeconds(5)
    Private ReadOnly _maxWaitTime As TimeSpan = TimeSpan.FromMinutes(10)

    Public Async Function ProcessDocumentAsync(localFilePath As String, Optional cancellationToken As CancellationToken = Nothing) As Task(Of DocumentResult)
        Dim s3Key = $"textract-uploads/{Guid.NewGuid()}{Path.GetExtension(localFilePath)}"

        Try
            ' Phase 1: Upload to S3
            Await UploadToS3Async(localFilePath, s3Key, cancellationToken)

            ' Phase 2: Start Textract job
            Dim jobId = Await StartTextractJobAsync(s3Key, cancellationToken)

            ' Phase 3: Poll until complete (up to 10 minutes)
            Dim pollResult = Await PollForCompletionAsync(jobId, cancellationToken)

            If Not pollResult.Success Then
                Throw New Exception($"Textract job failed: {pollResult.ErrorMessage}")
            End If

            ' Phase 4: Retrieve paginated results
            Return Await GetAllResultsAsync(jobId, cancellationToken)
        Finally
            ' Phase 5: S3 cleanup — must succeed or storage costs accumulate
            Await DeleteFromS3Async(s3Key, cancellationToken)
        End Try
    End Function

    Private Async Function PollForCompletionAsync(jobId As String, cancellationToken As CancellationToken) As Task(Of (Success As Boolean, ErrorMessage As String))
        Dim startTime = DateTime.UtcNow
        Dim pollCount As Integer = 0

        While DateTime.UtcNow - startTime < _maxWaitTime
            cancellationToken.ThrowIfCancellationRequested()

            Dim response = Await _textractClient.GetDocumentTextDetectionAsync(New GetDocumentTextDetectionRequest With {.JobId = jobId}, cancellationToken)

            pollCount += 1

            Select Case response.JobStatus
                Case JobStatus.SUCCEEDED
                    Return (True, Nothing)
                Case JobStatus.FAILED
                    Return (False, If(response.StatusMessage, "Unknown error"))
                Case JobStatus.IN_PROGRESS
                    Await Task.Delay(_pollInterval, cancellationToken)
                Case Else
                    Throw New Exception($"Unknown job status: {response.JobStatus}")
            End Select
        End While

        Return (False, "Job timed out")
    End Function
End Class

Imports System
Imports System.IO
Imports System.Threading
Imports System.Threading.Tasks
Imports Amazon.Textract
Imports Amazon.S3
Imports Amazon.Textract.Model

' Full production-grade async processor for Textract PDF handling
Public Class TextractAsyncProcessor
    Private ReadOnly _textractClient As AmazonTextractClient
    Private ReadOnly _s3Client As AmazonS3Client
    Private ReadOnly _bucketName As String
    Private ReadOnly _pollInterval As TimeSpan = TimeSpan.FromSeconds(5)
    Private ReadOnly _maxWaitTime As TimeSpan = TimeSpan.FromMinutes(10)

    Public Async Function ProcessDocumentAsync(localFilePath As String, Optional cancellationToken As CancellationToken = Nothing) As Task(Of DocumentResult)
        Dim s3Key = $"textract-uploads/{Guid.NewGuid()}{Path.GetExtension(localFilePath)}"

        Try
            ' Phase 1: Upload to S3
            Await UploadToS3Async(localFilePath, s3Key, cancellationToken)

            ' Phase 2: Start Textract job
            Dim jobId = Await StartTextractJobAsync(s3Key, cancellationToken)

            ' Phase 3: Poll until complete (up to 10 minutes)
            Dim pollResult = Await PollForCompletionAsync(jobId, cancellationToken)

            If Not pollResult.Success Then
                Throw New Exception($"Textract job failed: {pollResult.ErrorMessage}")
            End If

            ' Phase 4: Retrieve paginated results
            Return Await GetAllResultsAsync(jobId, cancellationToken)
        Finally
            ' Phase 5: S3 cleanup — must succeed or storage costs accumulate
            Await DeleteFromS3Async(s3Key, cancellationToken)
        End Try
    End Function

    Private Async Function PollForCompletionAsync(jobId As String, cancellationToken As CancellationToken) As Task(Of (Success As Boolean, ErrorMessage As String))
        Dim startTime = DateTime.UtcNow
        Dim pollCount As Integer = 0

        While DateTime.UtcNow - startTime < _maxWaitTime
            cancellationToken.ThrowIfCancellationRequested()

            Dim response = Await _textractClient.GetDocumentTextDetectionAsync(New GetDocumentTextDetectionRequest With {.JobId = jobId}, cancellationToken)

            pollCount += 1

            Select Case response.JobStatus
                Case JobStatus.SUCCEEDED
                    Return (True, Nothing)
                Case JobStatus.FAILED
                    Return (False, If(response.StatusMessage, "Unknown error"))
                Case JobStatus.IN_PROGRESS
                    Await Task.Delay(_pollInterval, cancellationToken)
                Case Else
                    Throw New Exception($"Unknown job status: {response.JobStatus}")
            End Select
        End While

        Return (False, "Job timed out")
    End Function
End Class

Dies ist kein Standardtext, der einmal erstellt und dann vergessen werden kann. Wenn ein Textract-Job während der Ausführung fehlschlägt, muss die S3-Bereinigung trotzdem ausgeführt werden. Wenn ein Auftrag nach 10 Minuten abbricht, benötigt der Aufrufer eine saubere Fehlermeldung. Wenn die Netzwerkverbindung während des Abfragevorgangs abbricht, darf die Wiederholungsstrategie keine doppelten Aufträge erzeugen. Jeder dieser Fehlermodi erfordert eine explizite Behandlung – die oben dargestellte Struktur ist die minimale, verantwortungsvolle Implementierung.

Stapelverarbeitung fügt eine weitere Schicht hinzu: Textracts Standard-StartDocumentTextDetection TPS-Limit ist 5 Anfragen pro Sekunde. Für die Verarbeitung von 100 Dokumenten sind ein SemaphoreSlim Drosselungs-, ein Ratenauffüllungs-Timer und eine Wiederholungslogik für ProvisionedThroughputExceededException erforderlich.

IronOCR-Ansatz

// IronOCR: same synchronous API regardless of document type or size
public string ProcessDocument(string filePath)
{
    using var input = new OcrInput();

    if (Path.GetExtension(filePath).Equals(".pdf", StringComparison.OrdinalIgnoreCase))
        input.LoadPdf(filePath);
    else
        input.LoadImage(filePath);

    return new IronTesseract().Read(input).Text;
}

// IronOCR: same synchronous API regardless of document type or size
public string ProcessDocument(string filePath)
{
    using var input = new OcrInput();

    if (Path.GetExtension(filePath).Equals(".pdf", StringComparison.OrdinalIgnoreCase))
        input.LoadPdf(filePath);
    else
        input.LoadImage(filePath);

    return new IronTesseract().Read(input).Text;
}

Imports System.IO

' IronOCR: same synchronous API regardless of document type or size
Public Function ProcessDocument(filePath As String) As String
    Using input As New OcrInput()
        If Path.GetExtension(filePath).Equals(".pdf", StringComparison.OrdinalIgnoreCase) Then
            input.LoadPdf(filePath)
        Else
            input.LoadImage(filePath)
        End If

        Return New IronTesseract().Read(input).Text
    End Using
End Function

Imports System.IO

' IronOCR: same synchronous API regardless of document type or size
Public Function ProcessDocument(filePath As String) As String
    Using input As New OcrInput()
        If Path.GetExtension(filePath).Equals(".pdf", StringComparison.OrdinalIgnoreCase) Then
            input.LoadPdf(filePath)
        Else
            input.LoadImage(filePath)
        End If

        Return New IronTesseract().Read(input).Text
    End Using
End Function

Es gibt keine Abfrageschleife, keine Job-ID-Verfolgung, keinen S3-Bucket und keine Ergebnispaginierung. Derselbe Code verarbeitet sowohl ein einzelnes JPEG als auch ein 200-seitiges PDF. Die Verarbeitung wird abgeschlossen oder es wird ein Fehler ausgelöst – es gibt keinen Zwischenzustand "in Bearbeitung", der verwaltet werden müsste. Für die Stapelverarbeitung ist IronOCR thread-sicher und eine einzige IronTesseract Instanz behandelt Parallel.ForEach ohne Sperren oder Semaphore.

Die IronTesseract-Einrichtungsanleitung behandelt die Konfiguration, und die PDF-Eingabeanleitung dokumentiert die Seitenbereichsauswahl, passwortgeschützte PDFs und die stream-basierte Eingabe für PDFs, die aus Datenbanken oder HTTP-Antworten abgerufen werden.

Overhead für die Verwaltung von Anmeldeinformationen

Um einen OCR-Vorgang mit AWS Textractzu starten, ist eine IAM-Konfiguration erforderlich, bevor auch nur eine einzige Seite verarbeitet werden kann.

AWS Textract-Ansatz

Bevor DetectDocumentTextAsync aufgerufen wird, muss ein Entwickler:

1. Erstellen Sie ein AWS-Konto oder verschaffen Sie sich Zugriff auf ein bestehendes Konto.
2. Erstellen Sie einen IAM-Benutzer oder eine Rolle mit textract:DetectDocumentText und textract:AnalyzeDocument Berechtigungen
3. Generieren und sicher speichern Sie die Zugriffsschlüssel-ID und den geheimen Zugriffsschlüssel.
4. Konfigurieren Sie die Auflösung der Anmeldeinformationen – Umgebungsvariablen, AWS-Anmeldeinformationsdatei oder EC2-Instanzprofil
5. Wenn PDFs verarbeitet werden: Erstellen Sie einen S3-Bucket, konfigurieren Sie die Bucket-Richtlinie, fügen Sie s3:PutObject und s3:DeleteObject Berechtigungen hinzu
6. Implementieren Sie Richtlinien zur Rotation von Anmeldeinformationen, um die Sicherheitsstandards zu erfüllen.
7. Speichern Sie Anmeldeinformationen sicher in jeder Bereitstellungsumgebung – Docker-Secrets, Kubernetes-Secrets, AWS Secrets Manager oder CI/CD-Pipeline-Variablen.

// Every environment needs these configured before this constructor succeeds
public TextractOcrService()
{
    // Reads credentials from environment, ~/.aws/credentials, or IAM role
    _client = new AmazonTextractClient(Amazon.RegionEndpoint.USEast1);
}

// Every environment needs these configured before this constructor succeeds
public TextractOcrService()
{
    // Reads credentials from environment, ~/.aws/credentials, or IAM role
    _client = new AmazonTextractClient(Amazon.RegionEndpoint.USEast1);
}

' Every environment needs these configured before this constructor succeeds
Public Sub New()
    ' Reads credentials from environment, ~/.aws/credentials, or IAM role
    _client = New AmazonTextractClient(Amazon.RegionEndpoint.USEast1)
End Sub

' Every environment needs these configured before this constructor succeeds
Public Sub New()
    ' Reads credentials from environment, ~/.aws/credentials, or IAM role
    _client = New AmazonTextractClient(Amazon.RegionEndpoint.USEast1)
End Sub

Wenn Anmeldeinformationen ablaufen, rotieren oder falsch konfiguriert sind, schlägt jeder OCR-Aufruf mit AmazonTextractException fehl, der ErrorCode == "AccessDeniedException" enthält. In einem Produktionssystem bedeutet dies die Implementierung spezifischer Abfangmechanismen für Anmeldefehler und die Überwachung von IAM-Richtlinienabweichungen.

IronOCR-Ansatz

// One-time setup at application startup
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

// Or from environment — recommended for deployments
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

// One-time setup at application startup
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

// Or from environment — recommended for deployments
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

' One-time setup at application startup
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"

' Or from environment — recommended for deployments
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE")

' One-time setup at application startup
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"

' Or from environment — recommended for deployments
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE")

Der Lizenzschlüssel ist eine statische Zeichenkette. Es läuft nicht während des Betriebs ab, erfordert keine Rotation und beinhaltet keine Verwaltungsberechtigungen. Ein Docker-Container, der Dokumente verarbeitet, benötigt keine injizierten AWS-Anmeldeinformationen, keine an einen Ausführungskontext gebundene IAM-Rolle und keinen Netzwerkzugriff auf AWS STS zur Tokenaktualisierung.

Die vollständige Reduzierung des Anmeldeinformationen-Aufwands beim Wechsel von Textract zu IronOCR: Drei NuGet-Pakete entfernt (AWSSDK.Textract, AWSSDK.S3, AWSSDK.Core), alle AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY / AWS_DEFAULT_REGION Umgebung Variablen entfernt, und IAM-Rollen und S3-Bucket-Konfigurationen außer Betrieb genommen. Die Anleitungen zur Bild- und Stream-Eingabe decken die gesamte Bandbreite der Eingabemethoden ab, die die Byte-Array- und S3-Objekt-Dokumentmodelle von Textract ersetzen.

API-Mapping-Referenz

Wenn Teams einen Wechsel von AWS Textractzu IronOCR erwägen

Wenn die monatliche Rechnung zu einem Budgetposten wird

Teams, die mit Textract bei geringem Volumen begonnen haben, stoßen oft auf einen bestimmten Moment: Die AWS-Rechnung für die OCR-Verarbeitung taucht bei einer vierteljährlichen Budgetprüfung auf und jemand fragt, ob diese Kosten fix sind. Das ist es nicht. Bei hohen Seitenvolumina können die jährlichen Textract-Kosten beträchtlich sein — konsultieren Sie die AWS Textract-Preisgestaltungsliste für aktuelle Tarife. Die IronOCR Professional-Lizenz bei $2,399 einmalig refinanziert sich schnell bei moderaten bis hohen Seitenvolumen.

Wenn eine Compliance-Anforderung die Cloud-Verarbeitung blockiert

Bei der Implementierung von Workflows zur Dokumentendigitalisierung stellen Organisationen im Gesundheitswesen häufig erst mitten im Projekt fest, dass HIPAA-geschützte Gesundheitsdaten (PHI) nicht ohne eine BAA (Business Associate Agreement) und eine zusätzliche rechtliche Prüfung über Cloud-Dienste fließen können oder dass ihr Sicherheitsteam die Cloud-Übertragung gänzlich untersagt. Auftragnehmer im Verteidigungsbereich, die mit technischen Zeichnungen, Spezifikationen oder CUI (Controlled Unclassified Information) arbeiten, unterliegen ITAR- und CMMC-Beschränkungen, die AWS Textractvon der Berücksichtigung ausschließen. Rechtsanwaltskanzleien, die vertrauliche Kommunikation verarbeiten, haben ähnliche Bedenken. Hierbei handelt es sich nicht um theoretische Grenzfälle der Compliance – sie treten regelmäßig bei Beschaffungsprüfungen, Sicherheitsaudits und Vertragsverhandlungen auf.IronOCR verarbeitet Daten lokal, daher reduziert sich die Frage der Compliance für Dokumentendaten darauf, ob Ihre eigene Infrastruktur in den Geltungsbereich fällt, und nicht darauf, ob die Infrastruktur von Amazon in den Geltungsbereich fällt.

Wenn die Komplexität des asynchronen PDFs ihren Wert überschreitet

Die fünfphasige S3-async-Pipeline – Hochladen, Job starten, Abfragen, Paginieren der Ergebnisse, Aufräumen – ist technisch nicht schwierig zu implementieren. Es ist schwierig zu warten, zu testen und zu betreiben. Jede Phase birgt ein potenzielles Fehlerrisiko. Bei S3-Upload-Fehlern ist eine Wiederholungslogik erforderlich. Bei Fehlern im Textract-Prozess muss zwischen vorübergehenden und permanenten Fehlern unterschieden werden. Bei Abfrage-Timeouts ist eine separate Timeout-Behandlung von der Abbruchbehandlung erforderlich. Die Ergebnispaginierung erfordert das Sammeln von Zuständen über mehrere API-Aufrufe hinweg. Fehler bei der S3-Bereinigung erfordern eine Benachrichtigung, da verwaiste Objekte Kosten verursachen. Teams, die diese Pipeline in die Produktion überführt haben, verbringen in der Regel mehr Zeit mit der laufenden Wartung als mit der Entwicklung. Das IronOCR-Äquivalent — input.LoadPdf(path) gefolgt von ocr.Read(input) — eliminiert alle fünf Phasen und ihre damit verbundenen Ausfallmodi.

Wenn Bereitstellungsumgebungen keinen Internetzugang haben

Docker-Container, die in isolierten Netzwerksegmenten laufen, lokale Server ohne ausgehende Internetverbindung, abgeschottete Forschungsumgebungen und industrielle Systeme mit strengen Netzwerkkontrollen haben alle eine Gemeinsamkeit: AWS Textractist nicht verfügbar.IronOCR wird als Standard NuGet Paket installiert und funktioniert nach der Installation ohne Netzwerkaufrufe. Teams, die .NET Anwendungen in diesen Umgebungen ausführen, haben keine Textract-Option und benötigen eine Bibliothek, die lokal verarbeitet. Der Docker-Bereitstellungsleitfaden und der Linux-Bereitstellungsleitfaden beschreiben die spezifische Konfiguration für containerisierte Umgebungen.

Wenn die Drosselung der Datenrate Batch-Workflows stört

Das Standard-StartDocumentTextDetection TPS-Limit beträgt 5 Anfragen pro Sekunde. DetectDocumentText synchrone Anrufe sind ebenfalls ratengesetzt. Batch-Jobs, die Hunderte oder Tausende von Dokumenten verarbeiten, müssen SemaphoreSlim Drosselung, exponentielles Backoff bei ProvisionedThroughputExceededException und Ratenauffüllungstimer implementieren. AWS unterstützt Anträge auf Erhöhung des TPS-Limits, diese erfordern jedoch eine Begründung, eine Überprüfung und können nicht garantiert werden.IronOCR verarbeitet so schnell, wie es die lokale CPU zulässt – ein Server mit 32 Kernen verarbeitet 32 ​​Dokumente gleichzeitig ohne Drosselungskonfiguration oder Service-Tier-Aushandlung.

Gemeinsame Überlegungen zur Migration

Ersetzen des Blockgraphen durch direkte Sammlungen

Textract stellt alle Ergebnisse als flache List<Block> dar, bei denen Zeilen, Wörter, Zellen, Tabellen und Schlüsselwertpaare durch BlockType unterschieden und durch Beziehungs-ID-Arrays verknüpft sind.IronOCR bietet direkt typisierte Sammlungen.

// Textract: filter flat block list by type
var lines = response.Blocks.Where(b => b.BlockType == BlockType.LINE);
var words = response.Blocks.Where(b => b.BlockType == BlockType.WORD);

// IronOCR: direct access to typed collections
var result = ocr.Read(imagePath);
var lines = result.Lines;   // IEnumerable<OcrResult.OcrResultLine>
var words = result.Words;   // IEnumerable<OcrResult.OcrResultWord>
foreach (var word in result.Words)
    Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y}) confidence {word.Confidence}%");

// Textract: filter flat block list by type
var lines = response.Blocks.Where(b => b.BlockType == BlockType.LINE);
var words = response.Blocks.Where(b => b.BlockType == BlockType.WORD);

// IronOCR: direct access to typed collections
var result = ocr.Read(imagePath);
var lines = result.Lines;   // IEnumerable<OcrResult.OcrResultLine>
var words = result.Words;   // IEnumerable<OcrResult.OcrResultWord>
foreach (var word in result.Words)
    Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y}) confidence {word.Confidence}%");

' Textract: filter flat block list by type
Dim lines = response.Blocks.Where(Function(b) b.BlockType = BlockType.LINE)
Dim words = response.Blocks.Where(Function(b) b.BlockType = BlockType.WORD)

' IronOCR: direct access to typed collections
Dim result = ocr.Read(imagePath)
Dim lines = result.Lines   ' IEnumerable(Of OcrResult.OcrResultLine)
Dim words = result.Words   ' IEnumerable(Of OcrResult.OcrResultWord)
For Each word In result.Words
    Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y}) confidence {word.Confidence}%")
Next

' Textract: filter flat block list by type
Dim lines = response.Blocks.Where(Function(b) b.BlockType = BlockType.LINE)
Dim words = response.Blocks.Where(Function(b) b.BlockType = BlockType.WORD)

' IronOCR: direct access to typed collections
Dim result = ocr.Read(imagePath)
Dim lines = result.Lines   ' IEnumerable(Of OcrResult.OcrResultLine)
Dim words = result.Words   ' IEnumerable(Of OcrResult.OcrResultWord)
For Each word In result.Words
    Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y}) confidence {word.Confidence}%")
Next

Der Leitfaden für strukturierte Ergebnisse behandelt result.Pages, result.Paragraphs, result.Lines, result.Words und den koordinierten Zugriff für den Aufbau von layoutbewusster Dokumentenverarbeitung.

Ersetzen der S3-gestuften PDF-Verarbeitung durch Direct LoadPdf

Jeglicher Textract-Code, der vor Beginn eines Erkennungsauftrags Daten auf S3 hochlädt, kann durch einen direkten PDF-Ladevorgang ersetzt werden. Kein Staging-Bucket, keine Upload-Zeitsteuerung, keine Bereinigungslogik.

// Textract: upload to S3 → start job → poll → paginate → cleanup (50+ lines)
//IronOCR equivalent:
public string ProcessPdf(string pdfPath)
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadPdf(pdfPath);
    return ocr.Read(input).Text;
}

// Specific page ranges (no Textract equivalent without async job per range)
public string ProcessPdfPages(string pdfPath, int startPage, int endPage)
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadPdfPages(pdfPath, startPage, endPage);
    return ocr.Read(input).Text;
}

// Textract: upload to S3 → start job → poll → paginate → cleanup (50+ lines)
//IronOCR equivalent:
public string ProcessPdf(string pdfPath)
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadPdf(pdfPath);
    return ocr.Read(input).Text;
}

// Specific page ranges (no Textract equivalent without async job per range)
public string ProcessPdfPages(string pdfPath, int startPage, int endPage)
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadPdfPages(pdfPath, startPage, endPage);
    return ocr.Read(input).Text;
}

Hinzufügen einer Vorverarbeitung für Dokumente, die in Textract eine geringe Konfidenz ergaben.

Die Vorverarbeitung von Textract ist intern und nicht konfigurierbar. Wenn ein gescanntes Dokument schlechte Ergebnisse liefert, bleiben nur zwei Möglichkeiten: den Scanvorgang wiederholen oder ein Ergebnis mit geringer Zuverlässigkeit akzeptieren.IronOCR legt die Vorverarbeitungspipeline direkt offen.

// For documents that returned low-confidence results from Textract
using var input = new OcrInput();
input.LoadImage("low-quality-scan.jpg");

input.Deskew();              // Fix rotation from scanner misalignment
input.DeNoise();             // Remove scanner noise artifacts
input.Contrast();            // Boost faint text
input.EnhanceResolution(300); // Scale to optimal OCR resolution

var result = new IronTesseract().Read(input);
Console.WriteLine($"Confidence: {result.Confidence}%");

// For documents that returned low-confidence results from Textract
using var input = new OcrInput();
input.LoadImage("low-quality-scan.jpg");

input.Deskew();              // Fix rotation from scanner misalignment
input.DeNoise();             // Remove scanner noise artifacts
input.Contrast();            // Boost faint text
input.EnhanceResolution(300); // Scale to optimal OCR resolution

var result = new IronTesseract().Read(input);
Console.WriteLine($"Confidence: {result.Confidence}%");

Imports IronOcr

Dim input As New OcrInput()
input.LoadImage("low-quality-scan.jpg")

input.Deskew()              ' Fix rotation from scanner misalignment
input.DeNoise()             ' Remove scanner noise artifacts
input.Contrast()            ' Boost faint text
input.EnhanceResolution(300) ' Scale to optimal OCR resolution

Dim result = New IronTesseract().Read(input)
Console.WriteLine($"Confidence: {result.Confidence}%")

Imports IronOcr

Dim input As New OcrInput()
input.LoadImage("low-quality-scan.jpg")

input.Deskew()              ' Fix rotation from scanner misalignment
input.DeNoise()             ' Remove scanner noise artifacts
input.Contrast()            ' Boost faint text
input.EnhanceResolution(300) ' Scale to optimal OCR resolution

Dim result = New IronTesseract().Read(input)
Console.WriteLine($"Confidence: {result.Confidence}%")

Der Leitfaden zur Bildqualitätskorrektur und das Tutorial zu Bildfiltern dokumentieren die gesamte Vorverarbeitungspipeline und Kombinationen, die am besten für bestimmte Dokumenttypen funktionieren. Für die Interpretation der Vertrauenswürdigkeitspunkte und den Zugriff auf elementweise Vertrauenswerte behandelt der Leitfaden für Vertrauenspunktbewertungen die result.Confidence Eigenschaft und wortgenaue Vertrauenswerte.

Umgang mit der Änderung des asynchronen zu synchronen Musters

Vorhandener Textract-Code ist notwendigerweise async Task<t> im gesamten, da das SDK nur asynchron ist. Die Operationen von IronOCR sind synchron. Für Anwendungscode, der bereits eine asynchrone Aufrufkette hat, umschließen Sie den IronOCR-Aufruf in Task.Run, um die asynchrone Grenze beizubehalten.

// Preserves async call site for minimal refactoring
public async Task<string> ExtractTextAsync(string path)
{
    return await Task.Run(() => new IronTesseract().Read(path).Text);
}

// Preserves async call site for minimal refactoring
public async Task<string> ExtractTextAsync(string path)
{
    return await Task.Run(() => new IronTesseract().Read(path).Text);
}

Imports System.Threading.Tasks

' Preserves async call site for minimal refactoring
Public Async Function ExtractTextAsync(path As String) As Task(Of String)
    Return Await Task.Run(Function() New IronTesseract().Read(path).Text)
End Function

Imports System.Threading.Tasks

' Preserves async call site for minimal refactoring
Public Async Function ExtractTextAsync(path As String) As Task(Of String)
    Return Await Task.Run(Function() New IronTesseract().Read(path).Text)
End Function

Dies ist eine optionale Verpackung, keine Pflicht. Bei serverseitiger Verarbeitung, bei der der aufrufende Code bereits in einem Hintergrundthread ausgeführt wird, ist der synchrone Aufruf direkt vorzuziehen.

Zusätzliche Funktionen von IronOCR

Über die oben genannten Vergleichspunkte hinaus bietet IronOCR Funktionen, die kein Äquivalent zu AWS Textracthaben:

• Barcodes beim OCR-Lesen: Setzen Sie ocr.Configuration.ReadBarCodes = true und Barcodes im Dokument werden zusammen mit dem Text in einem Durchgang extrahiert — kein separater Barcode-Scan-Schritt
• Fortschrittsverfolgung für lange Aufträge : Abonnieren Sie Fortschrittsereignisse für die Verarbeitung mehrseitiger Daten, ohne einen externen Dienst abzufragen.
• Verarbeitung gescannter Dokumente : Optimierte Pipeline für typische Büroscannerausgaben, einschließlich Duplexscans und Seiten mit unterschiedlicher Ausrichtung.
• Mehrsprachige gleichzeitige Extraktion: Kombinieren Sie Sprachpakete zur Lesezeit — OcrLanguage.French + OcrLanguage.German — ohne Änderung der API-Stufe
• Pass- und Ausweislesen : Spezielle Pipeline für maschinenlesbare Bereiche auf Ausweisdokumenten, die strukturierte Felder ohne manuelle Bereichsdefinition extrahiert.

.NET-Kompatibilität und Zukunftsfähigkeit

IronOCR zielt auf .NET 8 und .NET 9 ab und bietet aktive Kompatibilität for .NET Standard 2.0-Projekte sowie .NET Framework 4.6.2 bis 4.8. Die Bibliothek liefert native Binärdateien für Windows x64, Windows x86, Linuxx64 und macOS über ein einziges NuGet Paket – ohne Laufzeitidentifikatorwechsel oder plattformspezifische Paketverweise. AWS Textracts AWSSDK.Textract Paket unterstützt die gleichen modernen .NET-Ziele, aber das Bereitstellungsmodell umfasst die gesamte AWS SDK-Abhängigkeitsstruktur, IAM-Anmeldeinfrastruktur und die architektonischen Einschränkungen, die in diesem Artikel dokumentiert sind.IronOCR wird aktiv weiterentwickelt und veröffentlicht regelmäßig Updates, die die Aktualisierungen der Tesseract 5-Engine und die Fortschritte der .NET Laufzeitumgebung berücksichtigen, einschließlich der Kompatibilität mit .NET 10 nach dessen Veröffentlichung.

Abschluss

AWS Textract und IronOCR lösen das gleiche Problem – das Extrahieren von Text aus Dokumenten in .NET -Anwendungen – mit grundlegend inkompatiblen architektonischen Annahmen. Textract geht davon aus, dass Dokumente Ihr Netzwerk verlassen können, dass die Kosten für Cloud-Dienste linear mit dem Volumen skalieren und dass mehrseitige PDFs eine fünfphasige asynchrone Pipeline mit S3-Staging rechtfertigen.IronOCR geht davon aus, dass Dokumente dort bleiben, wo sie verarbeitet werden, dass die Lizenzkosten vom Volumen entkoppelt sein sollten und dass die PDF-Verarbeitung die gleichen drei Codezeilen wie die Bildverarbeitung erfordern sollte.

Die Kostenarithmetik ist die deutlichste Trennlinie. Bei niedrigem Volumen sind die Per-Pages-Gebühren von Textract zu bewältigen. Mit zunehmendem Volumen steigen die jährlichen Kosten erheblich. Bei hohen Seitenvolumen mit Tabellenextraktion können die Textract-Kosten über mehrere Jahre hinweg die Lizenzkosten von IronOCRs Unlimited-Lizenz bei $4,799 erheblich übersteigen. Das einleitende Rechnen hält: Das Per-Seiten-Modell summiert sich schnell und hört nie auf.

Datensouveränität ist die zweite strukturelle Einschränkung. Bei Arbeitsabläufen im Gesundheitswesen, im Rechtswesen, im Finanzwesen und bei Behörden ist die Frage, wo Dokumente bearbeitet werden, keine Frage der Präferenz – es handelt sich um eine gesetzliche Vorgabe.IronOCR verarbeitet Prozesse standardmäßig lokal, nicht durch Konfiguration. Es gibt keinen "lokalen Modus", der aktiviert werden könnte; Die lokale Verarbeitung ist der einzige Modus. Damit ist die Antwort in Sachen Compliance ganz einfach: Ihre Dokumente bleiben in Ihrer Infrastruktur, weil es keinen anderen Ort gibt, an den sie gelangen könnten.

Für Teams, die OCR im großen Maßstab evaluieren oder in Umgebungen arbeiten, in denen Dokumentendaten die interne Infrastruktur nicht verlassen dürfen, bietet die Dokumentation von IronOCR die vollständige API-Referenz, Bereitstellungsleitfäden für Docker, AWS, Azureund Linuxsowie Tutorials, die das gesamte Spektrum der OCR-Anwendungsfälle abdecken – von der einfachen Bilderkennung bis hin zur Generierung durchsuchbarer PDFs und der Extraktion mehrerer Sprachen.