Le problème fondamental

MessagingToolkit.Barcode impose une dépendance à System.Drawing et un flux de travail basé sur une instance qui est incompatible avec les versions modernes de .NET :

// MessagingToolkit.Barcode: only compiles on .NET Framework 4.5 or earlier
// System.Drawing.Bitmap throws PlatformNotSupportedException on Linux/.NET 6+
using MessagingToolkit.Barcode;
using System.Drawing;

var decoder = new BarcodeDecoder();
using (var bitmap = new Bitmap("barcode.png"))  // Windows-only in .NET 6+
{
    var result = decoder.Decode(bitmap);          // Single result or null
    if (result != null)
    {
        Console.WriteLine(result.Text);
    }
}

// MessagingToolkit.Barcode: only compiles on .NET Framework 4.5 or earlier
// System.Drawing.Bitmap throws PlatformNotSupportedException on Linux/.NET 6+
using MessagingToolkit.Barcode;
using System.Drawing;

var decoder = new BarcodeDecoder();
using (var bitmap = new Bitmap("barcode.png"))  // Windows-only in .NET 6+
{
    var result = decoder.Decode(bitmap);          // Single result or null
    if (result != null)
    {
        Console.WriteLine(result.Text);
    }
}

Imports MessagingToolkit.Barcode
Imports System.Drawing

Dim decoder As New BarcodeDecoder()
Using bitmap As New Bitmap("barcode.png") ' Windows-only in .NET 6+
    Dim result = decoder.Decode(bitmap) ' Single result or Nothing
    If result IsNot Nothing Then
        Console.WriteLine(result.Text)
    End If
End Using

IronBarcode supprime complètement la dépendance System.Drawing et fonctionne de manière identique sous Windows, Linux, macOS, et dans les conteneurs Docker :

// IronBarcode: runs on .NET 6, 7, 8, 9 — Windows, Linux, macOS, Docker
using IronBarCode;

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

var results = BarcodeReader.Read("barcode.png");  // Non Bitmap, no System.Drawing
foreach (var result in results)
{
    Console.WriteLine(result.Value);
}

// IronBarcode: runs on .NET 6, 7, 8, 9 — Windows, Linux, macOS, Docker
using IronBarCode;

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

var results = BarcodeReader.Read("barcode.png");  // Non Bitmap, no System.Drawing
foreach (var result in results)
{
    Console.WriteLine(result.Value);
}

Imports IronBarCode

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

Dim results = BarcodeReader.Read("barcode.png") ' Non Bitmap, no System.Drawing
For Each result In results
    Console.WriteLine(result.Value)
Next

Étape 1 : Remplacer le package NuGet

Supprimez le package MessagingToolkit.Barcode :

dotnet remove package MessagingToolkit.Barcode

dotnet remove package MessagingToolkit.Barcode

Si le projet référence MessagingToolkit.Barcode.dll directement via une entrée <HintPath> dans le fichier .csproj, supprimez également cette référence.

Installer IronBarcode:

dotnet add package IronBarcode

dotnet add package IronBarcode

IronBarcode prend en charge .NET Framework 4.6.2 à .NET 9. Il s'installe sous forme d'un seul package avec toutes les dépendances intégrées ; aucune bibliothèque graphique séparée ni référence ZXing n'est requise.

Étape 2 : Mise à jour des espaces de noms

Remplacez le namespace MessagingToolkit par le namespace Code-barres IronBarcode dans chaque fichier qui référence l'ancienne bibliothèque :

// Remove this
using MessagingToolkit.Barcode;
using System.Drawing;  // if used only for Bitmap input to MessagingToolkit

// Add this
using IronBarCode;

// Remove this
using MessagingToolkit.Barcode;
using System.Drawing;  // if used only for Bitmap input to MessagingToolkit

// Add this
using IronBarCode;

Imports IronBarCode

Les fichiers qui importaient System.Drawing uniquement pour le type Bitmap utilisé avec MessagingToolkit.Barcode peuvent supprimer cet import dès qu'IronBarcode est en place.

Étape 3 : initialisation de la licence

Ajoutez l'initialisation de la licence une fois au démarrage de l'application — dans Program.cs, Startup.cs, ou le point d'entrée équivalent. Une clé de licence est requise pour une utilisation en production ; La bibliothèque fonctionne en mode d'essai sans cela.

// Add once at application startup
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";

// Add once at application startup
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";

' Add once at application startup
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY"

Lecture des codes-barres à partir de fichiers image

L'ancienne approche nécessitait de construire un Bitmap à partir du chemin de fichier et de le passer à une instance BarcodeDecoder. Code-barres IronBarcode accepte directement le chemin du fichier.

MessagingToolkit.Approche par code-barres :

using MessagingToolkit.Barcode;
using System.Drawing;

public string ReadBarcodeValue(string imagePath)
{
    var decoder = new BarcodeDecoder();
    using (var bitmap = new Bitmap(imagePath))
    {
        var result = decoder.Decode(bitmap);
        return result?.Text;
    }
}

using MessagingToolkit.Barcode;
using System.Drawing;

public string ReadBarcodeValue(string imagePath)
{
    var decoder = new BarcodeDecoder();
    using (var bitmap = new Bitmap(imagePath))
    {
        var result = decoder.Decode(bitmap);
        return result?.Text;
    }
}

Imports MessagingToolkit.Barcode
Imports System.Drawing

Public Function ReadBarcodeValue(imagePath As String) As String
    Dim decoder As New BarcodeDecoder()
    Using bitmap As New Bitmap(imagePath)
        Dim result = decoder.Decode(bitmap)
        Return If(result IsNot Nothing, result.Text, Nothing)
    End Using
End Function

Approche IronBarcode :

using IronBarCode;

public string ReadBarcodeValue(string imagePath)
{
    var results = BarcodeReader.Read(imagePath);
    return results.FirstOrDefault()?.Value;
}

using IronBarCode;

public string ReadBarcodeValue(string imagePath)
{
    var results = BarcodeReader.Read(imagePath);
    return results.FirstOrDefault()?.Value;
}

Imports IronBarCode

Public Function ReadBarcodeValue(imagePath As String) As String
    Dim results = BarcodeReader.Read(imagePath)
    Return results.FirstOrDefault()?.Value
End Function

La version Code-barres IronBarcode supprime la construction Bitmap et le modèle conditionnel nul sur un seul objet. BarcodeReader.Read() renvoie une collection — une collection vide lorsque rien n'est trouvé — donc .FirstOrDefault() remplace le contrôle de nullité sur l'ancienne valeur de retour à un seul résultat.

Accès aux informations de format des résultats

MessagingToolkit.Barcode exposait le format détecté via result.BarcodeFormat. Code-barres IronBarcode l'expose via result.Format. Ce sont deux valeurs d'énumération de l'objet résultat, avec des noms de type d'énumération différents.

MessagingToolkit.Approche par code-barres :

using MessagingToolkit.Barcode;
using System.Drawing;

var decoder = new BarcodeDecoder();
using (var bitmap = new Bitmap("barcode.png"))
{
    var result = decoder.Decode(bitmap);
    if (result != null)
    {
        Console.WriteLine($"Value: {result.Text}");
        Console.WriteLine($"Format: {result.BarcodeFormat}");
    }
}

using MessagingToolkit.Barcode;
using System.Drawing;

var decoder = new BarcodeDecoder();
using (var bitmap = new Bitmap("barcode.png"))
{
    var result = decoder.Decode(bitmap);
    if (result != null)
    {
        Console.WriteLine($"Value: {result.Text}");
        Console.WriteLine($"Format: {result.BarcodeFormat}");
    }
}

Imports MessagingToolkit.Barcode
Imports System.Drawing

Dim decoder As New BarcodeDecoder()
Using bitmap As New Bitmap("barcode.png")
    Dim result = decoder.Decode(bitmap)
    If result IsNot Nothing Then
        Console.WriteLine($"Value: {result.Text}")
        Console.WriteLine($"Format: {result.BarcodeFormat}")
    End If
End Using

Approche IronBarcode :

using IronBarCode;

var results = BarcodeReader.Read("barcode.png");
var first = results.FirstOrDefault();
if (first != null)
{
    Console.WriteLine($"Value: {first.Value}");
    Console.WriteLine($"Format: {first.Format}");
}

using IronBarCode;

var results = BarcodeReader.Read("barcode.png");
var first = results.FirstOrDefault();
if (first != null)
{
    Console.WriteLine($"Value: {first.Value}");
    Console.WriteLine($"Format: {first.Format}");
}

Imports IronBarCode

Dim results = BarcodeReader.Read("barcode.png")
Dim first = results.FirstOrDefault()
If first IsNot Nothing Then
    Console.WriteLine($"Value: {first.Value}")
    Console.WriteLine($"Format: {first.Format}")
End If

Le nom de la propriété change de .Text à .Value et de .BarcodeFormat à .Format. Le type enum passe de BarcodeFormat (MessagingToolkit) à BarcodeEncoding (IronBarcode), bien que .Format.ToString() produise une chaîne lisible par un humain comparable à des fins d'affichage ou de journalisation.

Générer des codes-barres

MessagingToolkit.Barcode utilisait un BarcodeEncoder basé sur une instance avec un format défini avant d'appeler .Encode(). Code-barres IronBarcode utilise une méthode statique avec le type d'encodage comme paramètre.

MessagingToolkit.Approche par code-barres :

using MessagingToolkit.Barcode;

public void GenerateQrCode(string data, string outputPath)
{
    var encoder = new BarcodeEncoder();
    encoder.Format = BarcodeFormat.QrCode;
    var bitmap = encoder.Encode(data);
    bitmap.Save(outputPath);
}

using MessagingToolkit.Barcode;

public void GenerateQrCode(string data, string outputPath)
{
    var encoder = new BarcodeEncoder();
    encoder.Format = BarcodeFormat.QrCode;
    var bitmap = encoder.Encode(data);
    bitmap.Save(outputPath);
}

Imports MessagingToolkit.Barcode

Public Sub GenerateQrCode(data As String, outputPath As String)
    Dim encoder As New BarcodeEncoder()
    encoder.Format = BarcodeFormat.QrCode
    Dim bitmap = encoder.Encode(data)
    bitmap.Save(outputPath)
End Sub

Approche IronBarcode :

using IronBarCode;

public void GenerateQrCode(string data, string outputPath)
{
    BarcodeWriter.CreateBarcode(data, BarcodeEncoding.QRCode)
        .SaveAsPng(outputPath);
}

using IronBarCode;

public void GenerateQrCode(string data, string outputPath)
{
    BarcodeWriter.CreateBarcode(data, BarcodeEncoding.QRCode)
        .SaveAsPng(outputPath);
}

Imports IronBarCode

Public Sub GenerateQrCode(data As String, outputPath As String)
    BarcodeWriter.CreateBarcode(data, BarcodeEncoding.QRCode) _
        .SaveAsPng(outputPath)
End Sub

Pour la création de codes 128 et autres codes-barres 1D , le même modèle statique s'applique avec une constante d'encodage différente :

// Code 128
BarcodeWriter.CreateBarcode("PRODUCT-12345", BarcodeEncoding.Code128)
    .SaveAsPng("code128.png");

// EAN-13
BarcodeWriter.CreateBarcode("5901234123457", BarcodeEncoding.EAN13)
    .SaveAsPng("ean13.png");

// Code 128
BarcodeWriter.CreateBarcode("PRODUCT-12345", BarcodeEncoding.Code128)
    .SaveAsPng("code128.png");

// EAN-13
BarcodeWriter.CreateBarcode("5901234123457", BarcodeEncoding.EAN13)
    .SaveAsPng("ean13.png");

' Code 128
BarcodeWriter.CreateBarcode("PRODUCT-12345", BarcodeEncoding.Code128) _
    .SaveAsPng("code128.png")

' EAN-13
BarcodeWriter.CreateBarcode("5901234123457", BarcodeEncoding.EAN13) _
    .SaveAsPng("ean13.png")

Mise à jour du cadre cible

Une fois MessagingToolkit.Barcode supprimé et toutes les références remplacées, le framework cible du fichier projet peut être mis à jour. Cette modification était bloquée par l'ancienne dépendance et devient possible après sa suppression :

MessagingToolkit.Barcode Approach (fichier de projet) :

<PropertyGroup>
  <TargetFramework>net472</TargetFramework>
</PropertyGroup>

<PropertyGroup>
  <TargetFramework>net472</TargetFramework>
</PropertyGroup>

Approche Code-barres IronBarcode (fichier de projet) :

<PropertyGroup>
  <TargetFramework>net8.0</TargetFramework>
</PropertyGroup>

<PropertyGroup>
  <TargetFramework>net8.0</TargetFramework>
</PropertyGroup>

IronBarcode prend en charge .NET Framework 4.6.2 à .NET 9, il peut donc être installé avant la finalisation de la mise à niveau du framework. Cela permet d'effectuer la migration par étapes : installer Code-barres IronBarcode en parallèle de MessagingToolkit.Barcode, remplacer toutes les utilisations, vérifier le nouveau code, supprimer l'ancien package, puis changer le framework cible en dernière étape.

Lecture des codes-barres dans les documents PDF

MessagingToolkit.Barcode ne prenait pas en charge le format PDF. La lecture des codes-barres à partir d'un PDF nécessitait l'extraction des images de chaque page via une bibliothèque distincte avant d'appeler le décodeur de codes-barres. Code-barres IronBarcode lit les fichiers PDF directement par la même méthode que celle utilisée pour les images.

MessagingToolkit.Approche par code-barres :

// Not supported — required external PDF page extraction before decode
// Non equivalent exists in MessagingToolkit.Barcode

// Not supported — required external PDF page extraction before decode
// Non equivalent exists in MessagingToolkit.Barcode

Approche IronBarcode :

using IronBarCode;

// Read all barcodes from every page of a PDF document
var results = BarcodeReader.Read("invoice.pdf");
foreach (var barcode in results)
{
    Console.WriteLine($"Page {barcode.PageNumber}: {barcode.Value} ({barcode.Format})");
}

using IronBarCode;

// Read all barcodes from every page of a PDF document
var results = BarcodeReader.Read("invoice.pdf");
foreach (var barcode in results)
{
    Console.WriteLine($"Page {barcode.PageNumber}: {barcode.Value} ({barcode.Format})");
}

Imports IronBarCode

' Read all barcodes from every page of a PDF document
Dim results = BarcodeReader.Read("invoice.pdf")
For Each barcode In results
    Console.WriteLine($"Page {barcode.PageNumber}: {barcode.Value} ({barcode.Format})")
Next

Les applications qui traitent des documents numérisés, des manifestes d'expédition ou des lots de factures multipages bénéficient de cette fonctionnalité dans le cadre de la migration, sans aucune bibliothèque ni configuration supplémentaire.

Problème 1 : Espace de noms introuvable après la mise à jour du package

Problème : Après avoir supprimé MessagingToolkit.Barcode et ajouté IronBarcode, la compilation échoue avec CS0246: The type or namespace name 'BarcodeDecoder' could not be found.

Solution : L'ancien espace de noms using MessagingToolkit.Barcode; doit être remplacé par using IronBarCode; (notez le C majuscule) dans chaque fichier qui référence l'ancienne bibliothèque. Une recherche à l'échelle du projet de l'ancienne chaîne d'espace de noms permettra de localiser tous les fichiers concernés :

grep -r "using MessagingToolkit.Barcode" --include="*.cs" .
grep -r "BarcodeDecoder\|BarcodeEncoder" --include="*.cs" .

grep -r "using MessagingToolkit.Barcode" --include="*.cs" .
grep -r "BarcodeDecoder\|BarcodeEncoder" --include="*.cs" .

Problème n° 2 : Ambiguïté entre les espaces de noms pour BarcodeReader

Problème : Si un projet référence à la fois MessagingToolkit.Barcode et IronBarcode pendant une migration par étapes, BarcodeReader peut être ambigu entre les deux espaces de noms.

Solution : Qualifier explicitement la référence pendant la période de transition :

// Use the fully qualified name while both packages are installed
var results = IronBarCode.BarcodeReader.Read("barcode.png");

// Use the fully qualified name while both packages are installed
var results = IronBarCode.BarcodeReader.Read("barcode.png");

Imports IronBarCode

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

Une fois que toutes les références à MessagingToolkit.Barcode ont été remplacées et que l'ancien package est supprimé, le qualificateur peut être supprimé et la directive using IronBarCode; est suffisante.

Problème 3 : Le framework cible reste défini sur net472 après la suppression du package

Problème : Après avoir supprimé MessagingToolkit.Barcode et installé IronBarcode, le fichier de projet vise toujours net472. Les avertissements de compilation indiquent que les API .NET modernes ne sont pas disponibles.

Solution : Mettez à jour l'élément <TargetFramework> dans le fichier .csproj une fois que la dépendance a été supprimée. Code-barres IronBarcode prend en charge à la fois net472 (via la compatibilité .NET Framework 4.6.2) et les cibles modernes. Passer à net8.0 nécessite de vérifier qu'aucune autre dépendance héritée ne subsiste dans le projet :

<TargetFramework>net8.0</TargetFramework>

<TargetFramework>net8.0</TargetFramework>

Exécutez dotnet build après le changement pour identifier les éventuelles dépendances héritées restantes qui doivent être traitées.

Tâches préalables à la migration

Examinez le code source pour identifier tous les emplacements qui font référence à MessagingToolkit.Barcode :

# Find all using statements
grep -r "using MessagingToolkit.Barcode" --include="*.cs" .

# Find decoder instantiations
grep -r "BarcodeDecoder" --include="*.cs" .

# Find encoder instantiations
grep -r "BarcodeEncoder" --include="*.cs" .

# Find decode calls
grep -r "\.Decode(" --include="*.cs" .

# Find encode calls
grep -r "\.Encode(" --include="*.cs" .

# Find project file references
grep -r "MessagingToolkit" --include="*.csproj" .
grep -r "MessagingToolkit" --include="packages.config" .

# Find all using statements
grep -r "using MessagingToolkit.Barcode" --include="*.cs" .

# Find decoder instantiations
grep -r "BarcodeDecoder" --include="*.cs" .

# Find encoder instantiations
grep -r "BarcodeEncoder" --include="*.cs" .

# Find decode calls
grep -r "\.Decode(" --include="*.cs" .

# Find encode calls
grep -r "\.Encode(" --include="*.cs" .

# Find project file references
grep -r "MessagingToolkit" --include="*.csproj" .
grep -r "MessagingToolkit" --include="packages.config" .

Documentez tous les fichiers qui nécessitent des modifications. Notez tous les endroits où System.Drawing.Bitmap est utilisé comme entrée pour le décodeur — ces utilisations devront également être mises à jour.

Tâches de mise à jour du code

1. Exécutez dotnet remove package MessagingToolkit.Barcode pour supprimer le package
2. Exécutez dotnet add package IronBarcode pour installer IronBarcode
3. Ajoutez IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY"; au démarrage de l'application
4. Remplacez toutes les instructions using MessagingToolkit.Barcode; par using IronBarCode;
5. Remplacez tous les motifs new BarcodeDecoder() par des appels statiques BarcodeReader.Read()
6. Remplacez tous les motifs new BarcodeEncoder() par des appels statiques BarcodeWriter.CreateBarcode()
7. Mettez à jour toutes les références result.Text vers result.Value
8. Mettez à jour toutes les références result.BarcodeFormat vers result.Format
9. Mettez à jour tous les motifs barcodeWriter.Format = BarcodeFormat.X pour passer l'encodage en tant que paramètre
10. Remplacez bitmap.Save() par .SaveAsPng() ou la méthode de sortie appropriée sur le résultat IronBarcode
11. Supprimez les imports using System.Drawing; là où ils étaient utilisés uniquement pour l'entrée Bitmap vers MessagingToolkit
12. Mettez à jour <TargetFramework> dans le fichier de projet si une mise à niveau du framework fait partie de la migration

Test de post-migration

• Vérifiez que dotnet build se termine avec zéro erreur et zéro référence à MessagingToolkit
• Exécutez grep -r "MessagingToolkit" --include="*.cs" . et confirmez zéro résultat
• Testez la lecture des codes-barres avec de vraies images de codes-barres de votre application et confirmez que .Value renvoie la chaîne attendue
• Tester la lecture des codes-barres avec des images de plusieurs codes-barres et confirmer que tous les codes-barres de la collection sont bien renvoyés.
• Tester la génération des codes-barres et vérifier que le fichier de sortie correspond au format et à l'encodage attendus.
• Si vous utilisez la lecture de fichiers PDF, effectuez un test avec un document PDF représentatif et vérifiez que les métadonnées de numéro de page sont correctes.
• Si le framework cible a été modifié, exécutez la Suite de tests complète sur le nouveau runtime afin d'identifier tout autre problème de compatibilité.