IRONSOFTWAREHOME
IRONSUITETous les 10 pour le prix de 2
ÉDITION DE DOCUMENTS
IMAGERIE & RECONNAISSANCE
RESSOURCES D'APPROVISIONNEMENT
CONTACTER LES VENTES
PAR ENTREPRISE
REJOIGNEZ NOTRE RÉSEAU D'EXPERTS
VIDÉOS

Migration de Syncfusion OCR vers IronOCR

Kannaopat Udonpant
Kannapat Udonpant
Updated: 1 août 2026

Ce guide présente la migration complète de OCR Syncfusion Processor vers IronOCR for .NET pour les développeurs .NET qui ont besoin d'extraire du texte à partir de documents numérisés et de fichiers PDF. Cela couvre les modifications spécifiques de configuration, les réécritures de code et le nettoyage de déploiement nécessaires pour remplacer Syncfusion.PDF.OCR.Net.Core par le package NuGet IronOcr, en se concentrant particulièrement sur l'élimination de la gestion des fichiers tessdata et la configuration du chemin binaire Tesseract que chaque déploiement OCR de Syncfusion nécessite.

Pourquoi migrer depuis Syncfusion OCR

Syncfusion OCR est un wrapper Tesseract intégré à une suite de 1 600 composants. Pour les équipes dont la seule exigence est l'extraction de texte, cette architecture crée des frictions à tous les niveaux : configuration, déploiement, maintenance et gestion des licences.

Le dossier tessdata suit chaque environnement. Chaque poste de travail développeur, coureur CI, serveur de mise en scène et conteneur de production a besoin d'un répertoire tessdata contenant des fichiers .traineddata pour chaque langue utilisée par l'application. En anglais seul, cela représente 23 Mo pour le modèle standard ou 94 Mo pour le meilleur modèle LSTM. Une application en cinq langues ajoute 100 à 500 Mo à chaque artefact de déploiement. Ce dossier doit être à l'emplacement exact que le constructeur OCRProcessor attend ou l'application génère une erreur immédiatement au démarrage. Ce n'est pas un coût de configuration unique — c'est un coût opérationnel récurrent qui apparaît chaque fois qu'un nouvel environnement est provisionné.

La configuration du chemin binaire Tesseract se casse à travers les environnements. Le constructeur OCRProcessor requiert un chemin vers le répertoire tessdata qui doit être résolu correctement sur chaque plateforme cible. Le chemin qui fonctionne sur une machine de développement Windows (@"tessdata/") échoue sur un conteneur Linux à moins que le pipeline de déploiement ne copie explicitement le dossier. Les constructions d'image Docker doivent inclure une couche COPY tessdata/ /app/tessdata/. Les pipelines CI doivent automatiser les téléchargements de tessdata. Les environnements isolés doivent gérer la distribution des fichiers binaires séparément de la restauration des paquets NuGet. Chaque environnement ajoute un nouveau risque de discordance de chemin d'accès pouvant entraîner un échec silencieux de l'OCR ou une exception d'exécution.

L'architecture centrée sur le PDF impose une surcharge de conversion pour les entrées d'image. Le OCRProcessor de Syncfusion accepte les objets PdfLoadedDocument, et non les fichiers image. Extraire du texte d'un JPG nécessite de créer un PdfDocument, d'ajouter une page, de dessiner l'image dessus, de sauvegarder sur un MemoryStream, de recharger comme un PdfLoadedDocument, puis d'exécuter l'OCR — neuf opérations avant l'étape de reconnaissance de texte. Ce cycle ajoute une surcharge d'exécution et une complexité de code pour chaque flux de travail OCR basé sur l'image.

Les licences de la Suite créent des événements de conformité déclenchés par la croissance. La licence communautaire Syncfusion exige moins de cinq développeurs, moins de dix employés, un chiffre d'affaires annuel inférieur à 1 million de dollars et un financement externe total inférieur à 3 millions de dollars — toutes ces conditions devant être remplies simultanément. Tout dépassement de ce seuil invalide immédiatement la licence et nécessite une mise à niveau commerciale au prix de 995 à 1 595 dollars par développeur et par an. Une équipe de cinq développeurs utilisant OCR Syncfusion à des fins commerciales depuis trois ans paie entre 14 925 et 23 925 dollars pour la même fonctionnalité d'extraction de texte que celle offerte par IronOCR Professional pour un montant unique de 2 999 dollars.

L'absence de prétraitement intégré implique des dépendances externes pour les numérisations de mauvaise qualité. Sans prétraitement, Tesseract produit des résultats médiocres sur les images pivotées, bruitées ou à faible contraste. Syncfusion ne propose aucune API de prétraitement. Les développeurs qui ont besoin de fonctions de redressement, de débruitage ou de correction du contraste doivent ajouter une bibliothèque d'imagerie distincte (System.Drawing, SkiaSharp, ImageSharp), implémenter les filtres et intégrer la sortie dans le cycle PDF avant que l'OCR puisse commencer. Il s'agit d'une dépendance tierce et de 20 à 40 lignes de code supplémentaires pour une fonctionnalité qu'IronOCR fournit sous forme de méthodes intégrées.

Seul l'OCR est nécessaire, mais toute la suite est sous licence. Syncfusion inclut Syncfusion.Pdf.Net.Core, Syncfusion.Compression.Net.Core et d'autres dépendances transitoires indépendamment des fonctionnalités réellement utilisées. Pour les équipes qui développent un service de traitement de documents spécialisé, ce graphe de dépendances a un impact significatif — en termes de temps de compilation, de taille des images de conteneur et de coût de licence — pour des composants qui n'ont aucune pertinence pour l'extraction de texte.

Le problème fondamental

Syncfusion OCR nécessite la configuration d'un chemin d'accès au système de fichiers tessdata avant qu'un appel OCR ne soit possible :

// Syncfusion: tessdata path required — fails in any environment where this path is wrong
private const string TessDataPath = @"tessdata/";

using var document = new PdfLoadedDocument("scanned-invoice.pdf");
using var processor = new OCRProcessor(TessDataPath);  // throws if path does not resolve
processor.Settings.Language = Languages.English;
processor.PerformOCR(document);

var text = new StringBuilder();
foreach (PdfLoadedPage page in document.Pages)
    text.AppendLine(page.ExtractText());
C#

IronOCR ne nécessite aucune configuration de chemin d'accès. Les données linguistiques sont fournies avec le package :

// IronOCR: no tessdata path, no path configuration, no folder to deploy
var text = new IronTesseract().Read("scanned-invoice.pdf").Text;
C#

IronOCR vs OCR Syncfusion : comparaison des fonctionnalités

Le tableau ci-dessous présente les fonctionnalités les plus importantes pour les équipes qui migrent depuis Syncfusion OCR.

FonctionOCR SyncfusionIronOCR
Paquet NuGetSyncfusion.PDF.OCR.Net.Core (suite)IronOcr (autonome)
tessdata requisOui — téléchargement manuel et configuration du chemin d'accèsNon — intégré en interne
OCR d'image directeNon — nécessite une conversion PDF aller-retourOui — LoadImage() ou chemin directement
OCR direct de PDFOui — modèle d'entrée principalOui — assistance de premier ordre
Prétraitement automatiqueNon — bibliothèque externe requiseOui — redressement, débruitage, contraste, binarisation
Sortie PDF consultableOui — enregistrer après PerformOCR()Oui — result.SaveAsSearchablePdf()
Langues prises en chargePlus de 60 via téléchargement manuel de tessdataPlus de 125 packages de langage disponibles via NuGet
Multilingue simultanéOui — drapeaux bit à bit sur l'énumération LanguagesOui — AddSecondaryLanguage()
OCR basé sur la régionNonOui — CropRectangle
Lecture de codes-barresNonOui — ocr.Configuration.ReadBarCodes = true
Structure de la sortiePages uniquement via page.ExtractText()Pages, paragraphes, lignes, mots, caractères avec coordonnées
Évaluation de la confianceNonOui — result.Confidence et scores par mot
Exportation hOCRNonOui
Entrée de fluxVia flux PDF uniquementEntrée directe en flux continu pour les images et les PDF
Sécurité des threadsNon documenté comme étant thread-safeComplet — une instance IronTesseract par thread
Cross-PlatformOui — mais tessdata doit être résolu sur chaque plateformeOui — NuGet unique, aucune configuration de chemin d'accès
Déploiement DockerNécessite la couche tessdata dans l'imageUn seul package, sans couches supplémentaires
Modèle de licenceAbonnement annuel à la Suite (995 $ – 1 595 $/développeur/an)Perpetual (Lite $999, Pro $1,499, Enterprise $2,999)
Restrictions de la licence communautairePlafonds de chiffre d'affaires, d'effectifs et de financement avec droits d'auditAucune restriction sur l'essai gratuit
Moteur OCRTesseract 5 (wrapper standard)Tesseract 5 optimisé avec des améliorations en matière de précision

Guide de démarrage rapide : migration de OCR Syncfusion vers IronOCR

Étape 1 : Remplacer le package NuGet

Supprimez OCR Syncfusion et tout autre package Syncfusion qui a été intégré uniquement pour la fonctionnalité OCR :

dotnet remove package Syncfusion.PDF.OCR.Net.Core
dotnet remove package Syncfusion.Pdf.Net.Core
dotnet remove package Syncfusion.Compression.Net.Core
SHELL

Installez IronOCR depuis NuGet :

> dotnet add package IronOcr

Étape 2 : Mise à jour des espaces de noms

Remplacer les importations de l'espace de noms Syncfusion par l'espace de noms unique IronOCR :

// Before (Syncfusion)
using Syncfusion.OCRProcessor;
using Syncfusion.PDF;
using Syncfusion.Pdf.Parsing;

// After (IronOCR)
using IronOcr;
C#

Étape 3 : initialisation de la licence

Ajouter l'initialisation de la licence une fois au démarrage de l'application, avant tout appel OCR :

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

Aucune inscription à la suite n'est requise. Aucune vérification de l'éligibilité à une licence communautaire n'est requise. La clé est une chaîne de caractères simple attribuée à une propriété statique.

Exemples de migration de code

Élimination des chemins d'accès Tessdata et initialisation de l'OCR

Les bases de code Syncfusion incluent souvent une logique de validation tessdata — vérifiant que le répertoire existe et que les fichiers .traineddata nécessaires sont présents avant de tenter l'OCR. Ce code de protection existe car l'absence d'un fichier tessdata provoque une exception d'exécution, et les incidents de production causés par des fichiers de langue manquants sont suffisamment fréquents pour que les équipes écrivent des contrôles défensifs.

Approche OCR de Syncfusion :

using Syncfusion.OCRProcessor;
using Syncfusion.Pdf.Parsing;

public class DocumentOcrService
{
    // Path hardcoded — different on every deployment target
    private const string TessDataPath = @"tessdata/";

    private bool ValidateTessdataBeforeUse(string languageCode)
    {
        // Guard required because missing files cause runtime exceptions
        if (!Directory.Exists(TessDataPath))
            throw new InvalidOperationException(
                "tessdata directory not found. Download from github.com/tesseract-ocr/tessdata_best");

        string filePath = Path.Combine(TessDataPath, $"{languageCode}.traineddata");
        if (!File.Exists(filePath))
            throw new InvalidOperationException(
                $"{languageCode}.traineddata not found — file must be downloaded manually");

        return true;
    }

    public string ExtractText(string pdfPath, string languageCode = "eng")
    {
        ValidateTessdataBeforeUse(languageCode);  // defensive check before every call

        using var document = new PdfLoadedDocument(pdfPath);
        using var processor = new OCRProcessor(TessDataPath);
        processor.Settings.Language = Languages.English;
        processor.PerformOCR(document);

        var sb = new StringBuilder();
        foreach (PdfLoadedPage page in document.Pages)
            sb.AppendLine(page.ExtractText());

        return sb.ToString();
    }
}
C#

Approche IronOCR :

using IronOcr;

public class DocumentOcrService
{
    // Non tessdata path — no validation logic — no defensive checks
    public string ExtractText(string pdfPath)
    {
        return new IronTesseract().Read(pdfPath).Text;
    }
}
C#

La méthode entière ValidateTessdataBeforeUse et la constante TessDataPath sont supprimées. Les étapes du pipeline de déploiement qui copient le dossier tessdata sont supprimées. Le script CI qui télécharge les fichiers .traineddata est supprimé. La couche Dockerfile qui copie tessdata dans l'image du conteneur est supprimée. Aucun de ces codes n'a besoin d'être remplacé — il n'est tout simplement plus nécessaire. Le guide d'installation d'IronTesseract couvre toutes les options d'initialisation disponibles si une configuration autre que celle par défaut est nécessaire.

Pipeline de génération de PDF consultables

La sortie PDF consultable de Syncfusion fonctionne en appelant PerformOCR() sur un document chargé, ce qui ajoute une couche de texte invisible en place, puis enregistre le document modifié dans un flux. Le modèle nécessite la gestion de deux flux — l'entrée et la sortie — et les étapes OCR et d'enregistrement sont des opérations distinctes sur le même objet document modifiable.

Approche OCR de Syncfusion :

using Syncfusion.OCRProcessor;
using Syncfusion.Pdf.Parsing;

public class SearchablePdfService
{
    private const string TessDataPath = @"tessdata/";

    public void ConvertToSearchable(string inputPdfPath, string outputPdfPath)
    {
        // Load document — mutable: PerformOCR modifies it in place
        using var document = new PdfLoadedDocument(inputPdfPath);
        using var processor = new OCRProcessor(TessDataPath);

        processor.Settings.Language = Languages.English;

        // Step 1: OCR modifies the document object
        processor.PerformOCR(document);

        // Step 2: Save the modified document to a separate output file
        using var outputStream = new FileStream(outputPdfPath, FileMode.Create, FileAccess.Write);
        document.Save(outputStream);
    }

    public byte[] ConvertToSearchableBytes(string inputPdfPath)
    {
        using var document = new PdfLoadedDocument(inputPdfPath);
        using var processor = new OCRProcessor(TessDataPath);

        processor.Settings.Language = Languages.English;
        processor.PerformOCR(document);

        using var outputStream = new MemoryStream();
        document.Save(outputStream);
        return outputStream.ToArray();
    }
}
C#

Approche IronOCR :

using IronOcr;

public class SearchablePdfService
{
    public void ConvertToSearchable(string inputPdfPath, string outputPdfPath)
    {
        var result = new IronTesseract().Read(inputPdfPath);
        result.SaveAsSearchablePdf(outputPdfPath);
    }

    public byte[] ConvertToSearchableBytes(string inputPdfPath)
    {
        using var input = new OcrInput();
        input.LoadPdf(inputPdfPath);

        var result = new IronTesseract().Read(input);

        // SaveAsSearchablePdf also accepts a MemoryStream
        using var ms = new MemoryStream();
        result.SaveAsSearchablePdf(ms);
        return ms.ToArray();
    }
}
C#

Le modèle de document mutable que Syncfusion utilise — où PerformOCR() modifie le document chargé en place avant de sauvegarder — est remplacé par le modèle de lecture-then-output immuable d'IronOCR. L'objet OcrResult contient le texte reconnu et peut être enregistré dans un PDF consultable, exporté comme texte brut, ou traversé comme données structurées, tout cela à partir du même résultat. Le guide pratique au format PDF consultable et l'exemple au format PDF consultable couvrent des options de sortie supplémentaires, notamment les paramètres de conformité PDF/A.

Pipeline d'OCR de PDF basé sur les flux

Les services de production qui reçoivent des documents PDF via un téléchargement HTTP, une file d'attente de messages ou un stockage de blobs fonctionnent généralement avec des flux plutôt qu'avec des chemins d'accès aux fichiers. Syncfusion accepte les flux via PdfLoadedDocument, mais la contrainte de chemin tessdata s'applique toujours — le dossier tessdata doit exister sur le serveur où le flux est traité.

Approche OCR de Syncfusion :

using Syncfusion.OCRProcessor;
using Syncfusion.Pdf.Parsing;

public class StreamOcrService
{
    private const string TessDataPath = @"tessdata/";

    public string ExtractFromStream(Stream pdfStream)
    {
        // Stream input works, but tessdata path constraint remains
        using var document = new PdfLoadedDocument(pdfStream);
        using var processor = new OCRProcessor(TessDataPath);

        processor.Settings.Language = Languages.English;
        processor.PerformOCR(document);

        var sb = new StringBuilder();
        foreach (PdfLoadedPage page in document.Pages)
            sb.AppendLine(page.ExtractText());

        return sb.ToString();
    }

    public async Task<string> ExtractFromStreamAsync(Stream pdfStream)
    {
        // Non native async — must wrap in Task.Run
        return await Task.Run(() => ExtractFromStream(pdfStream));
    }
}
C#

Approche IronOCR :

using IronOcr;

public class StreamOcrService
{
    public string ExtractFromStream(Stream pdfStream)
    {
        using var input = new OcrInput();
        input.LoadPdf(pdfStream);    // accepts Stream directly

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

    public async Task<string> ExtractFromStreamAsync(Stream pdfStream)
    {
        using var input = new OcrInput();
        input.LoadPdf(pdfStream);

        var ocr = new IronTesseract();
        var result = await ocr.ReadAsync(input);   // native async support
        return result.Text;
    }
}
C#

La méthode LoadPdf() sur OcrInput accepte un Stream directement, sans besoin d'écriture de fichier intermédiaire. IronOCR fournit également une méthode ReadAsync() pour une intégration asynchrone native — pas besoin d'un wrapper Task.Run(). Pour les contrôleurs d'API Web, Azure Functions et d'autres modèles de services asynchrones, cette API est parfaitement adaptée. Le guide d'entrée de flux documente toutes les options de chargement de flux, y compris les flux d'images et les flux TIFF multipages. Le guide sur l'OCR asynchrone couvre la prise en charge des jetons d'annulation et les rappels de progression pour les lots de documents à exécution longue.

Extraction structurée de paragraphes et de WORDs

Le modèle d'extraction de texte de Syncfusion offre deux niveaux : texte concaténé pour le document complet via result.Text, et texte par page via l'itération page.ExtractText(). Il n'y a pas de structure de sous-pages — pas de coordonnées de mots, pas de limites de paragraphes, pas de scores de confiance par token. Les applications qui doivent localiser des champs spécifiques par position ou filtrer des tokens à faible confiance doivent implémenter leur propre logique d'analyse syntaxique sur la chaîne concaténée.

Approche OCR de Syncfusion :

using Syncfusion.OCRProcessor;
using Syncfusion.Pdf.Parsing;

public class StructuredExtractionService
{
    private const string TessDataPath = @"tessdata/";

    public Dictionary<int, string> ExtractPerPage(string pdfPath)
    {
        var pageTexts = new Dictionary<int, string>();

        using var document = new PdfLoadedDocument(pdfPath);
        using var processor = new OCRProcessor(TessDataPath);

        processor.Settings.Language = Languages.English;
        processor.PerformOCR(document);

        // Page-level is the finest granularity available
        int pageNum = 1;
        foreach (PdfLoadedPage page in document.Pages)
        {
            pageTexts[pageNum] = page.ExtractText();
            pageNum++;
        }

        return pageTexts;
        // Non word coordinates, no paragraph boundaries, no per-token confidence
    }
}
C#

Approche IronOCR :

using IronOcr;

public class StructuredExtractionService
{
    public void ExtractWithStructure(string pdfPath)
    {
        var result = new IronTesseract().Read(pdfPath);

        Console.WriteLine($"Overall confidence: {result.Confidence}%");

        foreach (var page in result.Pages)
        {
            Console.WriteLine($"Page {page.PageNumber}: {page.Words.Length} words");

            foreach (var paragraph in page.Paragraphs)
            {
                Console.WriteLine($"  Paragraph at ({paragraph.X}, {paragraph.Y}):");
                Console.WriteLine($"  {paragraph.Text}");
            }
        }
    }

    public IEnumerable<string> ExtractHighConfidenceWords(string pdfPath, int minConfidence = 80)
    {
        var result = new IronTesseract().Read(pdfPath);

        // Per-word confidence filtering — not possible with Syncfusion's page-level model
        return result.Pages
            .SelectMany(p => p.Words)
            .Where(w => w.Confidence >= minConfidence)
            .Select(w => w.Text);
    }
}
C#

Le modèle de sortie structuré présente les paragraphes, les lignes, les WORDs et les caractères avec les coordonnées de leur cadre de sélection et des scores de confiance individuels. Cela s'avère particulièrement utile pour l'extraction de champs de factures, l'analyse de formulaires et la classification de documents — des workflows où savoir où le texte apparaît sur la page est aussi important que ce qu'il dit. Le guide des résultats de lecture et la documentation de référence de l'API OcrResult décrivent l'ensemble du graphe d'objets.

Traitement par lots de documents avec exécution parallèle

Les services d'OCR à haut débit traitent simultanément des dizaines, voire des centaines de documents. Syncfusion ne documente pas OCRProcessor comme sûr pour les threads, ce qui impose un traitement séquentiel ou oblige les développeurs à mettre en œuvre leur propre pool d'instances. Les instances IronOCR sont sûres à créer par thread, permettant une utilisation directe avec Parallel.ForEach ou PLINQ sans synchronisation supplémentaire.

Approche OCR de Syncfusion :

using Syncfusion.OCRProcessor;
using Syncfusion.Pdf.Parsing;

public class BatchOcrService
{
    private const string TessDataPath = @"tessdata/";

    public Dictionary<string, string> ProcessBatch(IEnumerable<string> pdfPaths)
    {
        var results = new Dictionary<string, string>();

        // Sequential processing — OCRProcessor thread safety not guaranteed
        foreach (var path in pdfPaths)
        {
            using var document = new PdfLoadedDocument(path);
            using var processor = new OCRProcessor(TessDataPath);

            processor.Settings.Language = Languages.English;
            processor.PerformOCR(document);

            var sb = new StringBuilder();
            foreach (PdfLoadedPage page in document.Pages)
                sb.AppendLine(page.ExtractText());

            results[path] = sb.ToString();
        }

        return results;
    }
}
C#

Approche IronOCR :

using IronOcr;

public class BatchOcrService
{
    public Dictionary<string, string> ProcessBatch(IEnumerable<string> pdfPaths)
    {
        var results = new ConcurrentDictionary<string, string>();

        // Parallel processing — IronTesseract is safe per-thread
        Parallel.ForEach(pdfPaths, pdfPath =>
        {
            var ocr = new IronTesseract();   // one instance per thread
            var text = ocr.Read(pdfPath).Text;
            results[pdfPath] = text;
        });

        return new Dictionary<string, string>(results);
    }
}
C#

Créer une instance IronTesseract par thread est le modèle documenté pour le traitement parallèle. Pas d'état partagé, pas de conflit de verrouillage, pas d'infrastructure de pool d'instances requise. L'exemple de multithreading présente des benchmarks de débit pour des tailles de lots de documents typiques, et le guide d'optimisation de la vitesse couvre les options de configuration du moteur pour les charges de travail sensibles à la latence.

Référence de mappage de l'API OCR de Syncfusion vers IronOCR

OCR SyncfusionÉquivalent d'IronOCRNotes
Syncfusion.PDF.OCR.Net.CoreIronOcrRemplacer le package NuGet
Syncfusion.OCRProcessorIronOcrespace de noms unique
Syncfusion.PdfRetirerPlus nécessaire
Syncfusion.Pdf.ParsingRetirerPlus nécessaire
SyncfusionLicenseProvider.RegisterLicense()IronOcr.License.LicenseKey =Affectation de chaîne, pas d'enregistrement de suite
new OCRProcessor(tessdataPath)new IronTesseract()Aucun argument de chemin
PdfLoadedDocument(filePath)Passer le chemin directement à ocr.Read(path)Ou utiliser OcrInput avec LoadPdf()
PdfLoadedDocument(stream)input.LoadPdf(stream)La prise en charge des flux est directe
processor.Settings.Language = Languages.Englishocr.Language = OcrLanguage.EnglishOcrLanguage énumération
Langues.Anglais | Langues.Françaisocr.Language = OcrLanguage.English ; ocr.AddSecondaryLanguage(OcrLanguage.French)Le modèle additif remplace les indicateurs binaires
processor.PerformOCR(document)ocr.Read(input)Retourne OcrResult directement
page.ExtractText()result.Text ou result.Pages[i].TextAucune boucle requise pour le texte complet
document.Pages itérationresult.Pages[] tableauComprend des paragraphes, des mots, des caractères
document.Save(outputStream) après OCRresult.SaveAsSearchablePdf(path)Méthode dédiée
Logique de validation TessdataSupprimer entièrementAucune donnée de test à valider
Constante de chemin d'accès manuel tessdataSupprimer entièrementNon requis par IronOCR
PdfBitmap conversion image-en-PDFinput.LoadImage(imagePath)Pas de conversion PDF pour l'OCR d'images
API sans prétraitementinput.Deskew(), input.DeNoise(), input.Contrast()Intégré à OcrInput

Problèmes de migration courants et solutions

Problème n° 1 : répertoire Tessdata introuvable après le changement de package

Syncfusion OCR : la validation du répertoire tessdata a été écrite sous forme de garde au démarrage ou par appel. Après avoir retiré Syncfusion et installé IronOCR, ce code de validation compile toujours (il utilise System.IO, non pas des espaces de noms Syncfusion) mais protège maintenant une opération qui n'existe plus. Le laisser en place revient à conserver du code mort qui risque de semer la confusion chez les futurs développeurs.

Solution : Supprimer entièrement toute la logique de validation des données. Supprimer la constante TessDataPath, tous les contrôles Directory.Exists(TessDataPath), tous les contrôles File.Exists(Path.Combine(TessDataPath, ...)), et toutes les méthodes de validation de démarrage. IronOCR ne génère pas d'exceptions liées aux données tessdata, car il n'y a pas de données tessdata manquantes :

// Delete these entirely — they have no equivalent in IronOCR
// private const string TessDataPath = @"tessdata/";
// private bool ValidateTessdata() { ... }

// The only error handling needed after migration:
try
{
    return new IronTesseract().Read(pdfPath).Text;
}
catch (FileNotFoundException)
{
    throw new ArgumentException($"PDF file not found: {pdfPath}");
}
C#

Problème n° 2 : fichiers de langue indisponibles lors de l'exécution

Syncfusion OCR: Les fichiers de langue .traineddata ont été déployés comme artéfacts de système de fichiers, marqués CopyToOutputDirectory dans le .csproj, et copiés par le système de construction. Après avoir retiré le dossier tessdata du projet, les étapes CI liées aux langues et les entrées .csproj peuvent encore référencer les fichiers supprimés, provoquant des avertissements de construction ou des échecs de pipeline.

Solution : Supprimer toutes les entrées liées à tessdata des fichiers .csproj et des définitions de pipeline CI. Installez plutôt les packs de langues sous forme de paquets NuGet :

# Languages install as NuGet packages — no manual file management
dotnet add package IronOcr.Languages.French
dotnet add package IronOcr.Languages.German
dotnet add package IronOcr.Languages.ChineseSimplified
SHELL
// Language configuration after migration
var ocr = new IronTesseract();
ocr.Language = OcrLanguage.French;
ocr.AddSecondaryLanguage(OcrLanguage.German);
var result = ocr.Read("multilingual-report.pdf");
C#

Le guide de plusieurs langues couvre l'installation des packs de langues et les valeurs d'énumération OcrLanguage pour toutes les 125+ langues prises en charge.

Problème n° 3 : l'ordre des octets diffère dans les fichiers PDF consultables

Syncfusion OCR: Le PDF consultable était produit en appelant document.Save(stream) après que PerformOCR() a modifié le document. Certains consommateurs en aval du tableau d'octets ont peut-être été programmés pour s'attendre à la structure PDF spécifique de Syncfusion, à ses champs de métadonnées ou à sa chaîne de production.

Solution : L'SaveAsSearchablePdf() d'IronOCR produit un PDF standard avec une couche de texte. Testez le résultat avec vos utilisateurs en aval (visionneuses PDF, index de recherche, systèmes d'archivage) pour vérifier la compatibilité. Si un résultat identique octet par octet est requis, un test de transition comparant l'extractibilité du texte (et non les octets bruts) constitue le critère d'acceptation approprié :

// Verify the searchable PDF contains the expected text
var result = new IronTesseract().Read("scanned.pdf");
result.SaveAsSearchablePdf("output-searchable.pdf");

// Validation: confirm text layer is present and readable
var verificationText = new IronTesseract().Read("output-searchable.pdf").Text;
Assert.True(verificationText.Contains("expected content"));
C#

Problème n° 4 : augmentation de la taille de l'image Docker après une tentative de migration

Syncfusion OCR : certaines équipes tentent la migration tout en laissant les fichiers tessdata dans l'image Docker par mesure de précaution pendant les tests. Cela se traduit par la présence à la fois de la couche tessdata et du package IronOCR dans l'image, ce qui augmente inutilement la taille de l'image.

Solution : Supprimer la couche COPY de tessdata du Dockerfile avant de construire l'image migrée. Le package IronOCR est autonome. Le guide de déploiement Docker fournit des images de base et des configurations vérifiées pour les cibles Alpine, Debian et Ubuntu :

# Retirer this layer entirely after migration
# COPY tessdata/ /app/tessdata/

# IronOCR requires only the standard .NET runtime
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS runtime
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "YourService.dll"]
Text

Problème n° 5 : le modèle PerformOCR / ExtractText en deux étapes n'a pas d'équivalent direct

Syncfusion OCR: Certains codes appelants transmettent une référence PdfLoadedDocument entre les méthodes — une méthode appelle PerformOCR() et une autre appelle ExtractText() — en comptant sur la mutation stateful de l'objet document. Ce modèle n'existe pas dans IronOCR car Read() renvoie un objet de résultat autonome.

Solution : Refactorer tous les modèles OCR/extract divisés en une seule méthode qui accepte un chemin de fichier ou un flux et renvoie un OcrResult. L'objet de résultat contient tout : le texte, les pages, les paragraphes, le niveau de confiance et la possibilité d'enregistrer le document au format PDF consultable :

// Replace split PerformOCR / ExtractText pattern
public OcrResult ProcessDocument(string pdfPath)
{
    // One call, immutable result, all data available
    return new IronTesseract().Read(pdfPath);
}

// Callers decide what they need from the result
var result = service.ProcessDocument("contract.pdf");
var fullText = result.Text;
var confidence = result.Confidence;
result.SaveAsSearchablePdf("contract-searchable.pdf");
C#

Problème n° 6 : le code d'enregistrement de la licence communautaire persiste après la migration

Syncfusion OCR: L'appel Syncfusion.Licensing.SyncfusionLicenseProvider.RegisterLicense() au démarrage de l'application enregistre la licence de la suite. Cet appel est souvent dans Program.cs, Startup.cs, ou un initialiseur statique. Après avoir supprimé les packages Syncfusion, cette ligne provoque une erreur de compilation.

Solution : Supprimer l'appel SyncfusionLicenseProvider.RegisterLicense() et le remplacer par l'initialisation de la licence IronOCR. Supprimez également toute logique d'éligibilité à une licence communautaire, toute référence à la documentation de conformité ou tout commentaire concernant les seuils de chiffre d'affaires et d'effectifs — aucun de ces concepts ne s'applique à IronOCR :

// Retirer (causes compile error after package removal)
// Syncfusion.Licensing.SyncfusionLicenseProvider.RegisterLicense("SYNCFUSION-KEY");

// Add at application startup
IronOcr.License.LicenseKey = "YOUR-IRONOCR-KEY";
C#

Liste de contrôle pour la migration OCR de Syncfusion

Pré-migration

Vérifiez le code source pour identifier toutes les utilisations de OCR Syncfusion avant d'apporter des modifications :

# Find all Syncfusion namespace imports
grep -r "using Syncfusion" --include="*.cs" .

# Find OCRProcessor usage
grep -r "OCRProcessor\|PerformOCR\|PdfLoadedDocument\|ExtractText" --include="*.cs" .

# Find tessdata path references
grep -r "TessDataPath\|tessdata\|traineddata" --include="*.cs" .

# Find Syncfusion license registration
grep -r "SyncfusionLicenseProvider\|RegisterLicense" --include="*.cs" .

# Find csproj tessdata copy rules
grep -r "tessdata\|traineddata" --include="*.csproj" .

# Find Dockerfile tessdata layers
grep -r "tessdata" Dockerfile* docker-compose*.yml .
SHELL

Faites le point sur les résultats avant d'écrire le moindre code. Notez quels fichiers contiennent des appels OCR, lesquels contiennent une validation tessdata, et quelles définitions de pipeline font référence au dossier tessdata.

Migration de code

  1. Retirer Syncfusion.PDF.OCR.Net.Core, Syncfusion.Pdf.Net.Core, et les packages associés de tous les fichiers .csproj.
  2. Exécuter dotnet add package IronOcr dans chaque projet qui effectue l'OCR.
  3. Installer des packs de langues via NuGet pour toutes les langues non anglaises utilisées : dotnet add package IronOcr.Languages.[Language].
  4. Supprimer la constante private const string TessDataPath de toutes les classes de service.
  5. Supprimer toutes les méthodes de validation tessdata (ValidateTessdata() et gardes similaires).
  6. Remplacer SyncfusionLicenseProvider.RegisterLicense() par IronOcr.License.LicenseKey = "YOUR-KEY" au démarrage de l'application.
  7. Remplacer using Syncfusion.OCRProcessor; using Syncfusion.PDF; using Syncfusion.Pdf.Parsing; with using IronOcr;.
  8. Remplacer chaque initialisation new OCRProcessor(TessDataPath) par new IronTesseract().
  9. Remplacer les chaînes PdfLoadedDocument + processor.PerformOCR() + page.ExtractText() par ocr.Read(path).Text.
  10. Remplacer les indicateurs de langue binaires de Syncfusion (Languages.English | Langues.Francais plus ocr.AddSecondaryLanguage() appels.
  11. Remplacer document.Save(stream) après PerformOCR() par result.SaveAsSearchablePdf(path) pour la sortie PDF consultable.
  12. Remplacer les allers-retours de conversion image-en-PDF par des input.LoadImage(imagePath) directs ou ocr.Read(imagePath).
  13. Retirer les entrées CopyToOutputDirectory de tessdata de tous les fichiers .csproj.
  14. Supprimer les étapes de téléchargement de tessdata de toutes les définitions de pipeline CI/CD.
  15. Retirer les couches COPY de tessdata de tous les Dockerfiles.

Après la migration

  • Vérifiez que l'OCR des PDF produit le contenu textuel attendu sur les mêmes exemples de documents que ceux utilisés avant la migration.
  • Vérifiez que l'OCR des images (JPG, PNG, BMP) fonctionne sans étape de conversion au format PDF.
  • Vérifiez que les documents multilingues sont correctement reconnus à l'aide des packs de langues NuGet installés.
  • Testez la sortie PDF consultable en ouvrant le fichier généré dans une visionneuse PDF et en vérifiant que la sélection de texte et la recherche fonctionnent.
  • Exécutez l'application dans un nouveau conteneur Docker créé à partir du fichier Dockerfile mis à jour afin de vérifier qu'aucune erreur de démarrage liée à tessdata ne se produit.
  • Confirmer que l'application démarre sans appel Syncfusion.Licensing ou référence d'espace de noms Syncfusion.
  • Vérifier que result.Confidence renvoie une valeur plausible (généralement 80–99 % pour les documents propres) pour confirmer que le moteur OCR est actif.
  • Testez le traitement par lots en parallèle en exécutant des appels OCR simultanés et en vérifiant qu'il n'y a pas d'exceptions de threading ni de résultats corrompus.
  • Comparez la précision de l'extraction de texte sur des numérisations de mauvaise qualité ou pivotées avant et après la migration, en notant l'amélioration apportée par le pipeline de prétraitement automatique.

Principaux avantages de la migration vers IronOCR

La complexité du déploiement tombe à un seul package NuGet. Après migration, chaque environnement — poste de travail développeur, coureur CI, conteneur de mise en scène, serveur en production — nécessite exactement une chose : le package NuGet IronOcr restauré par le système de construction. Aucun dossier tessdata. Aucun chemin d'accès au système de fichiers à configurer. Pas de scripts de téléchargement de fichiers de langue. Pas de couches Dockerfile contenant 100 à 500 Mo de données binaires. Les images de conteneurs sont plus petites, les pipelines de CI sont plus simples et les nouveaux environnements sont provisionnés correctement dès la première compilation, sans intervention manuelle.

Les coûts de licence deviennent prévisibles et non récurrents. L'achat d'une licence perpétuelle unique remplace le cycle de renouvellement annuel par développeur. Une équipe de cinq développeurs qui achète IronOCR Professional (2 999 $) devient propriétaire de la bibliothèque IronOCR pour une durée illimitée, avec un an de mises à jour inclus. Il n'y a pas de seuils de chiffre d'affaires à surveiller, pas de limites d'effectifs à suivre, pas de dispositions d'audit et pas de documentation de conformité à tenir à jour. Les événements liés à la croissance — nouveaux prestataires, contrats importants, levées de fonds — ne déclenchent pas de révision des licences.

Le pipeline OCR gère les documents dégradés sans dépendances externes. Redressage, débruitage, amélioration du contraste, binarisation et mise à l'échelle de la résolution sont disponibles en tant que méthodes sur OcrInput. Aucune bibliothèque d'images distincte n'est nécessaire. Les documents présentant une légère rotation, des artefacts de numérisation ou un faible contraste, qui nécessitaient auparavant une étape de prétraitement à l'aide de System.Drawing ou SkiaSharp, peuvent désormais être traités dans le cadre du même appel IronOCR. Le guide de correction de la qualité d'image et la page des fonctionnalités de prétraitement répertorient tous les filtres disponibles et leur effet sur la précision de la reconnaissance.

La sortie structurée permet une intelligence documentaire au niveau des champs. L'objet OcrResult expose toute la structure du document — pages, paragraphes, lignes, mots et caractères — avec des coordonnées de boîte englobante et des scores de confiance par jeton. Les applications qui analysaient auparavant des chaînes de texte concaténées pour trouver les limites des champs peuvent désormais utiliser directement les données de coordonnées des paragraphes et des mots. Les workflows de traitement des factures, d'extraction de formulaires et de classification de documents permettent d'accéder à des informations spatiales que le modèle au niveau de la page de Syncfusion ne peut pas fournir. La page consacrée aux cas d'utilisation de l'OCR pour les PDF couvre les modèles courants d'intelligence documentaire.

Le traitement par lots parallèle évolue sans infrastructure. Créer une instance IronTesseract par thread est la stratégie complète de threading — pas de mise en pool d'instances, pas de gestion de sémaphore, pas de contraintes de traitement séquentiel. Un service par lots traitant 500 documents par heure peut saturer les cœurs de processeur disponibles avec Parallel.ForEach et une seule ligne de synchronisation. L'architecture du moteur autonome signifie que chaque thread fonctionne de manière indépendante, sans état mutable partagé.

Plus de 125 langues sont disponibles sans gestion de fichiers binaires. Chaque pack linguistique s'installe sous forme de package NuGet via le gestionnaire de packages standard. La gestion des versions, l'acquisition des mises à jour et la résolution des dépendances sont gérées par les mêmes outils que ceux utilisés pour toutes les autres dépendances du projet. Ajouter l'OCR japonais ou arabe à un service nécessite une seule commande dotnet add package, pas un téléchargement manuel depuis un dépôt GitHub suivi de mises à jour de pipeline de déploiement. L'index des langues répertorie tous les scripts pris en charge avec les commandes d'installation.

Veuillez noter: Syncfusion et Tesseract sont des marques déposées de leurs propriétaires respectifs. Ce site n'est ni affilié à, ni approuvé par, ni sponsorisé par Google ou Syncfusion. Tous les noms de produits, logos et marques sont la propriété de leurs propriétaires respectifs. Les comparaisons sont à titre informatif uniquement et reflètent les informations publiquement disponibles au moment de l'écriture.
Kannaopat Udonpant
Kannapat Udonpant
Ingénieur logiciel

Articles connexes

Key in blue circle

Obtenez votre clé d'essai de 30 jours instantanément.

Your trial license will be sent to your email address

Aucune restriction. 100 % débloqué. Pas de carte bancaire.

bullet_checkedAucune carte de crédit ou création de compte requiseAucune restriction. 100 % débloqué. Pas de carte bancaire.
  • Logo Aetna
  • Logo NASA
  • Logo GE
  • Logo Porsche
  • Logo USDA
  • Logo Qatar
Join Millions of Engineers who’ve tried IronPDF
Obtenez Votre Consultation sans Engagement
Remplissez le formulaire ci-dessous ou envoyez un email à sales@ironsoftware.com
Vos informations seront toujours gardées confidentielles.
De confiance par des millions d'ingénieurs dans le monde entier
Logos des clients d'Iron Software
Obtenez votre clé d'essai 30 jours gratuitement.
Aucune carte de crédit ou création de compte requise