L'BarcodeReader de ZXing.Net n'est pas sûr pour les threads. Chaque chemin de lecture concurrent dans votre application — chaque ForEach parallèle, chaque action de contrôleur asynchrone traitant des requêtes simultanées — nécessite sa propre instance de lecteur. Cela signifie que la configuration du format est répétée par instance, le chargement et la suppression d'Bitmap à chaque appel, et l'allocation du lecteur pour chaque requête. La méthode statique d'IronBarcode gère le même travail sans allocation par requête. La sécurité des threads n'est qu'un élément de la liste : l'absence de prise en charge native du format PDF, la fragmentation des packages de liaison entre Windows et Linux, et l'obligation de spécifier chaque format de code-barres que vous souhaitez scanner sont autant de caractéristiques qui font que les projets ZXing .NET accumulent des solutions de contournement au fil du temps.

Comprendre ZXing .NET

ZXing .NET est un portage open-source de la bibliothèque Java ZXing (" Zebra Crossing ") de Google, publié sous la licence Apache 2.0et maintenu par Michael Jahn sur GitHub. Il s'agit de la bibliothèque de codes-barres open source la plus téléchargée pour .NET, avec une longue expérience remontant à plus d'une décennie. La bibliothèque prend en charge la lecture et l'écriture d'un large éventail de formats de codes-barres, et sa licence gratuite la rend accessible aux projets de toutes tailles, y compris les produits open source nécessitant des dépendances compatibles avec Apache.

L'architecture de ZXing.Net reflète ses origines de portage Java. La classe BarcodeReader est un objet avec état : appeler Decode écrit l'état interne, ce qui rend les instances non sûres à partager entre les threads. L'utilisation correcte en concurrence nécessite soit un nouveau lecteur par thread, soit un pool d'ThreadLocal<BarcodeReader> — ce qui place la responsabilité de la sécurité des threads sur l'appelant. Le chargement d'images n'est pas non plus inclus dans le package principal ; ZXing .NET propose en revanche des packages de liaison spécifiques à chaque plateforme, exposant chacun une interface API différente.

Les principales caractéristiques architecturales comprennent :

• Licence Apache 2.0 : gratuite pour une utilisation commerciale et open source, sans frais ni obligation de contact commercial.
• Lecteur de codes-barres avec état : L'instance BarcodeReader n'est pas sûre pour les threads; Une nouvelle instance doit être créée par thread ou par opération parallèle.
• Spécification de format manuelle : Les appelants doivent définir reader.Options.PossibleFormats avant chaque décodage; Les formats non répertoriés sont ignorés silencieusement, sans erreur ni avertissement.
• Aucune prise en charge native du format PDF : la bibliothèque ne lit que les images ; L'importation de fichiers PDF nécessite une bibliothèque de rendu PDF distincte telle que PdfiumViewer pour convertir les pages en bitmaps avant le décodage.
• Fragmentation de la liaison de la plateforme : le package principal ne fournit aucun chargement d'image ; des packages de liaison séparés (ZXing.Net.Bindings.Windows.Compatibility utilisant System.Drawing, ZXing.Net.Bindings.ImageSharp / .V2 / .V3 utilisant SixLabors.ImageSharp, plus ZXing.Net.Bindings.SkiaSharp et ZXing.Net.Bindings.Magick) exposent différentes API pour différentes cibles de déploiement.
• Communauté active : les problèmes, les demandes de fusion et les discussions sont actifs sur GitHub, offrant un soutien communautaire gratuit.
• Prise en charge des formats étendus : prend en charge les codes QR, Code 128, Code 39, EAN-13, EAN-8, UPC-A, Data Matrix, PDF 417, Aztec et d'autres symbologies largement utilisées.

L'architecture du lecteur d'état

L'BarcodeReader de ZXing.Net nécessite une nouvelle instance pour chaque thread ou opération parallèle. Le schéma suivant illustre la configuration minimale correcte pour le traitement simultané :

// ZXing.Net: a new reader instance is created per iteration
Parallel.ForEach(imagePaths, path =>
{
    var reader = new BarcodeReader();
    reader.Options.PossibleFormats = new List<BarcodeFormat>
    {
        BarcodeFormat.QR_CODE,
        BarcodeFormat.CODE_128,
        BarcodeFormat.EAN_13
    };

    using var bitmap = new Bitmap(path);
    var result = reader.Decode(bitmap);

    if (result != null)
        results[path] = result.Text;
});

// ZXing.Net: a new reader instance is created per iteration
Parallel.ForEach(imagePaths, path =>
{
    var reader = new BarcodeReader();
    reader.Options.PossibleFormats = new List<BarcodeFormat>
    {
        BarcodeFormat.QR_CODE,
        BarcodeFormat.CODE_128,
        BarcodeFormat.EAN_13
    };

    using var bitmap = new Bitmap(path);
    var result = reader.Decode(bitmap);

    if (result != null)
        results[path] = result.Text;
});

Imports System.Collections.Concurrent
Imports System.Drawing
Imports ZXing

Parallel.ForEach(imagePaths, Sub(path)
    Dim reader = New BarcodeReader()
    reader.Options.PossibleFormats = New List(Of BarcodeFormat) From {
        BarcodeFormat.QR_CODE,
        BarcodeFormat.CODE_128,
        BarcodeFormat.EAN_13
    }

    Using bitmap As New Bitmap(path)
        Dim result = reader.Decode(bitmap)

        If result IsNot Nothing Then
            results(path) = result.Text
        End If
    End Using
End Sub)

Imports System.Collections.Concurrent
Imports System.Drawing
Imports ZXing

Parallel.ForEach(imagePaths, Sub(path)
    Dim reader = New BarcodeReader()
    reader.Options.PossibleFormats = New List(Of BarcodeFormat) From {
        BarcodeFormat.QR_CODE,
        BarcodeFormat.CODE_128,
        BarcodeFormat.EAN_13
    }

    Using bitmap As New Bitmap(path)
        Dim result = reader.Decode(bitmap)

        If result IsNot Nothing Then
            results(path) = result.Text
        End If
    End Using
End Sub)

Le modèle ThreadLocal<BarcodeReader> réduit l'allocation par appel en réutilisant une instance par thread, mais ajoute la complexité de la suppression. De toute façon, la sécurité des threads est la responsabilité de l'appelant dans ZXing.Net.

Comprendre IronBarcode

IronBarcode est une bibliothèque commerciale de codes-barres .NET développée par Iron Software. Il fournit la lecture et la génération de codes-barres via une API statique sans état : BarcodeReader.Read et BarcodeWriter.CreateBarcode sont les principaux points d'entrée, et aucun ne nécessite la création ou la configuration d'instances avant l'utilisation. La bibliothèque est distribuée sous la forme d'un seul package NuGet qui fonctionne de manière identique sous Windows, Linux, macOSet dans des conteneurs Docker, sans packages de liaison spécifiques à la plateforme.

Le moteur de lecture d'IronBarcode effectue une détection automatique du format sur plus de 50 symbologies de codes-barres. Les appelants ne précisent pas les formats à rechercher ; Le moteur évalue chaque image par rapport à tous les formats pris en charge et renvoie tous les codes-barres trouvés. Pour les applications qui ont besoin d'équilibrer la vitesse de numérisation avec la minutie, un enum ReadingSpeed (Faster, Balanced, Detailed, ExtremeDetail) offre un contrôle sans nécessiter d'énumération de formats. La bibliothèque inclut également une prise en charge native du format PDF, permettant la lecture directe des codes-barres à partir des documents PDF sur toutes les pages, sans nécessiter de bibliothèque de rendu PDF distincte.

Les principales caractéristiques sont les suivantes

• Licence commerciale : nécessite une clé de licence payante ; Un mode d'essai est disponible pour évaluation.
• API statique sans état : BarcodeReader.Read et BarcodeWriter.CreateBarcode sont des méthodes statiques sûres pour les threads; Aucune gestion d'instance n'est requise.
• Détection automatique du format : tous les plus de 50 formats de codes-barres pris en charge sont détectés sans liste de formats ; les utilisateurs optimisent la vitesse plutôt que la portée des formats.
• Support PDF natif : BarcodeReader.Read accepte directement les chemins de fichiers PDF, traitant toutes les pages sans bibliothèque PDF externe.
• Un seul package multiplateforme : un seul package NuGet fonctionne sous Windows, Linux, macOSet Docker avec la même interface API.
• API de génération fluide : BarcodeWriter.CreateBarcode renvoie un objet GeneratedBarcode avec des méthodes de sortie intégrées incluant SaveAsPng, SaveAsPdf, ToPngBinaryData, et ToStream.
• Assistance commerciale : Les licences payantes incluent l'accès à l'équipe d'assistance d'Iron Software avec des engagements de niveau de service.

Comparaison des fonctionnalités

Le tableau suivant met en évidence les différences fondamentales entre ZXing .NET et IronBarcode:

Comparaison détaillée des fonctionnalités

Sécurité des threads et traitement simultané

La sécurité des threads est la différence opérationnelle la plus importante entre les deux bibliothèques, et elle affecte davantage de projets que ne le suggèrent les avertissements de la documentation.

Approche ZXing .NET

L'BarcodeReader de ZXing.Net est un objet avec état. Lorsque Decode est appelé, l'état interne est écrit. Si deux threads partagent la même instance, ces écritures entrent en concurrence. Les résultats sont non déterministes : vous pouvez obtenir un résultat provenant d'une image différente, une valeur nulle là où un code-barres est présent, ou une exception. L'approche correcte consiste à créer un lecteur par thread — ce qui signifie que chaque chemin parallèle ou asynchrone alloue un lecteur, le configure, l'utilise une fois, puis le supprime :

// ZXing.Net: one reader instance per parallel operation
Parallel.ForEach(imagePaths, path =>
{
    var reader = new BarcodeReader();
    reader.Options.PossibleFormats = new List<BarcodeFormat>
    {
        BarcodeFormat.QR_CODE,
        BarcodeFormat.CODE_128,
        BarcodeFormat.EAN_13
    };

    using var bitmap = new Bitmap(path);
    var result = reader.Decode(bitmap);

    if (result != null)
        results[path] = result.Text;
});

// ZXing.Net: one reader instance per parallel operation
Parallel.ForEach(imagePaths, path =>
{
    var reader = new BarcodeReader();
    reader.Options.PossibleFormats = new List<BarcodeFormat>
    {
        BarcodeFormat.QR_CODE,
        BarcodeFormat.CODE_128,
        BarcodeFormat.EAN_13
    };

    using var bitmap = new Bitmap(path);
    var result = reader.Decode(bitmap);

    if (result != null)
        results[path] = result.Text;
});

Imports System.Collections.Concurrent
Imports System.Drawing
Imports ZXing

Parallel.ForEach(imagePaths, Sub(path)
    Dim reader As New BarcodeReader()
    reader.Options.PossibleFormats = New List(Of BarcodeFormat) From {
        BarcodeFormat.QR_CODE,
        BarcodeFormat.CODE_128,
        BarcodeFormat.EAN_13
    }

    Using bitmap As New Bitmap(path)
        Dim result = reader.Decode(bitmap)

        If result IsNot Nothing Then
            results(path) = result.Text
        End If
    End Using
End Sub)

Imports System.Collections.Concurrent
Imports System.Drawing
Imports ZXing

Parallel.ForEach(imagePaths, Sub(path)
    Dim reader As New BarcodeReader()
    reader.Options.PossibleFormats = New List(Of BarcodeFormat) From {
        BarcodeFormat.QR_CODE,
        BarcodeFormat.CODE_128,
        BarcodeFormat.EAN_13
    }

    Using bitmap As New Bitmap(path)
        Dim result = reader.Decode(bitmap)

        If result IsNot Nothing Then
            results(path) = result.Text
        End If
    End Using
End Sub)

Le modèle ThreadLocal<BarcodeReader> réduit l'allocation par appel en réutilisant un lecteur par thread, mais cela ajoute la complexité de la suppression et nécessite toujours la configuration du format sur chaque instance.

Approche IronBarcode

L'BarcodeReader.Read d'IronBarcode est une méthode statique sans état. Il n'y a pas d'instance à partager, pas d'instance à isoler et aucun état de configuration à protéger. Le même appel s'exécute en toute sécurité depuis un nombre quelconque de threads simultanés :

// IronBarcode: static method — no instance management
var options = new BarcodeReaderOptions
{
    Speed = ReadingSpeed.Balanced,
    ExpectMultipleBarcodes = true,
    MaxParallelThreads = 4
};

Parallel.ForEach(imagePaths, path =>
{
    var result = BarcodeReader.Read(path, options).FirstOrDefault();
    if (result != null)
        results[path] = result.Value;
});

// IronBarcode: static method — no instance management
var options = new BarcodeReaderOptions
{
    Speed = ReadingSpeed.Balanced,
    ExpectMultipleBarcodes = true,
    MaxParallelThreads = 4
};

Parallel.ForEach(imagePaths, path =>
{
    var result = BarcodeReader.Read(path, options).FirstOrDefault();
    if (result != null)
        results[path] = result.Value;
});

Imports IronBarcode

Dim options As New BarcodeReaderOptions With {
    .Speed = ReadingSpeed.Balanced,
    .ExpectMultipleBarcodes = True,
    .MaxParallelThreads = 4
}

Parallel.ForEach(imagePaths, Sub(path)
    Dim result = BarcodeReader.Read(path, options).FirstOrDefault()
    If result IsNot Nothing Then
        results(path) = result.Value
    End If
End Sub)

Imports IronBarcode

Dim options As New BarcodeReaderOptions With {
    .Speed = ReadingSpeed.Balanced,
    .ExpectMultipleBarcodes = True,
    .MaxParallelThreads = 4
}

Parallel.ForEach(imagePaths, Sub(path)
    Dim result = BarcodeReader.Read(path, options).FirstOrDefault()
    If result IsNot Nothing Then
        results(path) = result.Value
    End If
End Sub)

La documentation d'IronBarcode sur la lecture asynchrone et multithread des codes-barres explique le modèle de mise en pool de threads interne. La propriété MaxParallelThreads contrôle le degré de parallélisme sans nécessiter de coordination externe.

Détection de format

La politique de détection des formats constitue la deuxième différence opérationnelle significative entre les deux bibliothèques.

Approche ZXing .NET

ZXing.Net exige que reader.Options.PossibleFormats soit rempli avant chaque décodage. Si un format de code-barres n'est pas répertorié, il ne sera pas détecté — sans erreur, sans avertissement et sans résultat partiel :

// ZXing.Net: PossibleFormats list controls which symbologies are decoded
var reader = new BarcodeReader();
reader.Options.PossibleFormats = new List<BarcodeFormat>
{
    BarcodeFormat.QR_CODE,
    BarcodeFormat.CODE_128,
    BarcodeFormat.CODE_39,
    BarcodeFormat.EAN_13,
    BarcodeFormat.EAN_8,
    BarcodeFormat.UPC_A,
    BarcodeFormat.DATA_MATRIX,
    BarcodeFormat.PDF_417
};
reader.Options.TryHarder = true;

using var bitmap = new Bitmap(imagePath);
var results = reader.DecodeMultiple(bitmap);

// ZXing.Net: PossibleFormats list controls which symbologies are decoded
var reader = new BarcodeReader();
reader.Options.PossibleFormats = new List<BarcodeFormat>
{
    BarcodeFormat.QR_CODE,
    BarcodeFormat.CODE_128,
    BarcodeFormat.CODE_39,
    BarcodeFormat.EAN_13,
    BarcodeFormat.EAN_8,
    BarcodeFormat.UPC_A,
    BarcodeFormat.DATA_MATRIX,
    BarcodeFormat.PDF_417
};
reader.Options.TryHarder = true;

using var bitmap = new Bitmap(imagePath);
var results = reader.DecodeMultiple(bitmap);

Imports ZXing
Imports ZXing.Common

' ZXing.Net: PossibleFormats list controls which symbologies are decoded
Dim reader As New BarcodeReader()
reader.Options.PossibleFormats = New List(Of BarcodeFormat) From {
    BarcodeFormat.QR_CODE,
    BarcodeFormat.CODE_128,
    BarcodeFormat.CODE_39,
    BarcodeFormat.EAN_13,
    BarcodeFormat.EAN_8,
    BarcodeFormat.UPC_A,
    BarcodeFormat.DATA_MATRIX,
    BarcodeFormat.PDF_417
}
reader.Options.TryHarder = True

Using bitmap As New Bitmap(imagePath)
    Dim results = reader.DecodeMultiple(bitmap)
End Using

Imports ZXing
Imports ZXing.Common

' ZXing.Net: PossibleFormats list controls which symbologies are decoded
Dim reader As New BarcodeReader()
reader.Options.PossibleFormats = New List(Of BarcodeFormat) From {
    BarcodeFormat.QR_CODE,
    BarcodeFormat.CODE_128,
    BarcodeFormat.CODE_39,
    BarcodeFormat.EAN_13,
    BarcodeFormat.EAN_8,
    BarcodeFormat.UPC_A,
    BarcodeFormat.DATA_MATRIX,
    BarcodeFormat.PDF_417
}
reader.Options.TryHarder = True

Using bitmap As New Bitmap(imagePath)
    Dim results = reader.DecodeMultiple(bitmap)
End Using

Si chaque format est répertorié pour éviter les oublis, les performances se dégradent. Si seuls les formats attendus sont répertoriés, des erreurs silencieuses deviennent possibles lorsque des images proviennent de sources externes. ZXing .NET ne dispose d'aucun mécanisme permettant de signaler la présence d'un code-barres dans un format non répertorié.

Approche IronBarcode

IronBarcode détecte automatiquement plus de 50 formats pris en charge. Aucune liste de format n'est requise ni acceptée :

// IronBarcode: automatic detection across all supported formats
var results = BarcodeReader.Read(imagePath);
foreach (var barcode in results)
{
    Console.WriteLine($"{barcode.Value} ({barcode.Format})");
}

// IronBarcode: automatic detection across all supported formats
var results = BarcodeReader.Read(imagePath);
foreach (var barcode in results)
{
    Console.WriteLine($"{barcode.Value} ({barcode.Format})");
}

Imports IronBarcode

' IronBarcode: automatic detection across all supported formats
Dim results = BarcodeReader.Read(imagePath)
For Each barcode In results
    Console.WriteLine($"{barcode.Value} ({barcode.Format})")
Next

Imports IronBarcode

' IronBarcode: automatic detection across all supported formats
Dim results = BarcodeReader.Read(imagePath)
For Each barcode In results
    Console.WriteLine($"{barcode.Value} ({barcode.Format})")
Next

Pour les applications qui règlent la vitesse de lecture par rapport à la minutie de détection, Code-barres IronBarcode expose un enum ReadingSpeed — Faster, Balanced, Detailed, ExtremeDetail — sans nécessiter d'énumération de formats. Le réglage de la vitesse influe sur la manière dont le moteur traite chaque image, et non sur les formats qu'il prend en compte.

Prise en charge des documents PDF

La lecture de fichiers PDF est une limitation importante de ZXing .NET: la bibliothèque ne prend en charge aucun type de format PDF.

Approche ZXing .NET

Lorsqu'un code-barres est intégré dans un PDF, ZXing .NET nécessite une bibliothèque de rendu PDF externe. La solution de contournement la plus courante utilise PdfiumViewer, ce qui ajoute environ 20 Mo de fichiers binaires natifs et une boucle de rendu de page que les appelants doivent implémenter et maintenir :

// ZXing.Net: PDF input is handled by PdfiumViewer with a per-page render loop
using var pdfDocument = PdfDocument.Load(pdfPath);

var reader = new BarcodeReader();
reader.Options.PossibleFormats = new List<BarcodeFormat>
{
    BarcodeFormat.QR_CODE,
    BarcodeFormat.CODE_128,
    BarcodeFormat.PDF_417
};

for (int i = 0; i < pdfDocument.PageCount; i++)
{
    string tempPath = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.png");
    try
    {
        using var pageImage = pdfDocument.Render(i, 200, 200, PdfRenderFlags.CorrectFromDpi);
        pageImage.Save(tempPath, ImageFormat.Png);

        using var bitmap = new Bitmap(tempPath);
        var decoded = reader.DecodeMultiple(bitmap);
        if (decoded != null)
            results.AddRange(decoded.Select(d => d.Text));
    }
    finally
    {
        File.Delete(tempPath);
    }
}

// ZXing.Net: PDF input is handled by PdfiumViewer with a per-page render loop
using var pdfDocument = PdfDocument.Load(pdfPath);

var reader = new BarcodeReader();
reader.Options.PossibleFormats = new List<BarcodeFormat>
{
    BarcodeFormat.QR_CODE,
    BarcodeFormat.CODE_128,
    BarcodeFormat.PDF_417
};

for (int i = 0; i < pdfDocument.PageCount; i++)
{
    string tempPath = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.png");
    try
    {
        using var pageImage = pdfDocument.Render(i, 200, 200, PdfRenderFlags.CorrectFromDpi);
        pageImage.Save(tempPath, ImageFormat.Png);

        using var bitmap = new Bitmap(tempPath);
        var decoded = reader.DecodeMultiple(bitmap);
        if (decoded != null)
            results.AddRange(decoded.Select(d => d.Text));
    }
    finally
    {
        File.Delete(tempPath);
    }
}

Imports System.IO
Imports System.Drawing
Imports PdfiumViewer
Imports ZXing
Imports ZXing.Common

' ZXing.Net: PDF input is handled by PdfiumViewer with a per-page render loop
Using pdfDocument As PdfDocument = PdfDocument.Load(pdfPath)

    Dim reader As New BarcodeReader()
    reader.Options.PossibleFormats = New List(Of BarcodeFormat) From {
        BarcodeFormat.QR_CODE,
        BarcodeFormat.CODE_128,
        BarcodeFormat.PDF_417
    }

    For i As Integer = 0 To pdfDocument.PageCount - 1
        Dim tempPath As String = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.png")
        Try
            Using pageImage As Image = pdfDocument.Render(i, 200, 200, PdfRenderFlags.CorrectFromDpi)
                pageImage.Save(tempPath, Imaging.ImageFormat.Png)

                Using bitmap As New Bitmap(tempPath)
                    Dim decoded = reader.DecodeMultiple(bitmap)
                    If decoded IsNot Nothing Then
                        results.AddRange(decoded.Select(Function(d) d.Text))
                    End If
                End Using
            End Using
        Finally
            File.Delete(tempPath)
        End Try
    Next
End Using

Imports System.IO
Imports System.Drawing
Imports PdfiumViewer
Imports ZXing
Imports ZXing.Common

' ZXing.Net: PDF input is handled by PdfiumViewer with a per-page render loop
Using pdfDocument As PdfDocument = PdfDocument.Load(pdfPath)

    Dim reader As New BarcodeReader()
    reader.Options.PossibleFormats = New List(Of BarcodeFormat) From {
        BarcodeFormat.QR_CODE,
        BarcodeFormat.CODE_128,
        BarcodeFormat.PDF_417
    }

    For i As Integer = 0 To pdfDocument.PageCount - 1
        Dim tempPath As String = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.png")
        Try
            Using pageImage As Image = pdfDocument.Render(i, 200, 200, PdfRenderFlags.CorrectFromDpi)
                pageImage.Save(tempPath, Imaging.ImageFormat.Png)

                Using bitmap As New Bitmap(tempPath)
                    Dim decoded = reader.DecodeMultiple(bitmap)
                    If decoded IsNot Nothing Then
                        results.AddRange(decoded.Select(Function(d) d.Text))
                    End If
                End Using
            End Using
        Finally
            File.Delete(tempPath)
        End Try
    Next
End Using

Ce modèle présente de réels modes de défaillance : une mauvaise configuration DPI provoque des échecs silencieux, les permissions des fichiers temporaires échouent dans les environnements verrouillés, les bibliothèques natives de PdfiumViewer nécessitent une gestion de déploiement séparée et l'installation ne fonctionne pas sous Linux sans configuration supplémentaire.

Approche IronBarcode

IronBarcode lit nativement les codes-barres des fichiers PDF — toutes les pages, tous les formats, sans dépendance externe. Le même appel BarcodeReader.Read accepte directement les chemins PDF :

// IronBarcode: one call processes every page of the PDF
var results = BarcodeReader.Read("invoice.pdf");
foreach (var barcode in results)
    Console.WriteLine($"Page {barcode.PageNumber}: {barcode.Value}");

// IronBarcode: one call processes every page of the PDF
var results = BarcodeReader.Read("invoice.pdf");
foreach (var barcode in results)
    Console.WriteLine($"Page {barcode.PageNumber}: {barcode.Value}");

Imports IronBarcode

' IronBarcode: one call processes every page of the PDF
Dim results = BarcodeReader.Read("invoice.pdf")
For Each barcode In results
    Console.WriteLine($"Page {barcode.PageNumber}: {barcode.Value}")
Next

Imports IronBarcode

' IronBarcode: one call processes every page of the PDF
Dim results = BarcodeReader.Read("invoice.pdf")
For Each barcode In results
    Console.WriteLine($"Page {barcode.PageNumber}: {barcode.Value}")
Next

Aucune énumération de pages, aucune configuration DPI, aucun fichier temporaire et aucune bibliothèque séparée à déployer avec l'application.

Liaisons et déploiement de la plateforme

La gestion des images de ZXing.Net est répartie entre des packages de liaison spécifiques à chaque plateforme, chacun possédant une interface API différente.

Approche ZXing .NET

Le package central ZXing.Net fournit la logique de décodage mais pas le chargement d'images. Les appelants doivent choisir une liaison en fonction de leur cible de déploiement :

La conséquence pratique est que le code Windows utilisant System.Drawing.Bitmap ne se compile pas ou ne s'exécute pas sur Linux. La conteneurisation nécessite de changer les packages de liaison et de réécrire le code de chargement des images :

// Windows binding path — uses System.Drawing
using ZXing.Windows.Compatibility;
using System.Drawing;

var reader = new BarcodeReader();
using var bitmap = new Bitmap(imagePath);
var result = reader.Decode(bitmap);

// Windows binding path — uses System.Drawing
using ZXing.Windows.Compatibility;
using System.Drawing;

var reader = new BarcodeReader();
using var bitmap = new Bitmap(imagePath);
var result = reader.Decode(bitmap);

Imports ZXing.Windows.Compatibility
Imports System.Drawing

Dim reader As New BarcodeReader()
Using bitmap As New Bitmap(imagePath)
    Dim result = reader.Decode(bitmap)
End Using

Imports ZXing.Windows.Compatibility
Imports System.Drawing

Dim reader As New BarcodeReader()
Using bitmap As New Bitmap(imagePath)
    Dim result = reader.Decode(bitmap)
End Using

// Cross-platform path — different package, different API
using ZXing.ImageSharp;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;

var reader = new BarcodeReader<Rgba32>();
using var image = Image.Load<Rgba32>(imagePath);
var result = reader.Decode(image);

// Cross-platform path — different package, different API
using ZXing.ImageSharp;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;

var reader = new BarcodeReader<Rgba32>();
using var image = Image.Load<Rgba32>(imagePath);
var result = reader.Decode(image);

Imports ZXing.ImageSharp
Imports SixLabors.ImageSharp
Imports SixLabors.ImageSharp.PixelFormats

Dim reader As New BarcodeReader(Of Rgba32)()
Using image As Image(Of Rgba32) = Image.Load(Of Rgba32)(imagePath)
    Dim result = reader.Decode(image)
End Using

Imports ZXing.ImageSharp
Imports SixLabors.ImageSharp
Imports SixLabors.ImageSharp.PixelFormats

Dim reader As New BarcodeReader(Of Rgba32)()
Using image As Image(Of Rgba32) = Image.Load(Of Rgba32)(imagePath)
    Dim result = reader.Decode(image)
End Using

Utiliser la liaison Windows sur un hôte Linux nécessite également libgdiplus dans l'image Docker, ajoutant environ 50 Mo au conteneur.

Approche IronBarcode

IronBarcode propose un seul colis pour toutes les plateformes. Le même appel BarcodeReader.Read(path) compile et s'exécute de manière identique sur Windows, Linux, macOS, et à l'intérieur de conteneurs Docker. Aucun paquetage de liaison, aucune condition de plateforme et aucune dépendance système supplémentaire ne sont requis. Pour les équipes qui conteneurisent des applications .NET , le guide d'installation Code-barres IronBarcode pour Docker et Linux couvre en détail le modèle de déploiement à package unique.

API de génération

Les deux bibliothèques génèrent des codes-barres, mais leurs API reflètent des approches de conception différentes.

Approche ZXing .NET

La classe BarcodeWriter de ZXing.Net crée un objet de rédacteur, accepte des options de codage, appelle Write, et renvoie un Bitmap que les appelants doivent sauvegarder manuellement en utilisant System.Drawing.Imaging :

// ZXing.Net: create writer, set options, call Write, save Bitmap
using ZXing;
using ZXing.Common;
using ZXing.Windows.Compatibility;
using System.Drawing.Imaging;

var writer = new BarcodeWriter
{
    Format = BarcodeFormat.CODE_128,
    Options = new EncodingOptions
    {
        Width = 300,
        Height = 100,
        Margin = 10
    }
};

using var bitmap = writer.Write("PRODUCT-001");
bitmap.Save("output.png", ImageFormat.Png);

// ZXing.Net: create writer, set options, call Write, save Bitmap
using ZXing;
using ZXing.Common;
using ZXing.Windows.Compatibility;
using System.Drawing.Imaging;

var writer = new BarcodeWriter
{
    Format = BarcodeFormat.CODE_128,
    Options = new EncodingOptions
    {
        Width = 300,
        Height = 100,
        Margin = 10
    }
};

using var bitmap = writer.Write("PRODUCT-001");
bitmap.Save("output.png", ImageFormat.Png);

Imports ZXing
Imports ZXing.Common
Imports ZXing.Windows.Compatibility
Imports System.Drawing.Imaging

Dim writer As New BarcodeWriter With {
    .Format = BarcodeFormat.CODE_128,
    .Options = New EncodingOptions With {
        .Width = 300,
        .Height = 100,
        .Margin = 10
    }
}

Using bitmap = writer.Write("PRODUCT-001")
    bitmap.Save("output.png", ImageFormat.Png)
End Using

Imports ZXing
Imports ZXing.Common
Imports ZXing.Windows.Compatibility
Imports System.Drawing.Imaging

Dim writer As New BarcodeWriter With {
    .Format = BarcodeFormat.CODE_128,
    .Options = New EncodingOptions With {
        .Width = 300,
        .Height = 100,
        .Margin = 10
    }
}

Using bitmap = writer.Write("PRODUCT-001")
    bitmap.Save("output.png", ImageFormat.Png)
End Using

Enregistrer dans des formats autres que PNG ou JPEG, enregistrer dans un PDF, ou produire une sortie binaire pour une réponse HTTP nécessitent tous une plomberie System.Drawing supplémentaire que l'appelant met en œuvre.

Approche IronBarcode

L'BarcodeWriter.CreateBarcode d'IronBarcode renvoie un objet GeneratedBarcode qui fournit des méthodes de sortie intégrées via une chaîne fluide:

// IronBarcode: create and save in one fluent chain
BarcodeWriter.CreateBarcode("PRODUCT-001", BarcodeEncoding.Code128)
    .ResizeTo(300, 100)
    .SaveAsPng("output.png");

// IronBarcode: create and save in one fluent chain
BarcodeWriter.CreateBarcode("PRODUCT-001", BarcodeEncoding.Code128)
    .ResizeTo(300, 100)
    .SaveAsPng("output.png");

Imports IronBarCode

' IronBarcode: create and save in one fluent chain
BarcodeWriter.CreateBarcode("PRODUCT-001", BarcodeEncoding.Code128) _
    .ResizeTo(300, 100) _
    .SaveAsPng("output.png")

Imports IronBarCode

' IronBarcode: create and save in one fluent chain
BarcodeWriter.CreateBarcode("PRODUCT-001", BarcodeEncoding.Code128) _
    .ResizeTo(300, 100) _
    .SaveAsPng("output.png")

L'objet GeneratedBarcode expose également .ToPngBinaryData(), .ToJpegBinaryData(), .ToStream(), et .SaveAsPdf() — des cibles de sortie que ZXing.Net exige que les appelants mettent en œuvre eux-mêmes en utilisant System.Drawing.

Référence de mappage d'API

Quand les équipes envisagent de passer de ZXing .NET à IronBarcode

Plusieurs scénarios incitent les équipes de développement à évaluer Code-barres IronBarcode comme alternative à ZXing .NET.

Traitement simultané et à haut débit

Une intégration ZXing .NET qui fonctionne correctement dans une application console monothread peut présenter un comportement non déterministe lorsque le même code est déplacé dans un contrôleur ASP.NET Core gérant des requêtes simultanées, ou dans une tâche en arrière-plan traitant des lots en parallèle. Le modèle d'instance par thread requis par ZXing .NET implique que chaque requête ou tâche parallèle alloue un objet lecteur complet avec son décodeur configuré, l'utilise une seule fois, puis le supprime. À mesure que le volume des demandes augmente, cette pression sur l'allocation devient mesurable. Les équipes qui atteignent ce stade — en particulier celles qui exploitent des pipelines de numérisation à haut débit dans les domaines de la logistique, de l'entreposage ou du traitement de documents — recherchent souvent une bibliothèque dont le modèle de threads n'impose pas cette surcharge à chaque appelant.

Numérisation de documents de formats mixtes

Les applications qui acceptent des documents provenant de tiers rencontrent fréquemment des formats de codes-barres qui n'avaient pas été prévus lors de la configuration de la liste des formats. Une intégration de livraison conçue pour Code 128 permet de recevoir un envoi d'un partenaire à l'aide de codes QR. Un système de dossiers médicaux configuré pour les symboles Data Matrix PDF 417 d'un nouveau fournisseur d'équipement. Dans ZXing .NET, chacun de ces cas produit un résultat nul silencieux plutôt qu'une erreur de décodage, ce qui signifie que le défaut peut ne pas apparaître avant que le traitement en aval n'échoue. Les équipes qui ont subi des pertes dues à des erreurs de formatage silencieuses — en particulier dans les contextes où un code-barres manquant a des conséquences commerciales — commencent à comparer le coût de la maintenance des listes de formats à une bibliothèque qui détecte automatiquement les formats.

Extraction de codes-barres PDF

De nombreux documents commerciaux nous parviennent au format PDF : factures, manifestes d'expédition, dossiers médicaux, certificats de conformité. ZXing .NET ne peut pas les lire directement. Les équipes qui doivent extraire des codes-barres à partir de fichiers PDF finissent par construire et maintenir un pipeline de rendu basé sur ZXing .NET : sélection d'une bibliothèque PDF, gestion de ses dépendances natives, mise en œuvre d'une boucle de rendu de page, gestion de la configuration DPI et écriture d'une logique de nettoyage pour les fichiers temporaires. Ce code d'infrastructure n'est pas une logique de code-barres ; Il existe uniquement pour combler le fossé entre ce que ZXing .NET accepte (images bitmap) et ce que sont réellement les documents commerciaux (PDF). Les équipes qui se retrouvent à devoir gérer ce lien — surtout lorsque la bibliothèque PDF elle-même a ses propres considérations en matière de licence, de déploiement et de plateforme — préfèrent souvent une bibliothèque unique qui gère l'ensemble de la surface de saisie.

Réduction de la complexité de liaison

Les projets qui démarrent sous Windows et sont ensuite déployés sous Linux ou Docker rencontrent directement la fragmentation des liaisons de ZXing.Net : le package de liaison Windows utilise une API différente de celle de la liaison ImageSharp multiplateforme, et passer de l'un à l'autre nécessite de modifier à la fois les références NuGet et le code de chargement d'images. Les équipes qui conteneurisent leurs applications .NET par habitude, ou qui exécutent le même code source sur des machines de développement (Windows ou macOS) et des serveurs de production (Linux), constatent que la maintenance de deux chemins de code pour le chargement d'images ajoute des frictions à chaque modification future de la couche de numérisation.

Considérations courantes en matière de migration

Les équipes qui passent de ZXing .NET à Code-barres IronBarcode doivent prévoir ces changements techniques spécifiques.

Suppression de l'instanciation de BarcodeReader

Chaque appel new BarcodeReader() dans le code est supprimé lors de la migration. Le modèle d'instanciation — création du lecteur, configuration du format, chargement de l'image, appel de décodage — se réduit à un seul appel de méthode statique. Les fichiers qui importent les espaces de noms ZXing, ZXing.Common, ZXing.Windows.Compatibility, ZXing.ImageSharp, et SixLabors.ImageSharp ont ces imports supprimés et remplacés par un seul using IronBarCode;.

Suppression de la configuration PossibleFormats

Le bloc d'affectation reader.Options.PossibleFormats est supprimé à chaque site d'appel. Code-barres IronBarcode effectue une détection de format automatique et n'accepte pas de liste de restriction de format. Le drapeau TryHarder est remplacé par la propriété ReadingSpeed sur BarcodeReaderOptions, qui contrôle l'effort de détection sans restreindre la portée du format.

Nettoyage du paquet de reliure

La migration supprime ZXing.Net, ZXing.Net.Bindings.Windows.Compatibility, toute variante d'ZXing.Net.Bindings.ImageSharp (.V2 / .V3), et tout package PdfiumViewer qui a été ajouté pour prendre en charge la lecture de PDF. Si libgdiplus a été ajouté à un Dockerfile pour prendre en charge System.Drawing via la liaison Windows sur Linux, cette ligne est également supprimée. Code-barres IronBarcode ne nécessite aucune dépendance spécifique à la plateforme dans l'image Docker.

Fonctionnalités supplémentaires IronBarcode

Outre les fonctionnalités décrites dans les sections comparatives ci-dessus, Code-barres IronBarcode offre :

• Code QR avec intégration de logo : Générez des codes QR avec une image de logo personnalisée superposée au centre, avec correction automatique des erreurs pour garantir la scanibilité.
• Personnalisation des couleurs des codes QR : Définissez les couleurs de premier plan et d'arrière-plan des codes QR générés pour un rendu conforme à votre marque.
• Intégration de codes-barres sur les PDF : Inscrivez des codes-barres directement sur les pages PDF existantes à des coordonnées spécifiées, sans bibliothèque PDF séparée.
• Prise en charge des codes-barres GS1 : Lire et générer des codes-barres au format GS1, y compris GS1-128 et GS1 DataBar, utilisés dans les chaînes d'approvisionnement du commerce de détail et des soins de santé.
• Lecture Asynchrone Multi-Threads : Méthodes asynchrones intégrées pour intégrer la lecture de codes-barres dans des pipelines await sans blocage.
• Correction d'Image Propulsée par ML : Amélioration automatique d'images pour les codes-barres endommagés, flous ou à faible contraste que TryHarder ne peut pas récupérer.

Compatibilité .NET et préparation à l'avenir

IronBarcode cible .NET Standard 2.0 et au-delà, offrant une compatibilité avec .NET Framework 4.6.2+, .NET Core 3.1, .NET 5, .NET 6, .NET 7, .NET 8, et .NET 9. La bibliothèque reçoit des mises à jour régulières alignées avec le cycle de publication de .NET par Microsoft, garantissant que la compatibilité avec .NET 10 sera disponible lors de sa sortie ou peu après. ZXing .NET assure également une large compatibilité .NET grâce à ses cibles de package NuGet , et les deux bibliothèques conviennent de ce point de vue aux projets .NET modernes.

Conclusion

ZXing .NET et Code-barres IronBarcode représentent des philosophies différentes en matière de conception de bibliothèques de codes-barres. ZXing .NET est une bibliothèque à état et basée sur des instances qui délègue entièrement la gestion des threads, la spécification du format et le pontage PDF à l'appelant. Code-barres IronBarcode est une bibliothèque sans état, à API statique, qui internalise le multithreading, détecte automatiquement les formats et gère nativement les entrées PDF. La conséquence pratique de cette différence est que le code ZXing .NET dans des contextes de traitement concurrent ou de documents tend à accumuler une infrastructure (modèles d'instances par thread, listes de formats, pipelines de rendu PDF et branches de liaison spécifiques à la plateforme), tandis que le code Code-barres IronBarcode pour les mêmes scénarios ne nécessite aucune de ces structures environnantes.

ZXing .NET est un choix véritablement judicieux pour les projets sans contraintes budgétaires. Sa licence Apache 2.0la rend compatible avec les projets open source et les produits commerciaux qui privilégient les dépendances libres. Dans les environnements contrôlés (formats de codes-barres connus, images nettes, traitement monothread ou légèrement concurrent), il fonctionne de manière fiable. Sa communauté active sur GitHub apporte des réponses rapides aux problèmes, et l'étendue de sa couverture de formats est comparable aux alternatives commerciales. Pour les applications où ces conditions sont réunies, l'avantage de coût de ZXing.Net est réel et ses limitations techniques sont gérables.

IronBarcode s'attaque aux scénarios où les contraintes de conception de ZXing.Net se transforment en coûts opérationnels : API Web concurrentes où l'allocation d'instances par requête est mesurable, pipelines de documents où l'entrée PDF est la norme plutôt que l'exception, numérisation de formats mixtes où les erreurs silencieuses comportent un risque commercial et déploiements multiplateformes où deux packages de liaison signifient deux chemins de code. Dans ces contextes, la licence commerciale de la bibliothèque offre un modèle de traitement par threads qui n'impose pas de gestion d'instances, une détection de format qui ne nécessite aucune maintenance et une prise en charge du format PDF qui ne requiert pas de seconde bibliothèque.

La décision dépend des exigences du projet. Un prototype à format unique, un scanner open source ou un outil à faible volume où le coût est la contrainte principale : ZXing .NET est le choix idéal dans ces cas. Une API web de production traitant des documents provenant de sources externes sur plusieurs threads : c'est là que les hypothèses de conception d'IronBarcode correspondent à la réalité opérationnelle. Pour une analyse plus approfondie de la façon dont les bibliothèques se comparent en termes de taux de détection et de scénarios de numérisation réels, la comparaison des scanners de codes-barres ZXing .NET et IronBarcode fournit une analyse supplémentaire.