IronOCR ou Iris OCR : quelle solution OCR les équipes d’ingénierie devraient-elles choisir ?

Modèle de sondage asynchrone

L'exigence d'asynchronisme de l'API Read engendre des conséquences structurelles dans le code. L'analyse d'image utilisant AnalyzeAsync retourne immédiatement mais nécessite await; Le traitement PDF via Form Recognizer nécessite WaitUntil.Completed pour bloquer jusqu'à ce que l'opération se termine, ou un sondage personnalisé avec UpdateStatusAsync pour un vrai comportement async. La hiérarchie des résultats nécessite alors de parcourir les blocs, les lignes et les mots à travers des boucles imbriquées :

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

Le traitement des PDF augmente encore la complexité — un DocumentAnalysisClient séparé avec son propre point d'accès, AnalyzeDocumentAsync avec WaitUntil.Completed, et une forme de résultat différente utilisant result.Pages et page.Lines accédant .Content au lieu de .Text.

Comparaison détaillée des fonctionnalités

Approche Azure Computer Vision

Azure facture par transaction en utilisant une tarification par paliers basée sur le volume. Consultez la page de tarification Azure Computer Vision pour les tarifs actuels. Chaque page PDF correspond à une transaction. Un PDF de 10 pages correspond à 10 appels facturables. Un niveau gratuit de 5 000 transactions par mois est disponible.

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

À volumes modérés à élevés de documents, la licence perpétuelle de IronOCR se rentabilise rapidement par rapport aux coûts de transaction Azure continus, après quoi chaque document supplémentaire est une économie.

Approche d'IronOCR

Le modèle tarifaire d'IronOCR repose sur un tarif unique. Installez le package NuGet, configurez la clé de licence et traitez n'importe quel volume sans que le compteur ne s'active :

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

Pas de comptage, pas de suivi de l'utilisation, pas d'alertes budgétaires nécessaires. Des coûts prévisibles dès le premier jour. Consultez le tutoriel " Lecture de texte à partir d'images " pour un guide complet de mise en route.

Approche Azure Computer Vision

Même avec la sélection d'un point de terminaison régional et un accord de partenariat commercial signé, le flux de données est fixe :

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

Un réseau isolé ne peut absolument pas accéder à l'URL du point de terminaison — Azure Computer Visionne dispose pas de mode hors ligne. Pour les organisations exploitant des SCIF, des installations militaires ou des environnements de traitement isolés, le service est architecturalement incompatible, quel que soit son prix.

Approche d'IronOCR

IronOCR traite les documents au sein du processus appelant. Il n'y a pas de connexion sortante :

// 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
        // Non 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
        // Non network call, no serialization to external endpoint
        var result = _ocr.Read(imagePath);
        return result.Text;
    }

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

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

Imports IronOcr

Public Class OnPremiseOcrService
    Private ReadOnly _ocr As New IronTesseract()

    Public Function ExtractText(imagePath As String) As String
        ' Runs entirely in-process
        ' Non network call, no serialization to external endpoint
        Dim result = _ocr.Read(imagePath)
        Return result.Text
    End Function

    Public Function ExtractFromPdf(pdfPath As String) As String
        ' PDF processed entirely on-premise, native support
        Using input As New OcrInput()
            input.LoadPdf(pdfPath)
            Return _ocr.Read(input).Text
        End Using
    End Function

    Public Function ExtractFromEncryptedPdf(pdfPath As String, password As String) As String
        ' Encrypted PDFs also stay local
        Using input As New OcrInput()
            input.LoadPdf(pdfPath, Password:=password)
            Return _ocr.Read(input).Text
        End Using
    End Function
End Class

Le déploiement Docker supprime entièrement les exigences en matière de réseau sortant :

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

Pour les entités soumises à la loi HIPAA, la conformité ITAR ou les scénarios FedRAMP en mode air-gapped, IronOCR élimine toute la catégorie de risques liés aux sous-traitants tiers. Consultez le guide de déploiement Azure pour exécuter IronOCR au sein de l'infrastructure Azure tout en conservant les documents localement sur l'instance de calcul, et le guide de déploiement Docker pour la configuration des conteneurs.

Approche Azure Computer Vision

Chaque appel OCR Azure nécessite await. Le code de production ajoute une logique de réessai pour les erreurs de limitation de débit 429 et les erreurs de service 5xx. Une implémentation minimale en production se présente comme suit :

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

Il ne s'agit pas d'une suringénierie défensive, mais du minimum requis pour tout appel d'API Azure en production. Les limites de débit, les interruptions de service et les erreurs transitoires sont des situations réelles auxquelles tout utilisateur d'Azure sera confronté.

Approche d'IronOCR

Le traitement local élimine les points de défaillance du réseau. La gestion des erreurs se limite au système de fichiers et à la validation des entrées :

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

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

Option Strict On



Public Function ExtractText(imagePath As String) As String
    Dim result = New IronTesseract().Read(imagePath)
    Return result.Text
End Function

Public Function OneLineOcr(imagePath As String) As String
    Return New IronTesseract().Read(imagePath).Text
End Function

Public Function ExtractWithConfidence(imagePath As String) As (Text As String, Confidence As Double)
    Dim result = New IronTesseract().Read(imagePath)
    Return (result.Text, result.Confidence)
End Function

Pas de RequestFailedException, pas de boucles de nouvelle tentative, pas de coordination Task.WhenAll pour les tâches par lot. Si vous avez besoin d'async pour l'intégration avec un pipeline de contrôleurs async, Task.Run(() => ocr.Read(path)) enveloppe l'appel synchrone sans changements structurels de la logique OCR elle-même. La référence de l'API IronTesseract couvre l'intégralité de l'interface synchrone. Pour les charges de travail qui nécessitent véritablement des modèles asynchrones, IronOCR fournit également un guide OCR asynchrone dédié.

Approche Azure Computer Vision

La séquence de configuration d'Azure avant d'écrire tout code OCR :

1. Créez un compte Azure si vous n'en avez pas encore.
2. Accédez au portail Azure et créez une ressource Cognitive Services (ou une ressource Azure AI Services).
3. Sélectionnez un niveau de tarification et une région.
4. Copiez l'URL du point d'accès (format : https://your-resource.cognitiveservices.azure.com/).
5. Copiez l'une des deux clés API.
6. Stockez les deux valeurs en toute sécurité — dans les variables d'environnement, Azure Key Vault, ou appsettings.json (uniquement en non-production).
7. Installez Azure.AI.Vision.ImageAnalysis via NuGet.
8. Initialisez ImageAnalysisClient avec le point d'accès et les informations d'identification.

Pour le traitement PDF, répétez les étapes 2-8 pour une ressource Form Recognizer avec un package NuGet différent (Azure.AI.FormRecognizer) et une classe client différente (DocumentAnalysisClient).

Le appsettings.json stocke le point d'accès et la clé :

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

La rotation des clés API, la gestion de l'expiration des identifiants et la gestion des URL des points de terminaison dans différents environnements (développement, préproduction, production) sont des tâches opérationnelles courantes qui n'ont pas d'équivalent dans le traitement local.

Approche d'IronOCR

Le guide d'installation d'IronTesseract réduit la configuration à deux étapes :

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

La clé de licence est une chaîne de caractères statique. Elle n'expire pas à chaque requête, ne nécessite pas de rotation et n'effectue pas de vérification auprès du serveur d'origine après activation. Les environnements de déploiement ne nécessitent aucune règle de pare-feu sortant pour que l'OCR fonctionne.

Exigences de conformité Bloc de traitement en nuage

Un éditeur de logiciels indépendant (ISV) du secteur de la santé qui développe un système de gestion de documents commence par Azure Computer Vision, car cette solution est rapide à intégrer. Puis arrive le premier client professionnel : un réseau hospitalier dont le responsable de la sécurité HIPAA pose deux questions : " Où vont nos données de santé protégées (PHI) ? " et " Pouvez-vous nous montrer le contrat de partenariat commercial (BAA) couvrant ce tiers ? " Azure dispose d'un BAA, mais la réponse à la première question — " les centres de données Microsoft " — déclenche un long examen de sécurité, une demande des rapports d'audit de Microsoft et un calendrier de mise en conformité qui retarde la signature du contrat. Le passage à IronOCR élimine complètement le problème. Les données de santé protégées (PHI) ne quittent jamais l'environnement du client. Le périmètre de conformité se limite à l'organisation du client.

La croissance du volume rend le tarification à la transaction intenable

Une équipe opérationnelle lance un pipeline de traitement des factures à raison de 5 000 documents par mois, ce qui reste largement dans les limites du niveau gratuit d'Azure. Au fur et à mesure que le volume augmente, les coûts par transaction s'accumulent avec chaque document traité. IronOCR Professional ($2,999) est un achat unique sans frais par document. Les équipes qui prévoient une croissance même modérée de leur volume atteignent rapidement le seuil de rentabilité, après quoi chaque document supplémentaire représente une économie.

La latence du réseau affecte les SLA de traitement

Un service de traitement de documents vise un SLA de bout en bout de 2 secondes. Azure Computer Visionajoute une latence réseau de 200 à 800 ms pour les appels au sein d'une même région et de 500 à 2 000 ms pour les déploiements interrégionaux — avant le calcul OCR proprement dit. Sous charge, la limite de 10 TPS sur S1 force la mise en file d'attente, ce qui augmente encore la latence. IronOCR traite une image unique de 300 DPI en 100 à 400 ms sur du matériel serveur standard, sans file d'attente, sans limite de débit et sans saut de réseau. Le SLA devient prévisible car il dépend uniquement du matériel, et non de l'état du service Azure ou des conditions du réseau.

Exigences relatives à l'infrastructure en mode air-gapped

Les sous-traitants du secteur de la défense, les agences de renseignement et les opérateurs d'infrastructures critiques exécutent des charges de travail sur des réseaux conçus pour ne pas être connectés à Internet. Azure Computer Visionest techniquement incompatible avec ces environnements — le point de terminaison est inaccessible. Les équipes de ces secteurs ont besoin d'une bibliothèque qui se déploie sous forme de binaire autonome, fonctionne sans aucune connexion sortante et satisfait aux contrôles de sécurité interdisant explicitement la transmission de données vers le cloud. Le déploiement sous Linux et la prise en charge de Docker d'IronOCR permettent de le déployer dans des environnements restreints sans modification.

Simplification du déploiement multi-environnements

Une équipe gérant les environnements de développement, de préproduction et de production pour une application SaaS dispose de trois ressources Azure Cognitive Services, de trois jeux de clés API et de trois URL de point de terminaison — chacun nécessitant un stockage sécurisé, des politiques de rotation et une configuration spécifique à l'environnement. Chaque environnement de déploiement nécessite un accès réseau sortant vers Azure. IronOCR réduit la configuration par environnement à une variable d'environnement (IRONOCR_LICENSE), élimine la nécessité d'accès au réseau, et supprime la surcharge opérationnelle de la gestion des informations d'identification à travers les environnements.

Modèle asynchrone vers synchrone

Le code consomateur Azure est async par nécessité. IronOCR ne nécessite pas d'async, mais la transition est mécanique. Remplacez les types de retour async Task<string> par string, retirez les mots clés await et async, et supprimez la boucle de nouvelle tentative. Si la méthode d'appel est un contrôleur ou un service ASP.NET qui doit rester async, enveloppez l'appel IronOCR dans Task.Run :

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

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

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

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

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

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

Imports System.IO
Imports System.Threading.Tasks
Imports System.Linq

' Before: Azure async chain
Public Async Function ReadTextAsync(imagePath As String) As Task(Of String)
    Using stream = File.OpenRead(imagePath)
        Dim data = BinaryData.FromStream(stream)
        Dim result = Await _client.AnalyzeAsync(data, VisualFeatures.Read)
        Return String.Join(vbLf, result.Value.Read.Blocks _
            .SelectMany(Function(b) b.Lines) _
            .Select(Function(l) l.Text))
    End Using
End Function

' After: IronOCR synchronous
Public Function ReadText(imagePath As String) As String
    Return New IronTesseract().Read(imagePath).Text
End Function

' If async signature must be preserved for interface compatibility
Public Function ReadTextAsync(imagePath As String) As Task(Of String)
    Return Task.Run(Function() New IronTesseract().Read(imagePath).Text)
End Function

Normalisation de l'échelle de confiance

Azure Computer Vision renvoie la confiance des mots sous forme de float entre 0 et 1. IronOCR renvoie la confiance sous forme de double sur une échelle de 0-100. Tout code qui se base sur les valeurs de confiance Azure doit être ajusté :

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

La documentation de référence de l'API OcrResult répertorie toutes les propriétés des résultats, y compris l'échelle de confiance. Le guide pratique sur les scores de confiance couvre la sélection des seuils et l'interprétation par élément.

Consolidation des services de traitement de PDF

Azure répartit l'OCR d'images et l'OCR de PDF entre deux services distincts, avec des clients, des packages NuGet et des configurations de points de terminaison distincts. La migration signifie consolider les deux chemins dans une seule instance IronTesseract. La méthode OcrInput.LoadPdf accepte un chemin de fichier, un flux, ou un tableau d'octets, avec un paramètre Password optionnel pour les fichiers chiffrés — pas besoin d'un second client :

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

// Sortie PDF consultable — 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);

// Sortie PDF consultable — no manual construction
pdfResult.SaveAsSearchablePdf("searchable-output.pdf");

Imports IronOcr

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

' After: One IronTesseract instance handles both
Dim ocr As New IronTesseract()

' Image
Dim imageResult = ocr.Read("document.jpg")

' PDF (same client, same Read method)
Using pdfInput As New OcrInput()
    pdfInput.LoadPdf("document.pdf")
    Dim pdfResult = ocr.Read(pdfInput)

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

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

Le guide d'entrée PDF couvre la sélection de plages de pages, l'entrée de flux et le pipeline de rendu PDF natif. Pour les entrées d'images, consultez le guide d'entrée d'images.

Extraction de données structurées sans Form Recognizer

Les équipes utilisant les modèles préconstruits de Form Recognizer (factures, reçus, documents d'identité) pour l'extraction de champs doivent reproduire cette logique d'extraction dans IronOCR en utilisant l'OCR basé sur la région avec CropRectangle. L'extraction positionnelle est explicite plutôt que basée sur un modèle :

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

Le guide OCR basé sur la région couvre l'utilisation de CropRectangle en détail. Pour les workflows spécifiques aux factures, le tutoriel sur l'OCR des factures présente le modèle d'extraction complet.