MessagingToolkit.Barcode a publié sa dernière version — 1.7.0.2 — en 2013 et n'a reçu aucune mise à jour depuis. Ce guide décrit l'intégralité du processus de migration vers IronBarcode: pourquoi la migration est nécessaire, quels changements de code sont apportés et comment vérifier que la migration est terminée. Ce guide s'adresse à la fois aux équipes migrant la fonctionnalité de code-barres de manière isolée et aux équipes entreprenant une mise à niveau plus large du .NET Framework pour laquelle MessagingToolkit.Barcode est une dépendance bloquante.

Pourquoi migrer depuis MessagingToolkit.Barcode

Problème de compatibilité avec le framework : MessagingToolkit.Barcode cible .NET Framework 3.5, 4.0 et 4.5. Il ne cible ni .NET Standard ni .NET Core . Lorsqu'un fichier de projet faisant référence à ce package est défini sur un framework cible .NET moderne ( .NET 6, .NET 7, .NET 8 ou .NET 9), l'opération de restauration NuGet échoue avec une erreur de compatibilité du framework. La compilation ne se poursuit pas. Il ne s'agit pas d'un avertissement ni d'une dégradation des performances en cours d'exécution ; Il s'agit d'une erreur de compilation qui empêche tout simplement la construction du projet. La suppression de MessagingToolkit.Barcode est une condition préalable à toute mise à niveau du .NET Framework , et non une étape de nettoyage facultative.

Vulnérabilité en matière de sécurité : Douze ans se sont écoulés depuis la dernière modification du code. Toute vulnérabilité découverte après 2014 dans la logique d'analyse d'images de la bibliothèque, son implémentation de décodage dérivée de ZXing ou ses dépendances transitives ne dispose d'aucun correctif, d'aucun avis et d'aucun responsable à contacter. Les outils d'analyse de sécurité signalent le paquet comme abandonné. Les cadres de conformité — PCI DSS, HIPAA, SOC 2, ISO 27001 — exigent une gestion active des correctifs des logiciels tiers. Un package abandonné échoue à ces audits pour des raisons de procédure, qu'une CVE spécifique ait été identifiée ou non.

Plateformes cibles abandonnées : les métadonnées du package NuGet indiquent Silverlight 3, 4 et 5 comme plateformes cibles ; Les trois ont été abandonnés en 2021. Windows Phone 7.0, 7.5, 7.8 et 8.0 sont listés ; L'arrêt du support de ces plateformes s'est produit entre 2014 et 2017. La bibliothèque n'a jamais été mise à jour pour cibler une quelconque plateforme ayant succédé à ces environnements abandonnés.

Écarts de capacités : MessagingToolkit.Barcode acceptait uniquement les entrées System.Drawing.Bitmap, qui est exclusif à Windows dans .NET 6 et plus tard. Il renvoyait un seul résultat par appel de décodage, sans prise en charge des images à plusieurs codes-barres. Elle ne disposait d'aucune fonctionnalité de lecture de fichiers PDF ; les applications qui devaient lire les codes-barres des documents PDF nécessitaient une étape d'extraction distincte avant d'appeler la bibliothèque. La génération de sortie a renvoyé un Bitmap, nécessitant un import de System.Drawing.Imaging empêchant le déploiement multiplateforme.

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

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);
}

Comparaison des fonctionnalités Code-barres IronBarcode et de MessagingToolkit.Barcode

Démarrage rapide : Migration de MessagingToolkit.Barcode vers IronBarcode

É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

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"

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

Exemples de migration de code

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

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

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

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

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

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

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

' 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

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.

Référence de mappage de l'API MessagingToolkit.Barcode vers IronBarcode

Problèmes de migration courants et solutions

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

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 :

<!-- Update this line in the .csproj file -->
<TargetFramework>net8.0</TargetFramework>

<!-- Update this line in the .csproj file -->
<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.

Liste de contrôle de migration des codes-barres de MessagingToolkit

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é.

Principaux avantages de la migration vers IronBarcode

Déblocage des mises à niveau du framework : une fois MessagingToolkit.Barcode supprimé, le framework cible du fichier projet peut être mis à jour vers n'importe quelle version .NET moderne. Cette simple modification permet d'accéder aux améliorations de performances de .NET 8, aux fonctionnalités du langage C# 12, aux modèles asynchrones natifs et à l'écosystème complet des packages NuGet nécessitant .NET Standard 2.0 ou une version ultérieure.

Déploiement multiplateforme : Le pipeline d'images interne d'IronBarcode ne dépend pas de System.Drawing, qui est exclusif à Windows dans .NET 6 et plus tard. Après la migration, les applications peuvent être déployées sur des serveurs Linux, des environnements de développement macOS, des conteneurs Docker, et des environnements de fonction cloud sans rencontrer PlatformNotSupportedException de la bibliothèque de codes-barres.

Constatations de conformité résolues : Code-barres IronBarcode reçoit des mises à jour de sécurité régulières grâce à un processus de maintenance documenté. Le remplacement d'une dépendance abandonnée par une dépendance activement maintenue résout les problèmes constatés lors des audits dans le cadre des normes PCI DSS, HIPAA, SOC 2 et autres cadres similaires qui exigent une gestion active des correctifs des bibliothèques tierces.

Prise en charge native des PDF : BarcodeReader.Read() accepte directement les chemins de fichiers PDF, éliminant le besoin d'une étape d'extraction d'images PDF séparée avant le décodage des codes-barres. Les applications qui traitent des documents numérisés ou des lots de factures bénéficient de cette fonctionnalité sans avoir à ajouter de nouvelles bibliothèques ni d'étapes de pipeline.

Options de sortie étendues : Les codes-barres générés sont disponibles sous forme de PNG, JPEG, SVG, PDF ou de chaînes encodées en base64 via l'objet de résultat fluide renvoyé par BarcodeWriter.CreateBarcode(). Cela remplace le type de retour System.Drawing.Bitmap de MessagingToolkit.Barcode, supprimant la contrainte de sortie exclusive à Windows et permettant une intégration directe dans les réponses web ou le stockage en base de données.