Ein Vergleich zwischen IronOCR und Nanonets OCR

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

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

Public Class PdfProcessor
    Private _s3Client As IAmazonS3
    Private _textractClient As IAmazonTextract
    Private _bucketName As String

    Public Async Function ProcessPdfAsync(pdfPath As String) As Task(Of String)
        ' Step 1: Upload to S3 — credentials for two services required
        Dim key As String = $"uploads/{Guid.NewGuid()}.pdf"
        Using fileStream As FileStream = File.OpenRead(pdfPath)
            Await _s3Client.PutObjectAsync(New PutObjectRequest With {
                .BucketName = _bucketName,
                .Key = key,
                .InputStream = fileStream
            })
        End Using

        Try
            ' Step 2: Start async Textract job
            Dim startResponse = Await _textractClient.StartDocumentTextDetectionAsync(
                New StartDocumentTextDetectionRequest With {
                    .DocumentLocation = New DocumentLocation With {
                        .S3Object = New S3Object With {.Bucket = _bucketName, .Name = key}
                    }
                })

            Dim jobId As String = startResponse.JobId

            ' Step 3: Poll every 5 seconds until complete
            Dim getResponse As GetDocumentTextDetectionResponse
            Do
                Await Task.Delay(5000)
                getResponse = Await _textractClient.GetDocumentTextDetectionAsync(
                    New GetDocumentTextDetectionRequest With {.JobId = jobId})
            Loop While getResponse.JobStatus = JobStatus.IN_PROGRESS

            If getResponse.JobStatus <> JobStatus.SUCCEEDED Then
                Throw New Exception($"Textract job failed: {getResponse.StatusMessage}")
            End If

            ' Step 4: Paginate through result blocks
            Dim allText As New StringBuilder()
            Dim nextToken As String = Nothing
            Do
                Dim pageResponse = Await _textractClient.GetDocumentTextDetectionAsync(
                    New GetDocumentTextDetectionRequest With {
                        .JobId = jobId,
                        .NextToken = nextToken
                    })

                For Each block In pageResponse.Blocks.Where(Function(b) b.BlockType = BlockType.LINE)
                    allText.AppendLine(block.Text)
                Next

                nextToken = pageResponse.NextToken
            Loop While nextToken IsNot Nothing

            Return allText.ToString()
        Finally
            ' Step 5: Stets clean up S3
            Await _s3Client.DeleteObjectAsync(_bucketName, key)
        End Try
    End Function
End Class

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.

Detaillierter Funktionsvergleich

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

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;

Imports IronOcr

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

Dim text As String = New IronTesseract().Read("document.jpg").Text

Die $2,999 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.

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

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

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.

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

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

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.

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

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

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.

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

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

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

Imports IronOcr

Public Class PdfProcessor
    ' Textract: upload to S3 → start job → poll → paginate → cleanup (50+ lines)
    ' IronOCR equivalent:
    Public Function ProcessPdf(pdfPath As String) As String
        Dim ocr As New IronTesseract()
        Using input As New OcrInput()
            input.LoadPdf(pdfPath)
            Return ocr.Read(input).Text
        End Using
    End Function

    ' Specific page ranges (no Textract equivalent without async job per range)
    Public Function ProcessPdfPages(pdfPath As String, startPage As Integer, endPage As Integer) As String
        Dim ocr As New IronTesseract()
        Using input As New OcrInput()
            input.LoadPdfPages(pdfPath, startPage, endPage)
            Return ocr.Read(input).Text
        End Using
    End Function
End Class

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

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

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.