Read API platformyAzure Computer Visionkosztuje 1,00 USD za 1 000 transakcji, wymaga subskrypcji Azure do buforowania zasobów Cognitive Services i zmusza do przetwarzania asynchronicznego przy każdym wywołaniu OCR: serializacja dokumentu do BinaryData, wywołanie AnalyzeAsync, a następnie przemierzanie zagnieżdżonych bloków i linii by odtworzyć tekst. To minimalna opcja — a każda strona wielostronicowego pliku PDF liczy się jako osobna transakcja. IronOCR sprowadza to wszystko do jednego synchronicznego wywołania metody, działa całkowicie w ramach Twojej infrastruktury i nie ma opłat za transakcję.

Zrozumienie Azure Computer Vision

Azure Computer Vision to usługa kognitywna Microsoftu działająca w chmurze, która udostępnia OCR przez dwa główne interfejsy API: Image Analysis API (używając ImageAnalysisClient z VisualFeatures.Read) dla obrazów i Azure Form Recognizer's DocumentAnalysisClient dla plików PDF. Oba to usługi oparte na REST hostowane w centrach danych Azure, dostępne za pośrednictwem pakietów NuGet Azure.AI.Vision.ImageAnalysis i Azure.AI.FormRecognizer.DocumentAnalysis odpowiednio.

Kluczowe cechy architektury:

• Zawsze w chmurze: każda operacja OCR przesyła dane dokumentu do serwerów zarządzanych przez Microsoft za pośrednictwem protokołu HTTPS. Nie ma trybu przetwarzania lokalnego.
• Wymagania wstępne dotyczące subskrypcji: Zespoły muszą utworzyć konto Azure, skonfigurować zasób Cognitive Services, uzyskać adres URL punktu końcowego oraz wygenerować klucz API przed napisaniem choćby jednej linii kodu OCR.
• Rozliczenie transakcji za stronę: Interfejs API Read pobiera opłaty za obraz lub za stronę PDF. 50-stronicowy plik PDF to 50 transakcji. Ceny zaczynają się od 1,00 USD za 1000 transakcji dla pierwszego miliona, a przy większych wolumenach spadają do 0,60 USD, a następnie do 0,40 USD.
• Limit w ramach bezpłatnego planu: 5000 transakcji miesięcznie w ramach bezpłatnego planu — wystarczające do tworzenia prototypów, ale nie do obciążeń produkcyjnych.
• Rozdzielna usługa dla PDF: Podstawowy OCR obrazów korzysta z ImageAnalysisClient. Pełne przetwarzanie PDF wymaga osobnej usługi — Form Recognizer's DocumentAnalysisClient — z własnym punktem końcowym i konfiguracją.
• Projekt wyłącznie asynchroniczny: Wszystkie wywołania API Read są asynchroniczne. Lokalne OCR może zwracać wyniki synchronicznie; przejścia w chmurze nie mogą. Każda metoda wywołująca w łańcuchu musi być async.
• Limity szybkości: Poziom S1 ma limit 10 transakcji na sekundę. Przetwarzanie dużych partii danych wymaga logiki kolejkowania lub aktualizacji warstw.
• Obszar potencjalnych błędów: Kod produkcyjny musi obsługiwać odpowiedzi HTTP 429 dotyczące ograniczeń szybkości, błędy usług Azure 5xx, przekroczenia limitów czasu sieci, niepowodzenia uwierzytelniania oraz dostępność punktów końcowych — z których każdy wymaga oddzielnej logiki ponownej próby.

Wzorzec asynchronicznego odpytywania

Wymóg asynchroniczności interfejsu API Read ma konsekwencje dla struktury kodu. Analiza obrazów przy użyciu AnalyzeAsync zwraca wynik natychmiast, ale wymaga await; Przetwarzanie PDF przez Form Recognizer wymaga WaitUntil.Completed do zablokowania do momentu zakończenia operacji, lub własne odpytywanie z UpdateStatusAsync dla prawdziwego zachowania asynchronicznego. Hierarchia wyników wymaga następnie przechodzenia przez bloki, wiersze i słowa za pomocą zagnieżdżonych pętli:

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

public class AzureOcrService
{
    private readonly ImageAnalysisClient _client;

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

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

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

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

        return text.ToString();
    }
}

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

public class AzureOcrService
{
    private readonly ImageAnalysisClient _client;

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

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

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

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

        return text.ToString();
    }
}

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

Public Class AzureOcrService
    Private ReadOnly _client As ImageAnalysisClient

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

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

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

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

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

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

Public Class AzureOcrService
    Private ReadOnly _client As ImageAnalysisClient

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

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

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

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

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

Przetwarzanie PDF podwyższa jeszcze bardziej złożoność — osobny DocumentAnalysisClient z własnym punktem końcowym, AnalyzeDocumentAsync z WaitUntil.Completed, oraz inny kształt wyniku przy użyciu result.Pages i page.Lines dostępu do .Content zamiast .Text.

Zrozumienie IronOCR

IronOCR to komercyjna biblioteka OCR dla platformy .NET, dostarczana jako pojedynczy pakiet NuGet. Zawiera zoptymalizowany silnik Tesseract 5 z automatycznym przetwarzaniem wstępnym, natywną obsługą plików PDF oraz synchronicznym interfejsem API, który nie wymaga danych uwierzytelniających do chmury, konfiguracji punktów końcowych ani asynchronicznej infrastruktury.

Kluczowe cechy:

• Pojedyncze wdrożenie NuGet: dotnet add package IronOcr instaluje wszystko — silnik OCR, natywne binaria i dane językowe dla angielskiego. Bez folderów tessdata, bez oddzielnego pobierania bibliotek natywnych.
• Licencjonowanie wieczyste: $999 Lite / $1,499 Plus / $2,399 Professional / $4,799 Unlimited — jednorazowy zakup, nie subskrypcja. Brak opłat za dokument, niezależnie od objętości.
• Przetwarzanie lokalne: całe OCR działa w ramach Twojego procesu. Dokumenty nigdy nie opuszczają Twojej infrastruktury.
• Automatyczne przetwarzanie wstępne: Deskew, DeNoise, Contrast, Binarize i poprawa rozdzielczości są stosowane automatycznie lub poprzez jawne wywołania filtrów na OcrInput.
• Natywna obsługa PDF: IronTesseract.Read("document.pdf") obsługuje PDF-y bezpośrednio, w tym pliki chronione hasłem, bez osobnej usługi czy dodatkowego pakietu NuGet.
• 125+ języków: Instalowane za pośrednictwem oddzielnych pakietów językowych NuGet — IronOcr.Languages.French, IronOcr.Languages.ChineseSimplified, itp. — bez ręcznego zarządzania tessdata.
• Bezpieczny dla wielowątkowości: IronTesseract może być używany jednocześnie bezpiecznie. Dla zadań wsadowych można używać Parallel.ForEach bez dodatkowej synchronizacji.
• Strukturalne dane wyjściowe: OcrResult udostępnia zbiory .Pages, .Paragraphs, .Lines, .Words i .Barcodes z informacją o współrzędnych dla każdego elementu, współczynnikach zaufania i prostokątach obramowań.

Porównanie funkcji

Szczegółowe porównanie funkcji

Model kosztów

Różnica w cenach transakcyjnych międzyAzure Computer Visiona IronOCR staje się decydująca przy dużych wolumenach produkcji. Kalkulator kosztów z plików źródłowych platformy Azure dokładnie przedstawia obliczenia.

Podejście Azure Computer Vision

Azure nalicza opłaty za transakcję stosując ceny warstwowe w zależności od wolumenu. Skonsultuj stronę z wyceną Azure Computer Vision dla aktualnych stawek. Każda strona PDF stanowi jedną transakcję. 10-stronicowy plik PDF to 10 rozliczanych zleceń. Dostępny jest bezpłatny poziom 5 000 transakcji miesięcznie.

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

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

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

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

Przy umiarkowanych do dużych ilościach dokumentów, licencja wieczysta IronOCR szybko się zwraca w porównaniu z trwającymi kosztami transakcji Azure, po czym każdy dodatkowy dokument to oszczędność.

Podejście IronOCR

Model cenowy IronOCR opiera się na jednej kwocie. Zainstaluj pakiet NuGet, ustaw klucz licencyjny i przetwarzaj dowolną ilość danych bez licznika:

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

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

var ocr = new IronTesseract();

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

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

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

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

var ocr = new IronTesseract();

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

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

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

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

Dim ocr As New IronTesseract()

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

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

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

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

Dim ocr As New IronTesseract()

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

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

Nie są potrzebne żadne pomiary, śledzenie użytkowania ani alerty budżetowe. Przewidywalne koszty od pierwszego dnia. Aby zapoznać się z kompletnym przewodnikiem dla początkujących, zapoznaj się z samouczkiem dotyczącym odczytywania tekstu z obrazów.

Suwerenność danych i możliwość pracy w trybie offline

Konsekwencje zgodności związane z chmurowym OCR nie są teoretyczne. Każdy dokument przetwarzany przezAzure Computer Visionprzekracza granice organizacji. Dokument README platformy Azure opisuje konkretne ramy regulacyjne, których to dotyczy: podmioty objęte ustawą HIPAA, wykonawcy z branży obronnej objęci przepisami ITAR, organizacje posiadające certyfikat CMMC, europejskie firmy podlegające przepisom RODO oraz wszelkie operacje w sieciach typu air-gapped.

Podejście Azure Computer Vision

Nawet przy regionalnym wyborze punktu końcowego i podpisanej umowie o współpracy biznesowej przepływ danych jest stały:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Sieć typu air-gapped nie ma żadnego dostępu do adresu URL punktu końcowego — usługaAzure Computer Visionnie posiada trybu offline. Dla organizacji prowadzących SCIF, obiekty wojskowe lub izolowane środowiska przetwarzania usługa jest niekompatybilna pod względem architektury, niezależnie od ceny.

Podejście IronOCR

IronOCR przetwarza dokumenty w ramach procesu wywołującego. Nie ma połączenia wychodzącego:

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

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

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

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

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

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

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

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

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

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

Wdrożenie Docker całkowicie eliminuje wymagania dotyczące sieci wychodzącej:

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

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

W przypadku podmiotów objętych HIPAA, zgodności z ITAR lub scenariuszy FedRAMP z izolacją fizyczną,IronOCR eliminuje całe ryzyko związane z zewnętrznymi podmiotami przetwarzającymi dane. Zapoznaj się z przewodnikiem wdrażania w Azure, aby uruchomićIronOCR w infrastrukturze Azure, zachowując dokumenty lokalnie na instancji obliczeniowej, oraz z przewodnikiem wdrażania Docker, aby skonfigurować kontener.

Projektowanie API synchronicznego a asynchronicznego

Interfejs API Azure Read jest asynchroniczny, ponieważ nie może być synchroniczny — operacje wejścia/wyjścia w chmurze wiążą się z opóźnieniami sieciowymi.IronOCR przetwarza lokalnie i może zwracać synchronicznie, co upraszcza kod wywołujący, eliminuje propagację async przez stos wywołań i usuwa tryby awarii związane z I/O sieciowym.

Podejście Azure Computer Vision

Każde wywołanie OCR w Azure wymaga await. Kod produkcyjny dodaje logikę ponownej próby dla błędów 429 związanych z limitem szybkości oraz błędów usługi 5xx. Minimalna implementacja produkcyjna wygląda następująco:

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

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

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

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

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

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

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

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

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

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

Imports System.IO
Imports System.Threading.Tasks

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

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

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

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

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

Imports System.IO
Imports System.Threading.Tasks

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

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

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

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

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

Nie jest to defensywna nadmierna inżynieria — jest to minimum wymagane dla każdego wywołania interfejsu API platformy Azure w środowisku produkcyjnym. Limity szybkości, przerwy w działaniu usług i przejściowe błędy to rzeczywiste sytuacje, z którymi spotka się każdy użytkownik platformy Azure.

Podejście IronOCR

Lokalne przetwarzanie eliminuje powierzchnię awarii sieci. Zakres obsługi błędów ogranicza się do systemu plików i walidacji danych wejściowych:

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

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

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

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

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

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

Bez RequestFailedException, bez pętli ponownych prób, bez koordynacji Task.WhenAll dla zadań wsadowych. Jeśli potrzebujesz asynchroniczności do integracji z asynchronicznym potokiem kontrolera, Task.Run(() => ocr.Read(path)) opakowuje synchroniczne wywołanie bez zmian strukturalnych samej logiki OCR. Dokumentacja API IronTesseract obejmuje pełny interfejs synchroniczny. W przypadku zadań, które rzeczywiście wymagają wzorców asynchronicznych,IronOCR udostępnia również dedykowany przewodnik po asynchronicznym OCR.

Konfiguracja poświadczeń i punktów końcowych

Azure Computer Vision wymaga przygotowania infrastruktury przed pierwszym testem.IronOCR wymaga instalacji NuGet i opcjonalnie ciągu znaków klucza licencyjnego.

Podejście Azure Computer Vision

Sekwencja konfiguracji platformy Azure przed napisaniem jakiegokolwiek kodu OCR:

1. Utwórz konto Azure, jeśli jeszcze go nie masz.
2. Przejdź do portalu Azure i utwórz zasób Cognitive Services (lub zasób Azure AI Services).
3. Wybierz poziom cenowy i region.
4. Skopiuj URL punktu końcowego (format: https://your-resource.cognitiveservices.azure.com/).
5. Skopiuj jeden z dwóch kluczy API.
6. Przechowuj obie wartości bezpiecznie — w zmiennych środowiskowych, Azure Key Vault lub appsettings.json (tylko poza produkcją).
7. Zainstaluj Azure.AI.Vision.ImageAnalysis przez NuGet.
8. Zainicjalizuj ImageAnalysisClient z punktem końcowym i poświadczeniami.

Dla przetwarzania PDF powtórz kroki od 2 do 8 dla zasobu Form Recognizer przy użyciu innego pakietu NuGet (Azure.AI.FormRecognizer) i innej klasy klienta (DocumentAnalysisClient).

appsettings.json przechowuje punkt końcowy i klucz:

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

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

Rotacja kluczy API, obsługa wygasania poświadczeń oraz zarządzanie adresami URL punktów końcowych w różnych środowiskach (rozwojowym, testowym, produkcyjnym) to bieżące zadania operacyjne, które nie mają odpowiednika w przetwarzaniu lokalnym.

Podejście IronOCR

Przewodnik konfiguracji IronTesseract sprowadza konfigurację do dwóch kroków:

dotnet add package IronOcr

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

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

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

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

Imports System

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

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

Imports System

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

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

Klucz licencyjny jest ciągiem statycznym. Nie wygasa na żądanie, nie wymaga rotacji i nie wysyła zapytania do serwera w celu weryfikacji po aktywacji. Środowiska wdrożeniowe nie wymagają reguł zapory wychodzącej, aby funkcja OCR działała.

Przewodnik po mapowaniu API

Kiedy zespoły rozważają przejście zAzure Computer Visionna IronOCR

Wymagania dotyczące zgodności Przetwarzanie w chmurze

Niezależny dostawca oprogramowania z branży medycznej, tworzący system zarządzania dokumentami, zaczyna od Azure Computer Vision, ponieważ można go szybko zintegrować. Wtedy pojawia się pierwszy klient korporacyjny — sieć szpitali z inspektorem bezpieczeństwa HIPAA, który zadaje dwa pytania: "Gdzie trafiają nasze dane medyczne (PHI)?" oraz "Czy możecie pokazać nam umowę o współpracy biznesowej (BAA) dotyczącą tej strony trzeciej?". Azure ma umowę BAA, ale odpowiedź na pierwsze pytanie — "centra danych Microsoftu" — wywołuje długotrwały przegląd bezpieczeństwa, prośbę o raporty audytowe Microsoftu oraz harmonogram zapewnienia zgodności, który opóźnia podpisanie umowy. Przejście na IronOCR całkowicie eliminuje ten problem. Dane PHI nigdy nie opuszczają środowiska klienta. Zakres zgodności ogranicza się do organizacji klienta.

Wzrost wolumenu sprawia, że ceny za transakcję stają się nieopłacalne

Zespół operacyjny uruchamia proces przetwarzania faktur na poziomie 5000 dokumentów miesięcznie — co spokojnie mieści się w ramach bezpłatnego pakietu Azure. W miarę wzrostu wolumenu, koszty za transakcję rosną z każdym przetworzonym dokumentem.IronOCR Professional ($2,399) to jednorazowy zakup bez opłat za dokument. Zespoły, które przewidują nawet umiarkowany wzrost wolumenu, szybko osiągają próg rentowności, a każdy dodatkowy dokument to oszczędność.

Opóźnienia sieciowe wpływają na umowy SLA dotyczące przetwarzania

Usługa przetwarzania dokumentów ma na celu zapewnienie kompleksowej umowy SLA w ciągu 2 sekund.Azure Computer Visionpowoduje opóźnienie sieciowe wynoszące 200–800 ms w przypadku wywołań w tym samym regionie oraz 500–2000 ms w przypadku wdrożeń międzyregionowych — przed samym obliczeniem OCR. Pod obciążeniem limit 10 TPS na S1 wymusza tworzenie kolejki, co dodatkowo zwiększa opóźnienia.IronOCR przetwarza pojedynczy obraz o rozdzielczości 300 DPI w czasie 100–400 ms na standardowym sprzęcie serwerowym bez kolejki, limitu szybkości i przeskoków sieciowych. Umowa SLA staje się przewidywalna, ponieważ zależy wyłącznie od sprzętu, a nie od stanu usług Azure czy warunków sieciowych.

Wymagania dotyczące infrastruktury typu air-gapped

Wykonawcy z sektóra obronnego, agencje wywiadowcze i operatorzy infrastruktury krytycznej obsługują obciążenia w sieciach, które z założenia nie mają połączenia z Internetem.Azure Computer Visionjest technicznie niekompatybilny z tymi środowiskami — nie można uzyskać dostępu do punktu końcowego. Zespoły w tych sektórach potrzebują biblioteki, która wdraża się jako samodzielny plik binarny, działa bez połączeń wychodzących i przechodzi kontrole bezpieczeństwa, które wyraźnie zabraniają transmisji danych do chmury. WdrożenieIronOCRw systemie Linux oraz obsługa Docker sprawiają, że można go wdrożyć w środowiskach o ograniczonym dostępie bez konieczności modyfikacji.

Uproszczenie wdrażania w wielu środowiskach

Zespół zarządzający środowiskami deweloperskimi, testowymi i produkcyjnymi dla aplikacji SaaS korzysta z trzech zasobów Azure Cognitive Services, trzech zestawów kluczy API oraz trzech adresów URL punktów końcowych — z których każdy wymaga bezpiecznego przechowywania, zasad rotacji oraz konfiguracji dostosowanej do danego środowiska. Każde środowisko wdrożeniowe wymaga dostępu do sieci wychodzącej do platformy Azure.IronOCR redukuje konfigurację per-środowisko do jednej zmiennej środowiskowej (IRONOCR_LICENSE), eliminuje wymóg dostępu do sieci i usuwa operacyjne obciążenie zarządzania poświadczeniami w różnych środowiskach.

Typowe kwestie związane z migracją

Wzorzec asynchroniczny do synchronicznego

Kod użytkownika Azure jest async z konieczności.IronOCR nie wymaga asynchroniczności, ale przejście jest mechaniczne. Zamień typy zwrotów async Task<string> na string, usuń słowa kluczowe await i async oraz usuń pętlę ponownych prób. Jeśli metoda wywołująca jest kontrolerem ASP.NET lub usługą, która musi pozostać asynchroniczna, opakuj wywołanie IronOCR w Task.Run:

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

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

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

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

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

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

Normalizacja skali pewności

Azure Computer Vision zwraca zaufanie co do słów jako float między 0 a 1.IronOCR zwraca zaufanie jako double w skali 0-100. Każdy kod, który przekracza wartości progowe zaufania platformy Azure, wymaga dostosowania:

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

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

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

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

Imports IronOcr

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

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

Imports IronOcr

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

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

Dokumentacja API OcrResult zawiera opis wszystkich właściwości wyników, w tym skali pewności. Przewodnik dotyczący oceny pewności obejmuje wybór progów i interpretację poszczególnych elementów.

Konsolidacja usług przetwarzania plików PDF

Azure dzieli OCR obrazów i OCR plików PDF na dwie oddzielne usługi z osobnymi klientami, pakietami NuGet i konfiguracjami punktów końcowych. Migracja oznacza konsolidację obu ścieżek do jednej instancji IronTesseract. Metoda OcrInput.LoadPdf akceptuje ścieżkę do pliku, strumień lub tablicę bajtów, z opcjonalnym parametrem Password dla zaszyfrowanych plików — nie jest wymagany drugi klient:

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

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

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

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

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

// Wynik w formacie PDF z możliwością wyszukiwania — no manual construction
pdfResult.SaveAsSearchablePdf("searchable-output.pdf");

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

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

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

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

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

// Wynik w formacie PDF z możliwością wyszukiwania — no manual construction
pdfResult.SaveAsSearchablePdf("searchable-output.pdf");

Przewodnik dotyczący danych wejściowych w formacie PDF obejmuje wybór zakresu stron, dane wejściowe strumieniowe oraz natywny proces renderowania plików PDF. Informacje na temat danych wejściowych w postaci obrazów można znaleźć w przewodniku dotyczącym danych wejściowych w postaci obrazów.

Pobieranie danych strukturalnych bez rozpoznawania formularzy

Zespoły używające predefiniowanych modeli Form Recognizer (faktury, pokwitowania, dokumenty tożsamości) do ekstrakcji pól muszą powtórzyć tę logikę ekstrakcji w IronOCR przy użyciu OCR opartego na regionach z CropRectangle. Ekstrakcja pozycyjna jest jawna, a nie oparta na modelu:

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

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

string vendor, date, total;

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

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

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

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

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

string vendor, date, total;

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

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

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

Imports IronOcr

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

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

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

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

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

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

Imports IronOcr

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

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

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

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

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

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

Przewodnik OCR opartego na regionach szczegółowo opisuje użycie CropRectangle. W przypadku procesów związanych z fakturami samouczek dotyczący OCR faktur pokazuje pełny wzorzec wyodrębniania danych.

Dodatkowe możliwości IronOCR

Oprócz powyższych punktów porównawczych,IronOCR oferuje funkcje, którychAzure Computer Visionnie udostępnia za pośrednictwem standardowego interfejsu API OCR:

• Przetwarzanie zeskanowanych dokumentów: Pełny proces wstępnego przetwarzania — prostowanie, usuwanie szumów, regulacja kontrastu, binaryzacja, wyostrzanie — jest stosowany przed tym, jak silnik OCR zobaczy obraz, poprawiając dokładność skanów, które zwracają puste lub mało wiarygodne wyniki z interfejsów API w chmurze.
• Śledzenie postępu w przypadku długich dokumentów: subskrybuj zdarzenia postępu podczas przetwarzania wielostronicowych plików PDF — przydatne w przypadku długotrwałych zadań wsadowych wymagających informacji zwrotnej z interfejsu użytkownika.
• Wstępne przetwarzanie obrazów: przetwarzanie wstępne oparte na głębokim uczeniu się, przeznaczone dla trudnych dokumentów, takich jak zdjęcia wykonane pod kątem lub w zmiennym oświetleniu.

Zgodność z platformą .NET i gotowość na przyszłość

IronOCR obsługuje platformy .NET 8, .NET 9, .NET Standard 2.0 oraz .NET Framework 4.6.2–4.8 z poziomu jednego pakietu NuGet. Obsługuje systemy Windows x64, Windows x86, Linux x64, macOS (Intel i Apple Silicon) oraz ARM64 — obejmując pełen zakres nowoczesnych środowisk wdrożeniowych .NET, w tym Azure App Service, AWS Lambda, kontenery Docker oraz lokalne serwery Linux. SDK .NET platformyAzure Computer Vision(Azure.AI.Vision.ImageAnalysis) również utrzymuje nowoczesną zgodność z .NET, ale architektura chmurowa oznacza, że zgodność z językiem uruchomieniowym jest drugorzędna względem zgodności z punktem końcowym Azure, który jest wersjonowany i aktualizowany niezależnie od SDK.IronOCR dostarcza aktualizacje języków i silników za pośrednictwem NuGet, dzięki czemu model aktualizacji jest spójny z resztą ekosystemu .NET.

Wnioski

Azure Computer Vision to wydajna usługa OCR przeznaczona dla zespołów działających już w ekosystemie Azure, których dokumenty nie podlegają ograniczeniom regulacyjnym dotyczącym transmisji w chmurze, a których objętość mieści się w ramach bezpłatnego pakietu lub płatnych pakietów o niskim limicie. Asynchroniczny interfejs API działa poprawnie, dokładność w przypadku standardowych dokumentów jest niezawodna, a gotowe modele Form Recognizer zmniejszają nakład pracy związany z tworzeniem dokumentów o strukturze, takich jak faktury i pokwitowania.

Model kosztowy nie jest jednak skalowalny. Przy 50 000 dokumentów miesięcznie IronOCR Lite zwraca się w mniej niż dwa miesiące dzięki oszczędnościom na opłatach transakcyjnych Azure. Rozliczenie za stronę w przypadku wielostronicowych plików PDF zwiększa koszt. Każdy rok działalności po osiągnięciu progu rentowności to pieniądze, które nie trafiają do Microsoftu. Dla każdego zespołu, który planuje wzrost powyżej 10 000 dokumentów miesięcznie, długoterminowa ekonomika przemawia za licencją wieczystą na lokalną instalację.

Argument dotyczący suwerenności danych ma charakter bardziej absolutny. Jeśli przez proces OCR przepływają dane medyczne (PHI), dane objęte przepisami ITAR, komunikacja objęta tajemnicą adwokacką lub jakakolwiek inna kategoria dokumentów, których przekazywanie poza organizację jest zabronione prawnie lub umownie, usługaAzure Computer Visionjest wykluczona z projektu — nie jest traktowana jako mniej korzystna, lecz całkowicie wykluczona. Model przetwarzania lokalnego IronOCR obsługuje te obciążenia bez uszczerbku dla architektury.

Złożoność asynchronicznego odpytywania stanowi rzeczywiste obciążenie. Logika ponawiania, obsługa limitów szybkości, tryby awarii sieci oraz podział między ImageAnalysisClient a DocumentAnalysisClient dla obrazów a PDF dodają kod, który nie ma wartości OCR — jest to kod integracji z chmurą. Synchronous metoda Read()IronOCR obsługuje obrazy i PDF-y z identycznym kodem, bez potrzeby propagacji asynchronicznej i bez konieczności logiki ponawiania. Dla zespołów, które chcą poświęcić wysiłek inżynieryjny na swoją aplikację, a nie na integrację z chmurowymi interfejsami API, ta prostota ma znaczną wartość w całym cyklu życia projektu.