Aspose.BarCode for .NET vs IronBarcode : Comparaison de la bibliothèque de codes-barres C#

Le modèle de lecture axé sur le format

L'API de lecture d'Aspose.BarCode repose sur l'hypothèse que l'appelant connaît le format du code-barres :

// Aspose.BarCode: must specify format or use slow AllSupportedTypes
using Aspose.BarCode.BarCodeRecognition;

var reader = new BarCodeReader("barcode.png", DecodeType.Code128);
reader.ReadBarCodes();
foreach (var result in reader.FoundBarCodes)
    Console.WriteLine($"{result.CodeTypeName}: {result.CodeText}");

// Aspose.BarCode: must specify format or use slow AllSupportedTypes
using Aspose.BarCode.BarCodeRecognition;

var reader = new BarCodeReader("barcode.png", DecodeType.Code128);
reader.ReadBarCodes();
foreach (var result in reader.FoundBarCodes)
    Console.WriteLine($"{result.CodeTypeName}: {result.CodeText}");

Imports Aspose.BarCode.BarCodeRecognition

' Aspose.BarCode: must specify format or use slow AllSupportedTypes
Dim reader As New BarCodeReader("barcode.png", DecodeType.Code128)
reader.ReadBarCodes()
For Each result In reader.FoundBarCodes
    Console.WriteLine($"{result.CodeTypeName}: {result.CodeText}")
Next

Lorsque le format est connu, ce modèle convient parfaitement. Le problème, c'est que même en connaissant le format, un système d'achat traitant les factures fournisseurs ne peut garantir que chaque fournisseur utilise le même type de code-barres. Un système de gestion de documents qui accepte les téléchargements des utilisateurs ne peut pas prédire le format utilisé par un scanner. Dans ces cas, DecodeType.AllSupportedTypes est la solution de repli, et elle est nettement plus lente qu'une liste de types de décodage ciblée.

Le décodeur doit également être mis au rebut :

using var reader = new BarCodeReader("barcode.png", DecodeType.Code128);

using var reader = new BarCodeReader("barcode.png", DecodeType.Code128);

Ne pas utiliser using est une fuite de ressources. Le BarcodeGenerator met également en œuvre le IDisposable, bien que les conséquences de ne pas s'en débarrasser soient moins graves. Dans les deux cas, vous gérez la durée de vie des objets, ce qu'une API de fabrique statique gérerait automatiquement.

Comparaison détaillée des fonctionnalités

Approche Aspose.BarCode

Aspose.BarCode utilise une classe BarcodeGenerator avec une hiérarchie Parameters pour la configuration. Un appel de génération minimal nécessite trois étapes : l'instanciation, l'appel de sauvegarde et la spécification du format. L'utilisation réelle nécessite généralement de naviguer dans generator.Parameters.Barcode.* :

using Aspose.BarCode.Generation;
using System.Drawing;

var generator = new BarcodeGenerator(EncodeTypes.Code128, "ITEM-12345");

// Common customizations require navigating a deep parameter hierarchy
generator.Parameters.Barcode.XDimension.Pixels = 2;
generator.Parameters.Barcode.BarHeight.Pixels = 100;
generator.Parameters.Barcode.CodeTextParameters.Location = CodeLocation.Below;
generator.Parameters.Barcode.CodeTextParameters.Font.FamilyName = "Arial";
generator.Parameters.Barcode.Padding.Left.Pixels = 10;
generator.Parameters.Barcode.Padding.Right.Pixels = 10;
generator.Parameters.BackColor = Color.White;
generator.Parameters.Resolution = 300;

generator.Save("barcode.png", BarCodeImageFormat.Png);

using Aspose.BarCode.Generation;
using System.Drawing;

var generator = new BarcodeGenerator(EncodeTypes.Code128, "ITEM-12345");

// Common customizations require navigating a deep parameter hierarchy
generator.Parameters.Barcode.XDimension.Pixels = 2;
generator.Parameters.Barcode.BarHeight.Pixels = 100;
generator.Parameters.Barcode.CodeTextParameters.Location = CodeLocation.Below;
generator.Parameters.Barcode.CodeTextParameters.Font.FamilyName = "Arial";
generator.Parameters.Barcode.Padding.Left.Pixels = 10;
generator.Parameters.Barcode.Padding.Right.Pixels = 10;
generator.Parameters.BackColor = Color.White;
generator.Parameters.Resolution = 300;

generator.Save("barcode.png", BarCodeImageFormat.Png);

Imports Aspose.BarCode.Generation
Imports System.Drawing

Dim generator As New BarcodeGenerator(EncodeTypes.Code128, "ITEM-12345")

' Common customizations require navigating a deep parameter hierarchy
generator.Parameters.Barcode.XDimension.Pixels = 2
generator.Parameters.Barcode.BarHeight.Pixels = 100
generator.Parameters.Barcode.CodeTextParameters.Location = CodeLocation.Below
generator.Parameters.Barcode.CodeTextParameters.Font.FamilyName = "Arial"
generator.Parameters.Barcode.Padding.Left.Pixels = 10
generator.Parameters.Barcode.Padding.Right.Pixels = 10
generator.Parameters.BackColor = Color.White
generator.Parameters.Resolution = 300

generator.Save("barcode.png", BarCodeImageFormat.Png)

Chaque personnalisation navigue dans generator.Parameters.Barcode.*, qui est une hiérarchie d'objets à plusieurs niveaux. Ce n'est pas complexe une fois qu'on l'a mémorisé — mais cela nécessite de le mémoriser.

Approche IronBarcode

IronBarcode remplace la hiérarchie des paramètres par une chaîne de méthodes fluide. Les paramètres par défaut donnent des résultats corrects dans la plupart des cas d'utilisation, et la personnalisation s'effectue directement dans le code :

using IronBarCode;

// Default settings work for most cases
BarcodeWriter.CreateBarcode("ITEM-12345", BarcodeEncoding.Code128)
    .SaveAsPng("barcode.png");

// Customization through a fluent chain
BarcodeWriter.CreateBarcode("ITEM-12345", BarcodeEncoding.Code128)
    .ResizeTo(400, 100)
    .SaveAsPng("barcode.png");

// Get as bytes instead of saving to disk
byte[] pngData = BarcodeWriter.CreateBarcode("ITEM-12345", BarcodeEncoding.Code128)
    .ToPngBinaryData();

using IronBarCode;

// Default settings work for most cases
BarcodeWriter.CreateBarcode("ITEM-12345", BarcodeEncoding.Code128)
    .SaveAsPng("barcode.png");

// Customization through a fluent chain
BarcodeWriter.CreateBarcode("ITEM-12345", BarcodeEncoding.Code128)
    .ResizeTo(400, 100)
    .SaveAsPng("barcode.png");

// Get as bytes instead of saving to disk
byte[] pngData = BarcodeWriter.CreateBarcode("ITEM-12345", BarcodeEncoding.Code128)
    .ToPngBinaryData();

Imports IronBarCode

' Default settings work for most cases
BarcodeWriter.CreateBarcode("ITEM-12345", BarcodeEncoding.Code128) _
    .SaveAsPng("barcode.png")

' Customization through a fluent chain
BarcodeWriter.CreateBarcode("ITEM-12345", BarcodeEncoding.Code128) _
    .ResizeTo(400, 100) _
    .SaveAsPng("barcode.png")

' Get as bytes instead of saving to disk
Dim pngData As Byte() = BarcodeWriter.CreateBarcode("ITEM-12345", BarcodeEncoding.Code128) _
    .ToPngBinaryData()

Pour les codes QR, l'API de génération de QR codes d'IronBarcode inclut la prise en charge des logos de marque sans composition manuelle d'image :

using IronBarCode;
using IronSoftware.Drawing;

// With brand logo — built in, no manual image overlay needed
QRCodeWriter.CreateQrCode("https://example.com", 500)
    .AddBrandLogo("logo.png")
    .SaveAsPng("qr-branded.png");

// With high error correction (recommended when using a logo)
QRCodeWriter.CreateQrCode(
    "https://example.com",
    500,
    QRCodeWriter.QrErrorCorrectionLevel.Highest)
    .AddBrandLogo("logo.png")
    .SaveAsPng("qr-branded-high-ecc.png");

// Colored QR code
QRCodeWriter.CreateQrCode("https://example.com", 300)
    .ChangeBarCodeColor(Color.DarkBlue)
    .SaveAsPng("qr-colored.png");

using IronBarCode;
using IronSoftware.Drawing;

// With brand logo — built in, no manual image overlay needed
QRCodeWriter.CreateQrCode("https://example.com", 500)
    .AddBrandLogo("logo.png")
    .SaveAsPng("qr-branded.png");

// With high error correction (recommended when using a logo)
QRCodeWriter.CreateQrCode(
    "https://example.com",
    500,
    QRCodeWriter.QrErrorCorrectionLevel.Highest)
    .AddBrandLogo("logo.png")
    .SaveAsPng("qr-branded-high-ecc.png");

// Colored QR code
QRCodeWriter.CreateQrCode("https://example.com", 300)
    .ChangeBarCodeColor(Color.DarkBlue)
    .SaveAsPng("qr-colored.png");

Imports IronBarCode
Imports IronSoftware.Drawing

' With brand logo — built in, no manual image overlay needed
QRCodeWriter.CreateQrCode("https://example.com", 500) _
    .AddBrandLogo("logo.png") _
    .SaveAsPng("qr-branded.png")

' With high error correction (recommended when using a logo)
QRCodeWriter.CreateQrCode( _
    "https://example.com", _
    500, _
    QRCodeWriter.QrErrorCorrectionLevel.Highest) _
    .AddBrandLogo("logo.png") _
    .SaveAsPng("qr-branded-high-ecc.png")

' Colored QR code
QRCodeWriter.CreateQrCode("https://example.com", 300) _
    .ChangeBarCodeColor(Color.DarkBlue) _
    .SaveAsPng("qr-colored.png")

Aspose.BarCode nécessite un dessin GDI+ manuel pour superposer un logo sur un code QR - en générant l'image du code-barres, puis en utilisant System.Drawing.Graphics pour composer le logo centré sur celui-ci. Le AddBrandLogo d'IronBarcode gère cela en un seul appel et définit automatiquement la correction d'erreur de manière appropriée.

Approche Aspose.BarCode

Aspose.BarCode ne prend pas en charge nativement le format PDF. Pour lire un code-barres à partir d'un PDF avec Aspose, vous avez besoin d'Aspose.PDF pour charger le PDF et convertir les pages en images, et d'Aspose.BarCode pour scanner ces images. Ce sont deux produits par abonnement. Les deux nécessitent une activation de licence. Au total, cela représente un coût annuel de 1 998 $ à 9 990 $ pour ce que la plupart des développeurs considèrent comme une fonctionnalité unique.

// Requires both Aspose.PDF (separate license) and Aspose.BarCode
using Aspose.Pdf;
using Aspose.Pdf.Devices;
using Aspose.BarCode.BarCodeRecognition;
using System.IO;

public List<string> ReadBarcodesFromPdf(string pdfPath)
{
    var barcodeValues = new List<string>();

    // Step 1: Load and render the PDF using Aspose.PDF
    var pdfDocument = new Aspose.Pdf.Document(pdfPath);
    var resolution = new Resolution(300);
    var device = new PngDevice(resolution);

    for (int pageNum = 1; pageNum <= pdfDocument.Pages.Count; pageNum++)
    {
        using var pageStream = new MemoryStream();
        device.Process(pdfDocument.Pages[pageNum], pageStream);
        pageStream.Seek(0, SeekOrigin.Begin);

        // Step 2: Scan the rendered image for barcodes using Aspose.BarCode
        using var reader = new BarCodeReader(pageStream, DecodeType.AllSupportedTypes);
        foreach (var result in reader.ReadBarCodes())
        {
            barcodeValues.Add(result.CodeText);
        }
    }

    return barcodeValues;
}

// Requires both Aspose.PDF (separate license) and Aspose.BarCode
using Aspose.Pdf;
using Aspose.Pdf.Devices;
using Aspose.BarCode.BarCodeRecognition;
using System.IO;

public List<string> ReadBarcodesFromPdf(string pdfPath)
{
    var barcodeValues = new List<string>();

    // Step 1: Load and render the PDF using Aspose.PDF
    var pdfDocument = new Aspose.Pdf.Document(pdfPath);
    var resolution = new Resolution(300);
    var device = new PngDevice(resolution);

    for (int pageNum = 1; pageNum <= pdfDocument.Pages.Count; pageNum++)
    {
        using var pageStream = new MemoryStream();
        device.Process(pdfDocument.Pages[pageNum], pageStream);
        pageStream.Seek(0, SeekOrigin.Begin);

        // Step 2: Scan the rendered image for barcodes using Aspose.BarCode
        using var reader = new BarCodeReader(pageStream, DecodeType.AllSupportedTypes);
        foreach (var result in reader.ReadBarCodes())
        {
            barcodeValues.Add(result.CodeText);
        }
    }

    return barcodeValues;
}

Imports Aspose.Pdf
Imports Aspose.Pdf.Devices
Imports Aspose.BarCode.BarCodeRecognition
Imports System.IO

Public Function ReadBarcodesFromPdf(pdfPath As String) As List(Of String)
    Dim barcodeValues As New List(Of String)()

    ' Step 1: Load and render the PDF using Aspose.PDF
    Dim pdfDocument As New Aspose.Pdf.Document(pdfPath)
    Dim resolution As New Resolution(300)
    Dim device As New PngDevice(resolution)

    For pageNum As Integer = 1 To pdfDocument.Pages.Count
        Using pageStream As New MemoryStream()
            device.Process(pdfDocument.Pages(pageNum), pageStream)
            pageStream.Seek(0, SeekOrigin.Begin)

            ' Step 2: Scan the rendered image for barcodes using Aspose.BarCode
            Using reader As New BarCodeReader(pageStream, DecodeType.AllSupportedTypes)
                For Each result In reader.ReadBarCodes()
                    barcodeValues.Add(result.CodeText)
                Next
            End Using
        End Using
    Next

    Return barcodeValues
End Function

Il s'agit de deux configurations de licence, de deux instructions d'utilisation de deux espaces de noms, d'un pipeline de rendu, d'une gestion de flux de mémoire et d'une boucle imbriquée. Il utilise également DecodeType.AllSupportedTypes parce qu'au moment de l'extraction de l'image, vous ne connaissez généralement pas le format utilisé par le code-barres.

Approche IronBarcode

IronBarcode gère en interne l'analyse des fichiers PDF, le rendu des pages et la détection des codes-barres. Vous appelez Read avec un chemin d'accès se terminant par .pdf, et il renvoie des résultats de code-barres qui incluent result.PageNumberafin que vous sachiez de quelle page chacun provient. Pas de deuxième paquet, pas de deuxième licence, pas de code de rendu.

using IronBarCode;

public List<string> ReadBarcodesFromPdf(string pdfPath)
{
    var results = BarcodeReader.Read(pdfPath);
    return results.Select(r => r.Value).ToList();
}

using IronBarCode;

public List<string> ReadBarcodesFromPdf(string pdfPath)
{
    var results = BarcodeReader.Read(pdfPath);
    return results.Select(r => r.Value).ToList();
}

Imports IronBarCode

Public Function ReadBarcodesFromPdf(pdfPath As String) As List(Of String)
    Dim results = BarcodeReader.Read(pdfPath)
    Return results.Select(Function(r) r.Value).ToList()
End Function

// With page number context
var results = BarcodeReader.Read("invoice-batch.pdf");
foreach (var barcode in results)
{
    Console.WriteLine($"Page {barcode.PageNumber}: [{barcode.Format}] {barcode.Value}");
}

// With page number context
var results = BarcodeReader.Read("invoice-batch.pdf");
foreach (var barcode in results)
{
    Console.WriteLine($"Page {barcode.PageNumber}: [{barcode.Format}] {barcode.Value}");
}

Imports System

' With page number context
Dim results = BarcodeReader.Read("invoice-batch.pdf")
For Each barcode In results
    Console.WriteLine($"Page {barcode.PageNumber}: [{barcode.Format}] {barcode.Value}")
Next

La documentation de lecture des fichiers PDF IronBarcode couvre le traitement par lots multipages et les options de filtrage par plage de pages.

Approche Aspose.BarCode

DecodeType.AllSupportedTypes est la solution d'Aspose pour les scénarios de format inconnu. La documentation d'Aspose reconnaît elle-même que cette méthode est plus lente que la spécification d'une liste ciblée, car le décodeur parcourt séquentiellement chaque symbologie connue. Pour le traitement à grand volume — un entrepôt scannant des milliers d'étiquettes par minute —, cette différence de performance n'est pas négligeable.

using Aspose.BarCode.BarCodeRecognition;

// AllSupportedTypes scans for every known format — significantly slower
using var reader = new BarCodeReader("unknown-format.png");
reader.SetBarCodeReadType(DecodeType.AllSupportedTypes);
foreach (var result in reader.ReadBarCodes())
{
    Console.WriteLine($"{result.CodeTypeName}: {result.CodeText}");
}

using Aspose.BarCode.BarCodeRecognition;

// AllSupportedTypes scans for every known format — significantly slower
using var reader = new BarCodeReader("unknown-format.png");
reader.SetBarCodeReadType(DecodeType.AllSupportedTypes);
foreach (var result in reader.ReadBarCodes())
{
    Console.WriteLine($"{result.CodeTypeName}: {result.CodeText}");
}

Imports Aspose.BarCode.BarCodeRecognition

' AllSupportedTypes scans for every known format — significantly slower
Using reader As New BarCodeReader("unknown-format.png")
    reader.SetBarCodeReadType(DecodeType.AllSupportedTypes)
    For Each result In reader.ReadBarCodes()
        Console.WriteLine($"{result.CodeTypeName}: {result.CodeText}")
    Next
End Using

Approche IronBarcode

Il n'existe pas de " mode lent " et de " mode rapide " basés sur la connaissance du format. La détection d'IronBarcode utilise le même algorithme, que l'image contienne un Code 128 ou un DataMatrix. Si vous souhaitez faire des compromis entre performance et précision, l'option ReadingSpeed vous permet de le faire sans avoir besoin de connaître le format :

using IronBarCode;

// The same call regardless of format — always auto-detects
var results = BarcodeReader.Read("unknown-format.png");
foreach (var result in results)
{
    Console.WriteLine($"{result.Format}: {result.Value}");
}

using IronBarCode;

// The same call regardless of format — always auto-detects
var results = BarcodeReader.Read("unknown-format.png");
foreach (var result in results)
{
    Console.WriteLine($"{result.Format}: {result.Value}");
}

Imports IronBarCode

' The same call regardless of format — always auto-detects
Dim results = BarcodeReader.Read("unknown-format.png")
For Each result In results
    Console.WriteLine($"{result.Format}: {result.Value}")
Next

using IronBarCode;

var options = new BarcodeReaderOptions
{
    Speed = ReadingSpeed.Balanced,
    ExpectMultipleBarcodes = true,
    MaxParallelThreads = 4
};

var results = BarcodeReader.Read("document.png", options);

using IronBarCode;

var options = new BarcodeReaderOptions
{
    Speed = ReadingSpeed.Balanced,
    ExpectMultipleBarcodes = true,
    MaxParallelThreads = 4
};

var results = BarcodeReader.Read("document.png", options);

Imports IronBarCode

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

Dim results = BarcodeReader.Read("document.png", options)

ReadingSpeed.Faster donne la priorité au débit. ReadingSpeed.Detailed donne la priorité à la précision sur les images endommagées ou à faible contraste. Aucun des deux ne nécessite de connaître le format à l'avance. Consultez les options de lecture IronBarcode pour connaître l'ensemble des paramètres de réglage.

Le renouvellement de l'abonnement est arrivé

Le renouvellement annuel des abonnements est le moment où les équipes réexaminent le plus souvent les décisions relatives à la bibliothèque. Si Aspose.BarCode est le seul produit Aspose de la pile, le coût annuel de 999 $ à 4 995 $ pour la fonctionnalité de code-barres justifie une comparaison. La conversation se déroule généralement ainsi : " Nous payons cela chaque année, indéfiniment. " " Combien coûte Code-barres IronBarcode une fois installé ? " Au niveau Professional (2 999 $ pour 10 développeurs), Code-barres IronBarcode est rentabilisé dès la première année grâce à la licence Site.

Pour les équipes utilisant Aspose.Total — où Aspose.BarCode est intégré à plus de 20 autres produits — le calcul est différent. Le coût marginal d'Aspose.BarCode au sein de ce pack tend vers zéro. Ces équipes ont moins de raisons de changer.

La prise en charge des fichiers PDF devient une exigence

De nombreux projets commencent par la lecture de codes-barres à partir d'images, puis ajoutent la prise en charge des fichiers PDF ultérieurement, lorsqu'un acteur clé se rend compte que les documents entrants sont des PDF et non des fichiers image. À ce stade, une équipe Aspose.BarCode doit prendre une décision : ajouter Aspose.PDF (un autre abonnement), trouver un moteur de rendu PDF tiers ou réévaluer la bibliothèque de codes-barres.

L'ajout d'Aspose.PDF répond au besoin immédiat, mais double le coût de l'abonnement. Le recours à un moteur de rendu tiers ajoute une dépendance et un effort d'intégration. Il en résulte souvent une réévaluation de la bibliothèque de codes-barres — et la découverte Code-barres IronBarcode lit nativement les PDF moyennant un paiement unique.

Scénarios de production au format inconnu

Les applications destinées aux clients qui acceptent le téléchargement de documents ne peuvent pas contrôler le format du code-barres utilisé par un document téléchargé. Si l'application a été construite en supposant des entrées de Code 128 et qu'un client télécharge une étiquette DataMatrix, un code en dur DecodeType.Code128 renverra silencieusement aucun résultat. Le passage à DecodeType.AllSupportedTypes corrige l'erreur mais introduit un coût de performance.

Les équipes qui ont rencontré ce problème - ajouter de plus en plus de valeurs DecodeType à leur configuration de lecteur à mesure que de nouveaux formats apparaissent en production - finissent souvent par maintenir une liste qui doit être mise à jour à chaque fois qu'une nouvelle source de format est ajoutée. La détection automatique d'IronBarcode rend cette liste inutile.

Déploiements dans le cloud et les conteneurs

Le système de licences basé sur des fichiers d'Aspose.BarCode ajoute une étape de déploiement : le fichier de licence doit être accessible lors de l'exécution à partir d'un chemin que l'application peut lire. Dans un flux de travail GitOps, le fichier de licence se retrouve soit dans le contrôle de version (un risque pour la sécurité), soit doit être injecté via un volume secret monté. L'approche d'IronBarcode basée sur les clés s'intègre parfaitement aux secrets Kubernetes et aux variables secrètes CI/CD, sans aucun fichier à gérer dans l'image du conteneur.

Association des noms de propriétés

L'erreur de compilation la plus courante après l'échange de paquets est le renommage de result.CodeTexten result.Value. Une recherche dans l'ensemble du code source permet de le faire rapidement :

grep -r "\.CodeText" --include="*.cs" .
grep -r "\.CodeTypeName" --include="*.cs" .

grep -r "\.CodeText" --include="*.cs" .
grep -r "\.CodeTypeName" --include="*.cs" .

result.CodeText devient result.Value. result.CodeTypeNamedevient result.Format.ToString(). La propriété result.Format est une valeur BarcodeEncoding enum, qui permet également des comparaisons typées lorsque cela est nécessaire.

Suppression du type de décodage

Chaque référence DecodeType.* dans la base de code peut être supprimée :

grep -r "DecodeType\." --include="*.cs" .

grep -r "DecodeType\." --include="*.cs" .

Si un DecodeType spécifique a été listé pour améliorer les performances sur un format connu, ReadingSpeed.Faster dans BarcodeReaderOptions fournit un avantage similaire sans exigence de connaissance du format.

Modification de l'initialisation de la licence

Aspose.BarCode utilise un fichier .lic chargé via license.SetLicense(). Code-barres IronBarcode utilise une clé de type chaîne de caractères :

IronBarCode.License.LicenseKey =
    Environment.GetEnvironmentVariable("IRONBARCODE_LICENSE")
    ?? throw new InvalidOperationException("IronBarcode license key not configured");

IronBarCode.License.LicenseKey =
    Environment.GetEnvironmentVariable("IRONBARCODE_LICENSE")
    ?? throw new InvalidOperationException("IronBarcode license key not configured");

Imports IronBarCode
Imports System

License.LicenseKey = If(Environment.GetEnvironmentVariable("IRONBARCODE_LICENSE"), Throw New InvalidOperationException("IronBarcode license key not configured"))

Supprimez le fichier .lic du référentiel et des artefacts de construction. Dans Docker, supprimez la ligne COPY Aspose.BarCode.lic et remplacez-la par une entrée ENV IRONBARCODE_LICENSE.

Correspondance entre les types d'encodage et l'encodage des codes-barres

EncodeTypes.QR correspond à BarcodeEncoding.QRCode - la différence de dénomination est l'endroit où les équipes rencontrent le plus souvent la première erreur de compilation après avoir migré le code de génération. Tous les autres mappages sont des équivalents directs avec une dénomination cohérente.