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)

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.

Comparaison détaillée des fonctionnalités

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)

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)

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.

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

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

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.

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

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

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

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

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

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.

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

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

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.

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.

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.