Ce guide décrit l'intégralité du processus de migration d'OnBarcode vers IronBarcode . Il aborde la modification de la configuration en trois étapes, fournit des exemples de code avant et après pour chaque modèle courant, établit une correspondance entre l'API Code-barres et ses équivalents Code-barres IronBarcode , documente les problèmes qui surviennent lors de la migration et fournit une liste de contrôle des termes de recherche pour auditer votre base de code avant de considérer la migration comme terminée.

Pourquoi migrer depuis Code-barres ?

Surcharge d'Acquisition à Deux SKU : Code-barres publie des prix perpétuels pour le SDK de Générateur (seulement linéaire et niveaux linéaire + 2D) et liste le SDK lecteur comme un produit tarifé séparément. Une organisation qui a besoin des deux capacités doit compléter deux processus d'achat contre deux SKU — sélectionnant le bon niveau de Générateur pour les symbologies utilisées, puis achetant le lecteur séparément — avant que le coût total ne soit établi. Le frottement est la duplication à travers deux achats plutôt qu'un seul poste.

Surcharge liée à la séparation des produits : la génération et la lecture sont des produits distincts avec des packages NuGet distincts, des espaces de noms de licence distincts, des clés de licence distinctes et des calendriers de versions distincts. Un projet utilisant les deux produits doit configurer deux clés de licence au démarrage, suivre deux versions de package lors des mises à jour et tenir compte de deux cycles de publication indépendants. Lorsque l'exigence de lecture est ajoutée à un projet initialement axé uniquement sur la génération, l'ensemble du processus d'approvisionnement et d'intégration doit être répété pour le second produit.

Lacunes du flux de travail PDF : Code-barres ne prend pas en charge nativement la lecture des codes-barres dans les documents PDF. Les projets qui traitent les codes-barres intégrés aux factures, aux manifestes d'expédition, aux bons de commande ou aux numérisations d'archives doivent acquérir une bibliothèque de rendu PDF vers image distincte, l'intégrer au processus, gérer sa licence séparément et transmettre les pages rendues au SDK Code-barres Reader une par une. Il en résulte une solution à deux dépendances alors qu'une solution à une seule dépendance suffirait.

Verbrosité de l'API : Le générateur Code-barres nécessite l'instanciation d'un objet Barcode, l'attribution de plusieurs propriétés — y compris des propriétés avec des valeurs par défaut raisonnables telles que Resolution, BarWidth, et BarHeight — puis l'appel d'une méthode de génération. Le même résultat peut être obtenu avec beaucoup moins de code en utilisant une API de fabrique statique. Appliqué à la génération par lots, le modèle d'affectation de propriétés produit de grands volumes de code répétitif qui doivent être revus et maintenus.

Le problème fondamental

La configuration à double licence constitue le principal point de friction pour tout projet nécessitant à la fois la génération et la lecture. Code-barres nécessite deux appels distincts à deux espaces de noms de licences distincts au démarrage :

// OnBarcode: two products, two DLL references, no runtime key
// Code-barres uses pre-licensed DLLs — the purchased DLL is already activated.
// There is no runtime SetLicense() call; the license is baked into the downloaded assembly.
using OnBarcode.Barcode;
using OnBarcode.Barcode;

// OnBarcode: two products, two DLL references, no runtime key
// Code-barres uses pre-licensed DLLs — the purchased DLL is already activated.
// There is no runtime SetLicense() call; the license is baked into the downloaded assembly.
using OnBarcode.Barcode;
using OnBarcode.Barcode;

IronBarcode réduit cela à une seule attribution de propriété qui couvre toutes les fonctionnalités — génération, lecture, prise en charge des PDF et opérations par lots — sous une seule clé :

// IronBarcode: one package, one key, one line
using IronBarCode;

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

// IronBarcode: one package, one key, one line
using IronBarCode;

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

Imports IronBarCode

IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY"

Imports IronBarCode

IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY"

Chaque opération de code-barres dans l'application — qu'elle génère, lise ou traite des PDF — s'exécute sous cette configuration unique.

Comparaison des fonctionnalités Code-barres IronBarcode et d'OnBarcode

Démarrage rapide : Migration d'OnBarcode vers IronBarcode

Étape 1 : Supprimer les références au package OnBarcode

Si votre projet utilise les packages NuGet , supprimez les deux :

dotnet remove package OnBarcode.Barcode.Generator
dotnet remove package OnBarcode.Barcode.Reader

dotnet remove package OnBarcode.Barcode.Generator
dotnet remove package OnBarcode.Barcode.Reader

Si votre projet utilise l'ancienne distribution basée sur des DLLs, supprimez également le bloc de référence manuel de votre .csproj:

<!-- Remove this block entirely -->
<ItemGroup>
  <Reference Include="OnBarcode.Barcode">
    <HintPath>lib\OnBarcode.Barcode.dll</HintPath>
    <Private>true</Private>
  </Reference>
</ItemGroup>

<!-- Remove this block entirely -->
<ItemGroup>
  <Reference Include="OnBarcode.Barcode">
    <HintPath>lib\OnBarcode.Barcode.dll</HintPath>
    <Private>true</Private>
  </Reference>
</ItemGroup>

Supprimez les fichiers DLL du répertoire lib/ ou partout où ils sont stockés. Laisser les anciens assemblages en place parallèlement au nouveau package NuGet entraînera des conflits d'espace de noms lors de la compilation.

Étape 2 : Ajouter un IronBarcode

Un seul forfait couvre la génération, la lecture et la prise en charge des fichiers PDF :

dotnet add package IronBarcode

dotnet add package IronBarcode

Aucun deuxième paquet n'est nécessaire pour la lecture. Aucun deuxième package n'est requis pour la prise en charge des fichiers PDF.

Étape 3 : Mettre à jour les espaces de noms et remplacer la configuration de la double licence

Remplacez les deux directives Code-barres using par une seule importation IronBarcode :

// Remove
using OnBarcode.Barcode;
using OnBarcode.Barcode;

// Add
using IronBarCode;

// Remove
using OnBarcode.Barcode;
using OnBarcode.Barcode;

// Add
using IronBarCode;

Imports IronBarCode

Imports IronBarCode

Remplacez les références DLL doubles par une seule assignation de clé. Insérez ceci une seule fois, au début du démarrage de l'application, avant toute opération de lecture de code-barres :

// Remove the Code-barres DLL references and using directives
// Add
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";

// Remove the Code-barres DLL references and using directives
// Add
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";

Exemples de migration de code

Génération de codes-barres Code 128

Le cas de base du Code 128 illustre le modèle d'affectation de propriété par rapport au modèle de fabrique statique.

Approche OnBarcode :

using OnBarcode.Barcode;

Linear barcode = new Linear();
barcode.Type = BarcodeType.CODE128;
barcode.Data = "SHIP-2024-001";
barcode.Resolution = 96;
barcode.X = 1;
barcode.BarcodeHeight = 80;
barcode.ShowText = true;
barcode.drawBarcode("shipping-label.png");

using OnBarcode.Barcode;

Linear barcode = new Linear();
barcode.Type = BarcodeType.CODE128;
barcode.Data = "SHIP-2024-001";
barcode.Resolution = 96;
barcode.X = 1;
barcode.BarcodeHeight = 80;
barcode.ShowText = true;
barcode.drawBarcode("shipping-label.png");

Imports OnBarcode.Barcode

Dim barcode As New Linear()
barcode.Type = BarcodeType.CODE128
barcode.Data = "SHIP-2024-001"
barcode.Resolution = 96
barcode.X = 1
barcode.BarcodeHeight = 80
barcode.ShowText = True
barcode.drawBarcode("shipping-label.png")

Imports OnBarcode.Barcode

Dim barcode As New Linear()
barcode.Type = BarcodeType.CODE128
barcode.Data = "SHIP-2024-001"
barcode.Resolution = 96
barcode.X = 1
barcode.BarcodeHeight = 80
barcode.ShowText = True
barcode.drawBarcode("shipping-label.png")

Approche IronBarcode :

using IronBarCode;

BarcodeWriter.CreateBarcode("SHIP-2024-001", BarcodeEncoding.Code128)
    .SaveAsPng("shipping-label.png");

using IronBarCode;

BarcodeWriter.CreateBarcode("SHIP-2024-001", BarcodeEncoding.Code128)
    .SaveAsPng("shipping-label.png");

Imports IronBarCode

BarcodeWriter.CreateBarcode("SHIP-2024-001", BarcodeEncoding.Code128) _
    .SaveAsPng("shipping-label.png")

Imports IronBarCode

BarcodeWriter.CreateBarcode("SHIP-2024-001", BarcodeEncoding.Code128) _
    .SaveAsPng("shipping-label.png")

Les données et le type d'encodage sont passés en tant qu'arguments à CreateBarcode. Des propriétés telles que la résolution et la hauteur des barres ne sont pas nécessaires pour produire une sortie scannable ; Les paramètres par défaut conviennent à la plupart des utilisations. Lorsque des dimensions personnalisées sont nécessaires, elles peuvent être ajoutées sous forme d'appels enchaînés entre CreateBarcode et SaveAsPng sans introduire d'état mutable de l'objet.

Génération de code QR avec logo

Les codes QR avec logo nécessitent que Code-barres revienne à System.Drawing pour l'étape de superposition de l'image. Code-barres IronBarcode fournit cela en tant qu'opération intégrée.

Approche OnBarcode :

using OnBarcode.Barcode;
using System.Drawing;

QRCode qr = new QRCode();
qr.Data = "https://example.com/product/4891";
qr.QRCodeDataMode = QRCodeDataMode.Auto;
qr.QRCodeECL = QRCodeECL.H; // H-level error correction required for logo overlay

Image qrImage = qr.drawBarcode();

using (Graphics g = Graphics.FromImage(qrImage))
{
    Image logo = Image.FromFile("brand-logo.png");
    int logoSize = qrImage.Width / 5;
    int x = (qrImage.Width - logoSize) / 2;
    int y = (qrImage.Height - logoSize) / 2;
    g.DrawImage(logo, x, y, logoSize, logoSize);
}

qrImage.Save("product-qr.png");

using OnBarcode.Barcode;
using System.Drawing;

QRCode qr = new QRCode();
qr.Data = "https://example.com/product/4891";
qr.QRCodeDataMode = QRCodeDataMode.Auto;
qr.QRCodeECL = QRCodeECL.H; // H-level error correction required for logo overlay

Image qrImage = qr.drawBarcode();

using (Graphics g = Graphics.FromImage(qrImage))
{
    Image logo = Image.FromFile("brand-logo.png");
    int logoSize = qrImage.Width / 5;
    int x = (qrImage.Width - logoSize) / 2;
    int y = (qrImage.Height - logoSize) / 2;
    g.DrawImage(logo, x, y, logoSize, logoSize);
}

qrImage.Save("product-qr.png");

Imports OnBarcode.Barcode
Imports System.Drawing

Dim qr As New QRCode()
qr.Data = "https://example.com/product/4891"
qr.QRCodeDataMode = QRCodeDataMode.Auto
qr.QRCodeECL = QRCodeECL.H ' H-level error correction required for logo overlay

Dim qrImage As Image = qr.drawBarcode()

Using g As Graphics = Graphics.FromImage(qrImage)
    Dim logo As Image = Image.FromFile("brand-logo.png")
    Dim logoSize As Integer = qrImage.Width \ 5
    Dim x As Integer = (qrImage.Width - logoSize) \ 2
    Dim y As Integer = (qrImage.Height - logoSize) \ 2
    g.DrawImage(logo, x, y, logoSize, logoSize)
End Using

qrImage.Save("product-qr.png")

Imports OnBarcode.Barcode
Imports System.Drawing

Dim qr As New QRCode()
qr.Data = "https://example.com/product/4891"
qr.QRCodeDataMode = QRCodeDataMode.Auto
qr.QRCodeECL = QRCodeECL.H ' H-level error correction required for logo overlay

Dim qrImage As Image = qr.drawBarcode()

Using g As Graphics = Graphics.FromImage(qrImage)
    Dim logo As Image = Image.FromFile("brand-logo.png")
    Dim logoSize As Integer = qrImage.Width \ 5
    Dim x As Integer = (qrImage.Width - logoSize) \ 2
    Dim y As Integer = (qrImage.Height - logoSize) \ 2
    g.DrawImage(logo, x, y, logoSize, logoSize)
End Using

qrImage.Save("product-qr.png")

Approche IronBarcode :

using IronBarCode;

var qr = QRCodeWriter.CreateQrCodeWithLogo("https://example.com/product/4891", "brand-logo.png", 500);
qr.SaveAsPng("product-qr.png");

using IronBarCode;

var qr = QRCodeWriter.CreateQrCodeWithLogo("https://example.com/product/4891", "brand-logo.png", 500);
qr.SaveAsPng("product-qr.png");

Imports IronBarCode

Dim qr = QRCodeWriter.CreateQrCodeWithLogo("https://example.com/product/4891", "brand-logo.png", 500)
qr.SaveAsPng("product-qr.png")

Imports IronBarCode

Dim qr = QRCodeWriter.CreateQrCodeWithLogo("https://example.com/product/4891", "brand-logo.png", 500)
qr.SaveAsPng("product-qr.png")

Le niveau de correction d'erreur, le calcul de la taille du logo et la composition de l'image sont gérés en interne. Aucune dépendance System.Drawing n'est requise.

Lecture des codes-barres à partir d'une image

La lecture d'un fichier image illustre le plus clairement la consolidation du produit. Avec OnBarcode, la lecture nécessite le kit de développement logiciel (SDK) Reader distinct, un appel de licence séparé et une spécification de format explicite. Avec IronBarcode, il s'agit d'un simple appel statique utilisant le même package et la même clé déjà en place.

Approche OnBarcode :

using OnBarcode.Barcode;

// Code-barres reader is distributed as a pre-licensed DLL — no runtime SetLicense() call.
BarcodeScanner scanner = new BarcodeScanner();
scanner.BarcodeTypes = new BarcodeType[] { BarcodeType.Code128, BarcodeType.QRCode };
string[] results = scanner.Scan("received-label.png");

foreach (string value in results)
    Console.WriteLine(value);

using OnBarcode.Barcode;

// Code-barres reader is distributed as a pre-licensed DLL — no runtime SetLicense() call.
BarcodeScanner scanner = new BarcodeScanner();
scanner.BarcodeTypes = new BarcodeType[] { BarcodeType.Code128, BarcodeType.QRCode };
string[] results = scanner.Scan("received-label.png");

foreach (string value in results)
    Console.WriteLine(value);

Approche IronBarcode :

using IronBarCode;

var results = BarcodeReader.Read("received-label.png");
foreach (var result in results)
    Console.WriteLine($"{result.Format}: {result.Value}");

using IronBarCode;

var results = BarcodeReader.Read("received-label.png");
foreach (var result in results)
    Console.WriteLine($"{result.Format}: {result.Value}");

Imports IronBarCode

Dim results = BarcodeReader.Read("received-label.png")
For Each result In results
    Console.WriteLine($"{result.Format}: {result.Value}")
Next

Imports IronBarCode

Dim results = BarcodeReader.Read("received-label.png")
For Each result In results
    Console.WriteLine($"{result.Format}: {result.Value}")
Next

Aucune création d'instance, aucun tableau de format, aucune configuration de licence séparée. Le format est détecté automatiquement. Chaque résultat comporte la valeur décodée et le format détecté. Pour plus de détails sur les options de lecture et les types d'images pris en charge, consultez le guide sur la lecture des codes-barres à partir d'images .

Lecture des codes-barres à partir d'un PDF

Cet exemple de migration s'applique aux équipes qui convertissaient des pages PDF en images à l'aide d'une bibliothèque tierce avant de transmettre ces images au SDK Code-barres Reader.

Approche OnBarcode :

// Code-barres has no native PDF support.
// A separate PDF rendering library was required — for example PdfiumViewer or Aspose.PDF.
var pageImages = RenderPdfPagesToImages("invoices.pdf"); // external library call

using OnBarcode.Barcode;
BarcodeScanner scanner = new BarcodeScanner();
scanner.BarcodeTypes = new BarcodeType[] { BarcodeType.Code128, BarcodeType.QRCode };

foreach (var pageImage in pageImages)
{
    string[] results = scanner.Scan(pageImage);
    foreach (string value in results)
        Console.WriteLine(value);
}

// Code-barres has no native PDF support.
// A separate PDF rendering library was required — for example PdfiumViewer or Aspose.PDF.
var pageImages = RenderPdfPagesToImages("invoices.pdf"); // external library call

using OnBarcode.Barcode;
BarcodeScanner scanner = new BarcodeScanner();
scanner.BarcodeTypes = new BarcodeType[] { BarcodeType.Code128, BarcodeType.QRCode };

foreach (var pageImage in pageImages)
{
    string[] results = scanner.Scan(pageImage);
    foreach (string value in results)
        Console.WriteLine(value);
}

Approche IronBarcode :

using IronBarCode;

var results = BarcodeReader.Read("invoices.pdf");
foreach (var result in results)
    Console.WriteLine($"Page {result.PageNumber}: {result.Format} — {result.Value}");

using IronBarCode;

var results = BarcodeReader.Read("invoices.pdf");
foreach (var result in results)
    Console.WriteLine($"Page {result.PageNumber}: {result.Format} — {result.Value}");

Imports IronBarCode

Dim results = BarcodeReader.Read("invoices.pdf")
For Each result In results
    Console.WriteLine($"Page {result.PageNumber}: {result.Format} — {result.Value}")
Next

Imports IronBarCode

Dim results = BarcodeReader.Read("invoices.pdf")
For Each result In results
    Console.WriteLine($"Page {result.PageNumber}: {result.Format} — {result.Value}")
Next

Aucune étape de rendu, aucune bibliothèque PDF externe, aucun tableau de formats. La fonction de lecture des codes-barres PDF traite automatiquement toutes les pages et inclut le numéro de page dans chaque résultat.

Génération par lots

La génération de codes-barres pour une collection d'articles suit le même schéma de différence que la génération d'un seul article.

Approche OnBarcode :

using OnBarcode.Barcode;

foreach (var item in inventoryItems)
{
    Linear barcode = new Linear();
    barcode.Type = BarcodeType.CODE128;
    barcode.Data = item.Sku;
    barcode.Resolution = 96;
    barcode.BarWidth = 1;
    barcode.BarHeight = 80;
    barcode.ShowText = true;
    barcode.drawBarcode($"labels/{item.Id}.png");
}

using OnBarcode.Barcode;

foreach (var item in inventoryItems)
{
    Linear barcode = new Linear();
    barcode.Type = BarcodeType.CODE128;
    barcode.Data = item.Sku;
    barcode.Resolution = 96;
    barcode.BarWidth = 1;
    barcode.BarHeight = 80;
    barcode.ShowText = true;
    barcode.drawBarcode($"labels/{item.Id}.png");
}

Imports OnBarcode.Barcode

For Each item In inventoryItems
    Dim barcode As New Linear()
    barcode.Type = BarcodeType.CODE128
    barcode.Data = item.Sku
    barcode.Resolution = 96
    barcode.BarWidth = 1
    barcode.BarHeight = 80
    barcode.ShowText = True
    barcode.drawBarcode($"labels/{item.Id}.png")
Next

Imports OnBarcode.Barcode

For Each item In inventoryItems
    Dim barcode As New Linear()
    barcode.Type = BarcodeType.CODE128
    barcode.Data = item.Sku
    barcode.Resolution = 96
    barcode.BarWidth = 1
    barcode.BarHeight = 80
    barcode.ShowText = True
    barcode.drawBarcode($"labels/{item.Id}.png")
Next

Approche IronBarcode :

using IronBarCode;

foreach (var item in inventoryItems)
{
    BarcodeWriter.CreateBarcode(item.Sku, BarcodeEncoding.Code128)
        .SaveAsPng($"labels/{item.Id}.png");
}

using IronBarCode;

foreach (var item in inventoryItems)
{
    BarcodeWriter.CreateBarcode(item.Sku, BarcodeEncoding.Code128)
        .SaveAsPng($"labels/{item.Id}.png");
}

Imports IronBarCode

For Each item In inventoryItems
    BarcodeWriter.CreateBarcode(item.Sku, BarcodeEncoding.Code128) _
        .SaveAsPng($"labels/{item.Id}.png")
Next

Imports IronBarCode

For Each item In inventoryItems
    BarcodeWriter.CreateBarcode(item.Sku, BarcodeEncoding.Code128) _
        .SaveAsPng($"labels/{item.Id}.png")
Next

Référence de correspondance entre l'API Code-barres et IronBarcode

Problèmes de migration courants et solutions

Problème 1 : Conflits de références DLL

OnBarcode : Les projets sur la distribution de DLL héritée ont des éléments <Reference> dans .csproj pointant vers lib\OnBarcode.Barcode.dll ou des chemins similaires. Si l'ancienne DLL reste sur le disque lors de l'ajout Code-barres IronBarcode , le compilateur verra deux assemblys fournissant les mêmes préfixes d'espace de noms et produira des erreurs de référence ambiguës.

Solution : Supprimez le bloc de référence <ItemGroup> de .csproj avant d'exécuter dotnet add package IronBarcode. Supprimez les fichiers DLL du disque. Vérifiez, à l'aide d'une compilation propre, qu'il ne reste aucune référence d'assemblage obsolète.

# Search for lingering Code-barres DLL references in project files
grep -r "OnBarcode" --include="*.csproj" .
grep -r "OnBarcode" --include="*.props" .

# Search for lingering Code-barres DLL references in project files
grep -r "OnBarcode" --include="*.csproj" .
grep -r "OnBarcode" --include="*.props" .

Problème 2 : Conflits de nom de type lors de la migration en phases

OnBarcode : L'espace de noms lecteur exporte une classe nommée BarcodeScanner. Code-barres IronBarcode a une classe statique nommée BarcodeReader. Ces noms ne se confondent pas directement, mais tout fichier qui importe à la fois OnBarcode.Barcode.Reader et IronBarCode simultanément peut voir une ambiguïté d'énum BarcodeType — Code-barres définit BarcodeType pour sa sélection de format, et Code-barres IronBarcode utilise BarcodeEncoding. Maintenir les deux espaces de noms actifs pendant la migration entraînera des erreurs de compilation sur toute référence BarcodeType.

Solution : Complétez la migration de chaque fichier de manière atomique — supprimez la directive using OnBarcode.Barcode.Reader et ajoutez using IronBarCode dans la même édition. Ne laissez pas les deux directives using présentes simultanément dans un même fichier. Si une approche progressive est nécessaire, utilisez temporairement les noms pleinement qualifiés :

// Temporary disambiguation during phased migration
var results = IronBarCode.BarcodeReader.Read("file.png");

// Temporary disambiguation during phased migration
var results = IronBarCode.BarcodeReader.Read("file.png");

' Temporary disambiguation during phased migration
Dim results = IronBarCode.BarcodeReader.Read("file.png")

' Temporary disambiguation during phased migration
Dim results = IronBarCode.BarcodeReader.Read("file.png")

Problème 3 : Suppression du tableau BarcodeType

OnBarcode : Le lecteur requiert reader.BarcodeTypes = new BarcodeType[] { ... } pour fonctionner. Les développeurs qui migrent le code du lecteur ont parfois l'habitude de spécifier explicitement les formats et recherchent une configuration équivalente dans IronBarcode.

Solution : Supprimer complètement la spécification de format. BarcodeReader.Read effectue une détection automatique sur tous les formats pris en charge. Aucune configuration n'est nécessaire, et aucun équivalent de BarcodeType[] n'existe dans Code-barres IronBarcode car ce n'est pas requis.

// No format configuration required
var results = BarcodeReader.Read("label.png");

// No format configuration required
var results = BarcodeReader.Read("label.png");

Dim results = BarcodeReader.Read("label.png")

Dim results = BarcodeReader.Read("label.png")

Liste de contrôle de migration OnBarcode

Tâches préalables à la migration

Avant d'apporter des modifications, auditez le code source afin de localiser toutes les utilisations de OnBarcode :

# Find all Code-barres namespace imports
grep -rn "using OnBarcode" --include="*.cs" .

# Find all license configuration calls
grep -rn "SetLicense" --include="*.cs" .

# Find all generator usage
grep -rn "new Linear\|new QRCode\|drawBarcode\|BarcodeType\." --include="*.cs" .

# Find all reader usage
grep -rn "BarcodeScanner\|\.Scan(\|BarcodeType\[\]" --include="*.cs" .

# Find DLL references in project files
grep -rn "OnBarcode" --include="*.csproj" .
grep -rn "OnBarcode" --include="*.sln" .

# Find all Code-barres namespace imports
grep -rn "using OnBarcode" --include="*.cs" .

# Find all license configuration calls
grep -rn "SetLicense" --include="*.cs" .

# Find all generator usage
grep -rn "new Linear\|new QRCode\|drawBarcode\|BarcodeType\." --include="*.cs" .

# Find all reader usage
grep -rn "BarcodeScanner\|\.Scan(\|BarcodeType\[\]" --include="*.cs" .

# Find DLL references in project files
grep -rn "OnBarcode" --include="*.csproj" .
grep -rn "OnBarcode" --include="*.sln" .

Documentez quels fichiers utilisent uniquement la génération, lesquels utilisent la lecture et lesquels utilisent les deux. Notez tous les fichiers qui incluent le bloc DLL <Reference> manuel plutôt qu'une référence de package NuGet.

Tâches de mise à jour du code

1. Supprimez le package NuGet OnBarcode.Barcode.Generator
2. Supprimez le package NuGet OnBarcode.Barcode.Reader
3. Supprimez toutes les entrées manuelles de DLL <Reference> depuis les fichiers .csproj
4. Supprimez les fichiers DLL Code-barres du référentiel
5. Exécutez dotnet add package IronBarcode
6. Remplacez using OnBarcode.Barcode par using IronBarCode dans chaque fichier
7. Remplacez using OnBarcode.Barcode.Reader par using IronBarCode dans chaque fichier
8. Supprimez les deux entrées DLL Code-barres <Reference> (générateur et lecteur) — aucun appel de licence d'exécution à remplacer
9. Ajoutez IronBarCode.License.LicenseKey = "YOUR-KEY" une fois au démarrage de l'application
10. Convertissez chaque bloc new Linear() ou new QRCode() + affectation de propriété en BarcodeWriter.CreateBarcode(data, encoding)
11. Remplacez barcode.drawBarcode("file.png") par .SaveAsPng("file.png") (ou méthode de format appropriée)
12. Remplacez new BarcodeScanner() { BarcodeTypes = [...] } + .Scan(path) par BarcodeReader.Read(path)
13. Mettez à jour la gestion des résultats de l'indexation string[] à result.Value et result.Format sur BarcodeResults
14. Supprimez tout code de rendu PDF vers image utilisé pour contourner la limitation PDF d'OnBarcode.
15. Remplacez les boucles de rendu de PDF en plusieurs étapes + numérisation par un seul appel BarcodeReader.Read("file.pdf")

Test de post-migration

• Vérifier que chaque type de code-barres utilisé dans le projet (Code 128, QR, EAN, Data Matrix, PDF417) génère un résultat scannable.
• Scannez les codes-barres générés avec un lecteur physique ou un appareil mobile pour en confirmer la lisibilité.
• Vérifier que la lecture des codes-barres renvoie des valeurs correctes pour les images de test connues
• Vérifier que la lecture des fichiers PDF renvoie les valeurs et les numéros de page corrects pour les documents de test multipages.
• Exécutez l'application dans un environnement d'intégration continue pour confirmer que la configuration de la clé de licence fonctionne correctement dans le pipeline.
• Vérifiez qu'aucune chaîne OnBarcode ne reste dans .cs, .csproj, ou les fichiers de configuration après que la migration est terminée

Principaux avantages de la migration vers IronBarcode

Package et licence consolidés : après la migration, un seul package NuGet et une seule clé de licence couvrent toutes les opérations de codes-barres. Il n'y a pas de produits distincts à acquérir, pas de calendriers de versions indépendants à suivre, ni de configuration de double licence à maintenir au démarrage. La complexité d'une architecture à deux produits est remplacée par une dépendance unique.

Processus d'achat transparent : Code-barres IronBarcode publie ses différents niveaux de licences perpétuelles avec leurs prix sur le site web du produit. Une entreprise peut ainsi déterminer le coût total, passer une commande et finaliser son achat sans avoir à contacter le service commercial. La page de licences IronBarcode inclut les tarifs pour tous les niveaux et des détails sur la configuration clé pour les environnements Docker et cloud.

Prise en charge native des PDF : les projets qui nécessitaient auparavant une bibliothèque de rendu PDF distincte pour traiter les PDF contenant des codes-barres peuvent désormais éliminer complètement cette dépendance. Un seul appel BarcodeReader.Read traite toutes les pages d'un document PDF sans aucune étape de rendu, et chaque résultat inclut le numéro de page à partir duquel il a été extrait.

Résultats de lecture plus riches : Le type de retour BarcodeResults fournit la valeur décodée, le format de code-barres détecté, les coordonnées de la boîte englobante dans l'image source, et le numéro de la page pour les lectures PDF. Les applications qui travaillaient auparavant avec un string[] plat peuvent maintenant faire apparaître des informations de format, prendre en charge les workflows d'annotation, ou implémenter un filtrage basé sur la confiance sans traitement supplémentaire.

Surface d'API réduite : le modèle de fabrique statique remplace le modèle d'affectation de propriétés. Les opérations de génération courantes nécessitent moins de lignes de code, et les opérations de lecture ne nécessitent aucune création d'instance ni préconfiguration de format. Les opérations par lots bénéficient d'une empreinte de code par article plus réduite, plus facile à examiner et à maintenir au fil du temps.