Une comparaison entre IronOCR et Aspose.OCR

Le problème du cycle de vie du moteur

Chaque appel OCR d'Asprise nécessite une gestion explicite du moteur. Le processus comporte quatre étapes obligatoires : configuration globale statique, création d'une instance, démarrage du moteur avec une chaîne de caractères de langue et arrêt du moteur une fois l'opération terminée. Ignorer l'arrêt du moteur entraîne des fuites de ressources natives car le ramasse-miettes ne peut pas libérer la mémoire non gérée :

// Asprise: four required steps before reading a single image
Ocr.SetUp();                              // Static global init
Ocr ocr = new Ocr();
try
{
    ocr.StartEngine("eng", Ocr.SPEED_FAST);   // Allocates native engine
    string text = ocr.Recognize(
        imagePath,
        Ocr.RECOGNIZE_TYPE_TEXT,
        Ocr.OUTPUT_FORMAT_PLAINTEXT);
    return text;
}
finally
{
    ocr.StopEngine();                         // Must call — no IDisposable fallback
}

// Asprise: four required steps before reading a single image
Ocr.SetUp();                              // Static global init
Ocr ocr = new Ocr();
try
{
    ocr.StartEngine("eng", Ocr.SPEED_FAST);   // Allocates native engine
    string text = ocr.Recognize(
        imagePath,
        Ocr.RECOGNIZE_TYPE_TEXT,
        Ocr.OUTPUT_FORMAT_PLAINTEXT);
    return text;
}
finally
{
    ocr.StopEngine();                         // Must call — no IDisposable fallback
}

' Asprise: four required steps before reading a single image
Ocr.SetUp()                              ' Static global init
Dim ocr As New Ocr()
Try
    ocr.StartEngine("eng", Ocr.SPEED_FAST)   ' Allocates native engine
    Dim text As String = ocr.Recognize( _
        imagePath, _
        Ocr.RECOGNIZE_TYPE_TEXT, _
        Ocr.OUTPUT_FORMAT_PLAINTEXT)
    Return text
Finally
    ocr.StopEngine()                         ' Must call — no IDisposable fallback
End Try

Ce schéma échoue silencieusement dans trois situations courantes : une exception non gérée avant que StopEngine() ne soit appelée, un chemin de code refactorisé qui ignore le nettoyage et une utilisation concurrente sur LITE/STANDARD où la licence interdit le threading qui permettrait même le parallélisme. Le bloc finally atténue le premier problème, mais la restriction de la licence rend le schéma caduc pour les charges de travail serveur de toute façon.

Comparaison détaillée des fonctionnalités

Approche d'entreprise

Asprise assure la communication entre le code .NETmanagé et son moteur OCR non managé via le marshaling P/Invoke. La source asprise-vs-ironocr-examples.cs montre le mécanisme sous-jacent :

// Asprise interop layer — bridging managed C# to native OCR engine
[DllImport("aocr.dll")]
private static extern IntPtr OCR(string imagePath, int type);

public string ExtractText(string imagePath)
{
    // P/Invoke call into unmanaged DLL
    IntPtr result = OCR(imagePath, 0);
    return Marshal.PtrToStringAnsi(result);  // Manual string marshal
}

// Asprise interop layer — bridging managed C# to native OCR engine
[DllImport("aocr.dll")]
private static extern IntPtr OCR(string imagePath, int type);

public string ExtractText(string imagePath)
{
    // P/Invoke call into unmanaged DLL
    IntPtr result = OCR(imagePath, 0);
    return Marshal.PtrToStringAnsi(result);  // Manual string marshal
}

Imports System.Runtime.InteropServices

' Asprise interop layer — bridging managed VB.NET to native OCR engine
Private Class OCRInterop
    <DllImport("aocr.dll")>
    Private Shared Function OCR(imagePath As String, type As Integer) As IntPtr
    End Function

    Public Function ExtractText(imagePath As String) As String
        ' P/Invoke call into unmanaged DLL
        Dim result As IntPtr = OCR(imagePath, 0)
        Return Marshal.PtrToStringAnsi(result)  ' Manual string marshal
    End Function
End Class

Au niveau de l'API de plus haut niveau, les développeurs font appel au même pont via un wrapper de classe, mais l'exigence de déploiement ne change pas : chaque machine cible a besoin du binaire natif correct, dans le bon chemin, correspondant à l'architecture de processus correcte. Un déploiement 64 bits qui expédie avec aocr.dll au lieu de aocr_x64.dll lance un BadImageFormatException au moment de l'exécution. Un conteneur DockerLinux sans libaocr.so dans LD_LIBRARY_PATH lance DllNotFoundException. Aucune des deux erreurs n'est détectée lors de la compilation.

Approche d'IronOCR

IronOCR s'installe sous forme d'une seule référence NuGet . Le package gère toutes les dépendances natives en interne via le mécanisme de sélection de packages spécifique à la plateforme de NuGet :

// Installation — one command, all platforms
// dotnet add package IronOcr

// License setup
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

// Basic OCR — no native binary setup, no tessdata, no config files
var text = new IronTesseract().Read("document.jpg").Text;

// Installation — one command, all platforms
// dotnet add package IronOcr

// License setup
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

// Basic OCR — no native binary setup, no tessdata, no config files
var text = new IronTesseract().Read("document.jpg").Text;

Imports IronOcr

' Installation — one command, all platforms
' dotnet add package IronOcr

' License setup
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"

' Basic OCR — no native binary setup, no tessdata, no config files
Dim text As String = New IronTesseract().Read("document.jpg").Text

L'instruction using sur OcrInput remplace les appels manuels de cycle de vie du moteur. Il n'y a aucun StartEngine() à appeler et aucun StopEngine() à oublier. Le ramasse-miettes et le modèle IDisposable gèrent correctement le nettoyage dans les scénarios d'exception sans nécessiter d'échafaudage try/finally autour de chaque appel OCR.

Pour des instructions d'installation détaillées, consultez le guide d'installation d'IronTesseract .

Approche d'entreprise

Les licences Lite et STANDARD interdisent explicitement l'exécution multithread et multiprocessus. Tout code appelant Asprise depuis plusieurs threads simultanément enfreint le contrat de licence relatif à ces niveaux. ASP.NET Core traite par défaut les requêtes sur un pool de threads. Cela fait de chaque contrôleur d'API Web standard qui appelle Asprise une violation de licence sur Lite/STANDARD :

// ASPRISE LITE/STANDARD — violates license in ASP.NET Core context
// Web server thread pool = multiple concurrent threads = prohibited
[ApiController]
public class OcrController : ControllerBase
{
    [HttpPost("extract")]
    public IActionResult ExtractText(IFormFile file)
    {
        // Two concurrent requests = two threads = license violation
        var ocr = new Ocr();
        ocr.StartEngine("eng", Ocr.SPEED_FAST);
        var text = ocr.Recognize(tempPath, Ocr.RECOGNIZE_TYPE_TEXT, Ocr.OUTPUT_FORMAT_PLAINTEXT);
        ocr.StopEngine();
        return Ok(text);
    }
}

// ASPRISE LITE/STANDARD — violates license in ASP.NET Core context
// Web server thread pool = multiple concurrent threads = prohibited
[ApiController]
public class OcrController : ControllerBase
{
    [HttpPost("extract")]
    public IActionResult ExtractText(IFormFile file)
    {
        // Two concurrent requests = two threads = license violation
        var ocr = new Ocr();
        ocr.StartEngine("eng", Ocr.SPEED_FAST);
        var text = ocr.Recognize(tempPath, Ocr.RECOGNIZE_TYPE_TEXT, Ocr.OUTPUT_FORMAT_PLAINTEXT);
        ocr.StopEngine();
        return Ok(text);
    }
}

Imports Microsoft.AspNetCore.Mvc

' ASPRISE LITE/STANDARD — violates license in ASP.NET Core context
' Web server thread pool = multiple concurrent threads = prohibited
<ApiController>
Public Class OcrController
    Inherits ControllerBase

    <HttpPost("extract")>
    Public Function ExtractText(file As IFormFile) As IActionResult
        ' Two concurrent requests = two threads = license violation
        Dim ocr As New Ocr()
        ocr.StartEngine("eng", Ocr.SPEED_FAST)
        Dim text As String = ocr.Recognize(tempPath, Ocr.RECOGNIZE_TYPE_TEXT, Ocr.OUTPUT_FORMAT_PLAINTEXT)
        ocr.StopEngine()
        Return Ok(text)
    End Function
End Class

Le traitement par lots sur Lite/STANDARD est forcé en mode séquentiel quel que soit le nombre de cœurs de processeur disponibles :

// ASPRISE LITE/STANDARD — sequential only (100 docs at 2 sec each = 3+ minutes)
Ocr.SetUp();
Ocr ocr = new Ocr();
try
{
    ocr.StartEngine("eng", Ocr.SPEED_FAST);
    foreach (var path in imagePaths)  // Cannot use Parallel.ForEach — license violation
    {
        string text = ocr.Recognize(path, Ocr.RECOGNIZE_TYPE_TEXT, Ocr.OUTPUT_FORMAT_PLAINTEXT);
        results.Add(text);
    }
}
finally
{
    ocr.StopEngine();
}

// ASPRISE LITE/STANDARD — sequential only (100 docs at 2 sec each = 3+ minutes)
Ocr.SetUp();
Ocr ocr = new Ocr();
try
{
    ocr.StartEngine("eng", Ocr.SPEED_FAST);
    foreach (var path in imagePaths)  // Cannot use Parallel.ForEach — license violation
    {
        string text = ocr.Recognize(path, Ocr.RECOGNIZE_TYPE_TEXT, Ocr.OUTPUT_FORMAT_PLAINTEXT);
        results.Add(text);
    }
}
finally
{
    ocr.StopEngine();
}

' ASPRISE LITE/STANDARD — sequential only (100 docs at 2 sec each = 3+ minutes)
Ocr.SetUp()
Dim ocr As New Ocr()
Try
    ocr.StartEngine("eng", Ocr.SPEED_FAST)
    For Each path In imagePaths ' Cannot use Parallel.ForEach — license violation
        Dim text As String = ocr.Recognize(path, Ocr.RECOGNIZE_TYPE_TEXT, Ocr.OUTPUT_FORMAT_PLAINTEXT)
        results.Add(text)
    Next
Finally
    ocr.StopEngine()
End Try

ENTERPRISE supprime la limitation de thread, mais ENTERPRISE nécessite de contacter les ventes d'Asprise avec un prix non publié.

Approche d'IronOCR

IronTesseract est thread-safe et ne comporte aucune restriction de threading sur aucun niveau de licence. Le traitement par lots parallèle sur une licence $999 Lite est entièrement pris en charge :

// IronOCR — parallel batch on any license tier
// 100 docs at 2 sec each, 8 cores = ~25 seconds vs 200 seconds sequential
var results = imagePaths
    .AsParallel()
    .Select(path => new IronTesseract().Read(path).Text)
    .ToList();

// IronOCR — parallel batch on any license tier
// 100 docs at 2 sec each, 8 cores = ~25 seconds vs 200 seconds sequential
var results = imagePaths
    .AsParallel()
    .Select(path => new IronTesseract().Read(path).Text)
    .ToList();

Imports System.Linq

' IronOCR — parallel batch on any license tier
' 100 docs at 2 sec each, 8 cores = ~25 seconds vs 200 seconds sequential
Dim results = imagePaths _
    .AsParallel() _
    .Select(Function(path) (New IronTesseract()).Read(path).Text) _
    .ToList()

Les contrôleurs ASP.NET Core fonctionnent sans configuration particulière :

// IronOCR — concurrent requests on any license tier
[ApiController]
public class OcrController : ControllerBase
{
    [HttpPost("extract")]
    public IActionResult ExtractText(IFormFile file)
    {
        // Thread-safe on Lite, Plus, Professional, Unlimited — all tiers
        var text = new IronTesseract().Read(tempPath).Text;
        return Ok(text);
    }
}

// IronOCR — concurrent requests on any license tier
[ApiController]
public class OcrController : ControllerBase
{
    [HttpPost("extract")]
    public IActionResult ExtractText(IFormFile file)
    {
        // Thread-safe on Lite, Plus, Professional, Unlimited — all tiers
        var text = new IronTesseract().Read(tempPath).Text;
        return Ok(text);
    }
}

Imports Microsoft.AspNetCore.Mvc

<ApiController>
Public Class OcrController
    Inherits ControllerBase

    <HttpPost("extract")>
    Public Function ExtractText(file As IFormFile) As IActionResult
        ' Thread-safe on Lite, Plus, Professional, Unlimited — all tiers
        Dim text = New IronTesseract().Read(tempPath).Text
        Return Ok(text)
    End Function
End Class

Consultez l' exemple de multithreading pour les modèles de débit parallèle dans les charges de travail par lots.

Approche d'entreprise

Le prétraitement nécessite une bibliothèque d'images externe. Un développeur travaillant avec Asprise ajoute une dépendance telle que ImageMagick, SkiaSharp ou System.Drawing, exécute manuellement les opérations de prétraitement, enregistre l'image traitée dans un fichier temporaire, puis transmet ce fichier à Asprise :

// Asprise preprocessing: external dependency required
// 1. Load with external library
// 2. Apply corrections (deskew, denoise, contrast) with external library
// 3. Save to temp file
// 4. Pass temp file to Asprise

var ocr = new Ocr();
ocr.StartEngine("eng", Ocr.SPEED_FAST);
// preprocessedImagePath comes from your external preprocessing pipeline
string text = ocr.Recognize(preprocessedImagePath, Ocr.RECOGNIZE_TYPE_TEXT, Ocr.OUTPUT_FORMAT_PLAINTEXT);
ocr.StopEngine();

// Asprise preprocessing: external dependency required
// 1. Load with external library
// 2. Apply corrections (deskew, denoise, contrast) with external library
// 3. Save to temp file
// 4. Pass temp file to Asprise

var ocr = new Ocr();
ocr.StartEngine("eng", Ocr.SPEED_FAST);
// preprocessedImagePath comes from your external preprocessing pipeline
string text = ocr.Recognize(preprocessedImagePath, Ocr.RECOGNIZE_TYPE_TEXT, Ocr.OUTPUT_FORMAT_PLAINTEXT);
ocr.StopEngine();

' Asprise preprocessing: external dependency required
' 1. Load with external library
' 2. Apply corrections (deskew, denoise, contrast) with external library
' 3. Save to temp file
' 4. Pass temp file to Asprise

Dim ocr As New Ocr()
ocr.StartEngine("eng", Ocr.SPEED_FAST)
' preprocessedImagePath comes from your external preprocessing pipeline
Dim text As String = ocr.Recognize(preprocessedImagePath, Ocr.RECOGNIZE_TYPE_TEXT, Ocr.OUTPUT_FORMAT_PLAINTEXT)
ocr.StopEngine()

Cela ajoute une dépendance de compilation, une surcharge d'exécution due à la bibliothèque supplémentaire et exige que le développeur comprenne suffisamment bien le traitement d'images pour mettre en œuvre des corrections efficaces.

Approche d'IronOCR

Le prétraitement est intégré dans OcrInput. Le même pipeline qui nécessitait 50 à 100 lignes avec une bibliothèque externe et un réglage précis des paramètres se réduit désormais à cinq appels de méthode :

// IronOCR — preprocessing built in, no external dependencies
using var input = new OcrInput();
input.LoadImage("low-quality-scan.jpg");
input.Deskew();               // Correct page rotation
input.DeNoise();              // Remove scanner artifacts
input.Contrast();             // Improve text/background separation
input.Binarize();             // Convert to black/white for cleaner engine input
input.EnhanceResolution(300); // Scale to optimal DPI

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

// IronOCR — preprocessing built in, no external dependencies
using var input = new OcrInput();
input.LoadImage("low-quality-scan.jpg");
input.Deskew();               // Correct page rotation
input.DeNoise();              // Remove scanner artifacts
input.Contrast();             // Improve text/background separation
input.Binarize();             // Convert to black/white for cleaner engine input
input.EnhanceResolution(300); // Scale to optimal DPI

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

Imports IronOcr

' IronOCR — preprocessing built in, no external dependencies
Using input As New OcrInput()
    input.LoadImage("low-quality-scan.jpg")
    input.Deskew()               ' Correct page rotation
    input.DeNoise()              ' Remove scanner artifacts
    input.Contrast()             ' Improve text/background separation
    input.Binarize()             ' Convert to black/white for cleaner engine input
    input.EnhanceResolution(300) ' Scale to optimal DPI

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

Pour les numérisations où la rotation est imprévisible, la correction automatique de l'angle de rotation gère les angles arbitraires sans que le développeur ait besoin de détecter ou de spécifier les valeurs de rotation. Le guide de correction de la qualité d'image couvre l'ensemble des filtres et explique quand appliquer chacun d'eux.

Approche d'entreprise

// Asprise PDF workaround — external library required to render PDF pages
var images = ExternalPdfLibrary.RenderPages("invoice.pdf");

Ocr.SetUp();
Ocr ocr = new Ocr();
try
{
    ocr.StartEngine("eng", Ocr.SPEED_FAST);
    var allText = new System.Text.StringBuilder();
    foreach (var imagePath in images)
    {
        string pageText = ocr.Recognize(imagePath, Ocr.RECOGNIZE_TYPE_TEXT, Ocr.OUTPUT_FORMAT_PLAINTEXT);
        allText.Append(pageText);
    }
    return allText.ToString();
}
finally
{
    ocr.StopEngine();
}
// Also: clean up temp image files

// Asprise PDF workaround — external library required to render PDF pages
var images = ExternalPdfLibrary.RenderPages("invoice.pdf");

Ocr.SetUp();
Ocr ocr = new Ocr();
try
{
    ocr.StartEngine("eng", Ocr.SPEED_FAST);
    var allText = new System.Text.StringBuilder();
    foreach (var imagePath in images)
    {
        string pageText = ocr.Recognize(imagePath, Ocr.RECOGNIZE_TYPE_TEXT, Ocr.OUTPUT_FORMAT_PLAINTEXT);
        allText.Append(pageText);
    }
    return allText.ToString();
}
finally
{
    ocr.StopEngine();
}
// Also: clean up temp image files

Imports System.Text

' Asprise PDF workaround — external library required to render PDF pages
Dim images = ExternalPdfLibrary.RenderPages("invoice.pdf")

Ocr.SetUp()
Dim ocr As New Ocr()
Try
    ocr.StartEngine("eng", Ocr.SPEED_FAST)
    Dim allText As New StringBuilder()
    For Each imagePath In images
        Dim pageText As String = ocr.Recognize(imagePath, Ocr.RECOGNIZE_TYPE_TEXT, Ocr.OUTPUT_FORMAT_PLAINTEXT)
        allText.Append(pageText)
    Next
    Return allText.ToString()
Finally
    ocr.StopEngine()
End Try
' Also: clean up temp image files

Cette approche ajoute une dépendance au rendu PDF (généralement iText, PDFSharp ou un moteur commercial), nécessite une gestion des fichiers temporaires, et perd les métadonnées et la structure PDF qu'un lecteur PDF natif préserverait. Les fichiers PDF protégés par mot de passe nécessitent un troisième élément.

Approche d'IronOCR

IronOCR lit directement les fichiers PDF. La méthode OcrInput.LoadPdf() gère le rendu en interne, y compris les documents multipages et les fichiers protégés par mot de passe :

// IronOCR — native PDF input, no external rendering library
using var input = new OcrInput();
input.LoadPdf("invoice.pdf");
var result = new IronTesseract().Read(input);
Console.WriteLine(result.Text);

// Password-protected PDFs — same API, one parameter
using var secureInput = new OcrInput();
secureInput.LoadPdf("confidential.pdf", Password: "secret");
var secureResult = new IronTesseract().Read(secureInput);

// Generate searchable PDF from a scanned document
var scanResult = new IronTesseract().Read("scanned-contract.pdf");
scanResult.SaveAsSearchablePdf("searchable-contract.pdf");

// IronOCR — native PDF input, no external rendering library
using var input = new OcrInput();
input.LoadPdf("invoice.pdf");
var result = new IronTesseract().Read(input);
Console.WriteLine(result.Text);

// Password-protected PDFs — same API, one parameter
using var secureInput = new OcrInput();
secureInput.LoadPdf("confidential.pdf", Password: "secret");
var secureResult = new IronTesseract().Read(secureInput);

// Generate searchable PDF from a scanned document
var scanResult = new IronTesseract().Read("scanned-contract.pdf");
scanResult.SaveAsSearchablePdf("searchable-contract.pdf");

Imports IronOcr

' IronOCR — native PDF input, no external rendering library
Using input As New OcrInput()
    input.LoadPdf("invoice.pdf")
    Dim result = New IronTesseract().Read(input)
    Console.WriteLine(result.Text)
End Using

' Password-protected PDFs — same API, one parameter
Using secureInput As New OcrInput()
    secureInput.LoadPdf("confidential.pdf", Password:="secret")
    Dim secureResult = New IronTesseract().Read(secureInput)
End Using

' Generate searchable PDF from a scanned document
Dim scanResult = New IronTesseract().Read("scanned-contract.pdf")
scanResult.SaveAsSearchablePdf("searchable-contract.pdf")

Le guide OCR PDF aborde la sélection de la plage de pages, la gestion des types de PDF mixtes et la sortie de PDF consultables pour les flux de travail d'archivage.

Le bloqueur de préparation à la production

La restriction du nombre de threads constitue un obstacle majeur pour la plupart des charges de travail .NETen production. Une équipe développe une fonctionnalité OCR à l'aide d'Asprise Lite — les tests monothread sont concluants, tout fonctionne. Ensuite, la fonctionnalité est déployée dans un environnement de test derrière une API ASP.NET Core , des requêtes de test simultanées arrivent et l'application génère des erreurs ou fonctionne dans un état techniquement non conforme. La solution consiste soit à passer à la Enterprise (avec les coûts et l'implication commerciale que cela implique), soit à remplacer la bibliothèque. Les équipes qui atteignent ce stade lors de la phase de préproduction plutôt qu'en production sont chanceuses ; Ceux qui le découvrent après son lancement sont confrontés à une migration plus urgente. IronOCR élimine toute cette classe de problème — la licence $999 Lite prend en charge le traitement des requêtes concurrentes, le traitement parallèle par lots, les services Windows et les fonctions cloud sans restriction.

La taxe sur la complexité du déploiement

Les équipes qui travaillent dans des environnements de déploiement modernes (conteneurs Docker, machines virtuelles Linux, pods Kubernetes) paient avec Asprise des frais de maintenance continus qui n'existent pas avec les packages NuGet purs. Chaque image de conteneur doit inclure le binaire natif approprié pour l'architecture cible. Chaque pipeline CI/CD ciblant plusieurs plateformes doit gérer l'inclusion de fichiers spécifiques à chaque plateforme. L'absence d'une bibliothèque native sur un conteneur Linuxde production est une découverte lors de l'exécution, et non une erreur de compilation. Les équipes qui ont passé des heures à déboguer une DLL 32 bits chargée dans un processus 64 bits comprennent concrètement le coût. Le déploiement d'IronOCR basé exclusivement sur NuGet élimine toute cette catégorie d'échec de déploiement.

Le problème de la documentation Java

Les équipes qui développent des applications .NETont besoin d'exemples en C#, et non en Java. La documentation principale d'Asprise, ses références API et ses ressources communautaires sont destinées aux développeurs Java. Un développeur .NETqui consulte la documentation Asprise traduit la syntaxe Java, les conventions des packages Javaet les modèles spécifiques à Javaen équivalents C# — et parfois la traduction n'est pas directe car le wrapper .NETn'expose pas toutes les fonctionnalités côté Java. La documentation, les tutoriels et les exemples de code d'IronOCR sont rédigés pour les développeurs C#. Le tutoriel sur la lecture de texte à partir d'images et le centre de tutoriels complet fournissent des exemples C# fonctionnels pour chaque fonctionnalité, sans surcharge de traduction.

Le fossé du pipeline PDF

Les équipes qui traitent des documents numérisés, des factures, des contrats ou des formulaires au format PDF ne peuvent pas utiliser Asprise sans ajouter une bibliothèque de rendu PDF à leur graphe de dépendances. Cette bibliothèque de rendu introduit ses propres considérations de licence, une charge de maintenance supplémentaire et des incompatibilités potentielles. Pour les équipes qui ont besoin de l'OCR et du PDF dans une seule et même solution, IronOCR gère les deux nativement. La possibilité de créer des PDF consultables à partir de données numérisées — une exigence courante pour les flux de travail d'archivage et de conformité — n'a pas d'équivalent dans Asprise, quel que soit le niveau de licence.

Le déficit de couverture linguistique

Asprise prend en charge plus de 20 langues OCR. IronOCR prend en charge plus de 125 technologies, chacune installable en tant que package NuGet indépendant. Les équipes traitant des documents en arabe, en hindi, en thaï ou dans l'une des dizaines d'autres langues prises en charge par IronOCR mais non par Asprise ne peuvent pas bénéficier du support multilingue via Asprise. Le guide multilingue explique comment installer et combiner les modules linguistiques, y compris la reconnaissance simultanée de plusieurs systèmes d'écriture.

Remplacement du code de cycle de vie du moteur

Le plus grand changement mécanique de la migration consiste à supprimer le modèle de cycle de vie du moteur Asprise et à le remplacer par une instanciation directe IronTesseract. Chaque occurrence de la séquence SetUp() / StartEngine() / Recognize() / StopEngine() devient un seul appel Read() :

// Before: Asprise lifecycle (15 lines, manual cleanup)
Ocr.SetUp();
Ocr ocr = new Ocr();
try
{
    ocr.StartEngine("eng", Ocr.SPEED_FAST);
    string text = ocr.Recognize(
        imagePath,
        Ocr.RECOGNIZE_TYPE_TEXT,
        Ocr.OUTPUT_FORMAT_PLAINTEXT);
    return text;
}
finally
{
    ocr.StopEngine();
}

// After: IronOCR (1 line)
return new IronTesseract().Read(imagePath).Text;

// Before: Asprise lifecycle (15 lines, manual cleanup)
Ocr.SetUp();
Ocr ocr = new Ocr();
try
{
    ocr.StartEngine("eng", Ocr.SPEED_FAST);
    string text = ocr.Recognize(
        imagePath,
        Ocr.RECOGNIZE_TYPE_TEXT,
        Ocr.OUTPUT_FORMAT_PLAINTEXT);
    return text;
}
finally
{
    ocr.StopEngine();
}

// After: IronOCR (1 line)
return new IronTesseract().Read(imagePath).Text;

' Before: Asprise lifecycle (15 lines, manual cleanup)
Ocr.SetUp()
Dim ocr As New Ocr()
Try
    ocr.StartEngine("eng", Ocr.SPEED_FAST)
    Dim text As String = ocr.Recognize( _
        imagePath, _
        Ocr.RECOGNIZE_TYPE_TEXT, _
        Ocr.OUTPUT_FORMAT_PLAINTEXT)
    Return text
Finally
    ocr.StopEngine()
End Try

' After: IronOCR (1 line)
Return New IronTesseract().Read(imagePath).Text

Pour un code sensible aux performances qui traite de nombreux documents de manière séquentielle, réutilisez l'instance IronTesseract plutôt que d'en créer une nouvelle par appel — l'initialisation du moteur entraîne des frais généraux, et une seule instance utilisée séquentiellement est plus efficace que d'en créer et en supprimer une par document.

Remplacement des codes de langage basés sur des chaînes de caractères

Asprise utilise des paramètres de chaîne pour la sélection des langues ("eng", "fra", "eng+fra"). IronOCR utilise un OcrLanguage enum fortement typé avec une API de langue secondaire. Le guide multilingue répertorie les identifiants de langue disponibles et les packages NuGet requis pour chacun :

// Before: Asprise string-based language
ocr.StartEngine("eng+fra", Ocr.SPEED_FAST);

// After: IronOCR strongly-typed language enum
var ocr = new IronTesseract();
ocr.Language = OcrLanguage.English;
ocr.AddSecondaryLanguage(OcrLanguage.French);
var result = ocr.Read(imagePath);

// Before: Asprise string-based language
ocr.StartEngine("eng+fra", Ocr.SPEED_FAST);

// After: IronOCR strongly-typed language enum
var ocr = new IronTesseract();
ocr.Language = OcrLanguage.English;
ocr.AddSecondaryLanguage(OcrLanguage.French);
var result = ocr.Read(imagePath);

Imports IronOcr

' Before: Asprise string-based language
ocr.StartEngine("eng+fra", Ocr.SPEED_FAST)

' After: IronOCR strongly-typed language enum
Dim ocr As New IronTesseract()
ocr.Language = OcrLanguage.English
ocr.AddSecondaryLanguage(OcrLanguage.French)
Dim result = ocr.Read(imagePath)

Remplacement des vérifications de chaînes d'erreur

Asprise renvoie null ou une chaîne de caractères préfixée par une erreur en cas d'échec de la reconnaissance. IronOCR génère des exceptions .NET. Remplacez les vérifications de null et de préfixe de chaîne par des blocs try/catch standards. Cela aligne la gestion des erreurs OCR avec le reste du modèle de gestion des exceptions .NETet donne accès aux traces de pile complètes et aux hiérarchies de types d'exceptions plutôt qu'aux chaînes d'erreur analysées.

Activation du traitement parallèle

Après la migration, les boucles de traitement par lots foreach existantes peuvent être converties en Parallel.ForEach ou PLINQ sans aucun souci de licence. Pour les lots de documents qui étaient auparavant traités séquentiellement sur Lite/STANDARD, le parallélisme est un multiplicateur de débit direct. Le guide sur l'OCR asynchrone couvre les modèles asynchrones pour les contextes d'applications Web où l'OCR non bloquant est préférable à la saturation du pool de threads.