Scanner de codes-barres USB en C# : Créez une application de numérisation complète

Pourquoi le mode Wedge du clavier HID simplifie-t-il l'intégration ?

La plupart des lecteurs de codes-barres USB sont livrés configurés par défaut en mode clavier HID. Lorsque vous branchez un tel appareil sur un ordinateur Windows, le système d'exploitation l'enregistre à la fois comme un périphérique de stockage USB (pour la configuration) et comme un clavier (pour la saisie de données). Lorsqu'un code-barres est scanné, l'appareil traduit la valeur décodée du code-barres en frappes de clavier et les envoie à la fenêtre d'application qui a le focus, en ajoutant un retour chariot à la fin.

Du point de vue d'un développeur C#, cela signifie qu'il n'est pas nécessaire d'utiliser les kits de développement logiciel (SDK) des fournisseurs, les bibliothèques COM ou les API USB spécifiques. Un simple contrôle TextBox avec un gestionnaire d'événement KeyDown suffit pour la saisie. Le principal défi d'intégration consiste à distinguer les données saisies par scanner de la véritable saisie au clavier. Les scanners délivrent généralement tous les caractères en un laps de temps très court — souvent moins de 50 millisecondes — tandis que la frappe humaine répartit les frappes sur des centaines de millisecondes. Le déclenchement temporel de la rafale est un moyen fiable de filtrer les frappes accidentelles.

Les scanners de qualité professionnelle prennent également en charge les modes série (RS-232 ou port COM virtuel) et USB HID direct, ce qui vous offre un meilleur contrôle sur les caractères de préfixe/suffixe et les déclencheurs de numérisation. Le modèle d'interface ci-dessous gère les deux cas :

public interface IScannerInput
{
    event EventHandler<string> BarcodeScanned;
    void StartListening();
    void StopListening();
}

public class KeyboardWedgeScanner : IScannerInput
{
    public event EventHandler<string> BarcodeScanned;
    private readonly TextBox _inputBox;
    private readonly System.Windows.Forms.Timer _burstTimer;
    private readonly System.Text.StringBuilder _buffer = new();

    public KeyboardWedgeScanner(TextBox inputBox)
    {
        _inputBox = inputBox;
        _burstTimer = new System.Windows.Forms.Timer { Interval = 80 };
        _burstTimer.Tick += OnBurstTimeout;
        _inputBox.KeyPress += OnKeyPress;
    }

    private void OnKeyPress(object sender, KeyPressEventArgs e)
    {
        if (e.KeyChar == (char)Keys.Enter)
        {
            _burstTimer.Stop();
            string value = _buffer.ToString().Trim();
            _buffer.Clear();
            if (value.Length > 0)
                BarcodeScanned?.Invoke(this, value);
        }
        else
        {
            _buffer.Append(e.KeyChar);
            _burstTimer.Stop();
            _burstTimer.Start();
        }
        e.Handled = true;
    }

    private void OnBurstTimeout(object sender, EventArgs e)
    {
        _burstTimer.Stop();
        _buffer.Clear(); // incomplete burst -- discard
    }

    public void StartListening() => _inputBox.Focus();
    public void StopListening() => _inputBox.Enabled = false;
}

public class SerialPortScanner : IScannerInput
{
    public event EventHandler<string> BarcodeScanned;
    private readonly System.IO.Ports.SerialPort _port;

    public SerialPortScanner(string portName, int baudRate = 9600)
    {
        _port = new System.IO.Ports.SerialPort(portName, baudRate);
        _port.DataReceived += OnDataReceived;
    }

    private void OnDataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
    {
        string data = _port.ReadLine().Trim();
        if (data.Length > 0)
            BarcodeScanned?.Invoke(this, data);
    }

    public void StartListening() => _port.Open();
    public void StopListening() => _port.Close();
}

public interface IScannerInput
{
    event EventHandler<string> BarcodeScanned;
    void StartListening();
    void StopListening();
}

public class KeyboardWedgeScanner : IScannerInput
{
    public event EventHandler<string> BarcodeScanned;
    private readonly TextBox _inputBox;
    private readonly System.Windows.Forms.Timer _burstTimer;
    private readonly System.Text.StringBuilder _buffer = new();

    public KeyboardWedgeScanner(TextBox inputBox)
    {
        _inputBox = inputBox;
        _burstTimer = new System.Windows.Forms.Timer { Interval = 80 };
        _burstTimer.Tick += OnBurstTimeout;
        _inputBox.KeyPress += OnKeyPress;
    }

    private void OnKeyPress(object sender, KeyPressEventArgs e)
    {
        if (e.KeyChar == (char)Keys.Enter)
        {
            _burstTimer.Stop();
            string value = _buffer.ToString().Trim();
            _buffer.Clear();
            if (value.Length > 0)
                BarcodeScanned?.Invoke(this, value);
        }
        else
        {
            _buffer.Append(e.KeyChar);
            _burstTimer.Stop();
            _burstTimer.Start();
        }
        e.Handled = true;
    }

    private void OnBurstTimeout(object sender, EventArgs e)
    {
        _burstTimer.Stop();
        _buffer.Clear(); // incomplete burst -- discard
    }

    public void StartListening() => _inputBox.Focus();
    public void StopListening() => _inputBox.Enabled = false;
}

public class SerialPortScanner : IScannerInput
{
    public event EventHandler<string> BarcodeScanned;
    private readonly System.IO.Ports.SerialPort _port;

    public SerialPortScanner(string portName, int baudRate = 9600)
    {
        _port = new System.IO.Ports.SerialPort(portName, baudRate);
        _port.DataReceived += OnDataReceived;
    }

    private void OnDataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
    {
        string data = _port.ReadLine().Trim();
        if (data.Length > 0)
            BarcodeScanned?.Invoke(this, data);
    }

    public void StartListening() => _port.Open();
    public void StopListening() => _port.Close();
}

Le minuteur de rafale intégré au clavier est un détail essentiel. Il se réinitialise à chaque frappe et ne se déclenche que si aucun caractère n'est enregistré, ce qui signifie que les utilisateurs de clavier qui tapent lentement verront leurs saisies incomplètes rejetées plutôt que traitées comme un scan de code-barres.

Comment gérez-vous plusieurs marques de scanners ?

Dans les environnements Enterprise , on trouve fréquemment un mélange de scanners Honeywell, Zebra (anciennement Symbol/Motorola) et Datalogic sur le même étage. Chaque fournisseur possède ses propres caractères de terminaison par défaut, ses débits de transmission et ses conventions de préfixe/suffixe. Un modèle de configuration assure la flexibilité de votre application :

public class ScannerConfiguration
{
    public string ScannerType { get; set; } = "KeyboardWedge";
    public string PortName { get; set; } = "COM3";
    public int BaudRate { get; set; } = 9600;
    public string Terminator { get; set; } = "\r\n";
    public bool EnableBeep { get; set; } = true;
    public Dictionary<string, string> BrandSettings { get; set; } = new();

    public static ScannerConfiguration GetHoneywellConfig() => new()
    {
        ScannerType = "Serial",
        BaudRate = 115200,
        BrandSettings = new Dictionary<string, string>
        {
            { "Prefix", "STX" },
            { "Suffix", "ETX" },
            { "TriggerMode", "Manual" }
        }
    };

    public static ScannerConfiguration GetZebraConfig() => new()
    {
        ScannerType = "KeyboardWedge",
        BrandSettings = new Dictionary<string, string>
        {
            { "ScanMode", "Continuous" },
            { "BeepVolume", "High" }
        }
    };
}

public class ScannerConfiguration
{
    public string ScannerType { get; set; } = "KeyboardWedge";
    public string PortName { get; set; } = "COM3";
    public int BaudRate { get; set; } = 9600;
    public string Terminator { get; set; } = "\r\n";
    public bool EnableBeep { get; set; } = true;
    public Dictionary<string, string> BrandSettings { get; set; } = new();

    public static ScannerConfiguration GetHoneywellConfig() => new()
    {
        ScannerType = "Serial",
        BaudRate = 115200,
        BrandSettings = new Dictionary<string, string>
        {
            { "Prefix", "STX" },
            { "Suffix", "ETX" },
            { "TriggerMode", "Manual" }
        }
    };

    public static ScannerConfiguration GetZebraConfig() => new()
    {
        ScannerType = "KeyboardWedge",
        BrandSettings = new Dictionary<string, string>
        {
            { "ScanMode", "Continuous" },
            { "BeepVolume", "High" }
        }
    };
}

Le stockage de ces configurations dans un fichier de paramètres ou une base de données permet au personnel de l'entrepôt de changer de modèle de scanner sans nécessiter de redéploiement. Le champ ScannerType détermine quelle implémentation IScannerInput est instanciée au démarrage.

Quelle est la méthode la plus rapide pour ajouter IronBarcode via NuGet?

Ouvrez la console du Package Manager dans Visual Studio et exécutez :

Install-Package IronBarCode

Install-Package IronBarCode

Vous pouvez également utiliser l'interface de ligne de commande .NET :

dotnet add package IronBarCode

dotnet add package IronBarCode

Ces deux commandes téléchargent la version actuelle depuis NuGet et ajoutent la référence d'assembly à votre fichier projet. La bibliothèque cible .NET Standard 2.0 et fonctionne donc avec .NET Framework 4.6.2 à .NET 10 sans aucun module de compatibilité supplémentaire.

Après l'installation, définissez votre clé de licence avant d'appeler une méthode IronBarcode . Pour le développement et l'évaluation, une clé d'essai gratuite est disponible sur la page de licences IronBarcode :

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

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

Pour les déploiements conteneurisés, IronBarcode fonctionne avec Docker sous Linux , et pour les fonctions cloud, il prend en charge AWS Lambda et Azure Functions .

Quelle est la bonne approche pour la vérification du format ?

IronBarcode prend en charge plus de 30 symbologies de codes-barres, notamment Code 128 , EAN-13 , Code 39 , les codes QR et Data Matrix . Pour les applications de scanner USB, le modèle de validation réencode la chaîne scannée sous forme d'image de code-barres et la relit immédiatement via le décodeur. Cet aller-retour confirme que la chaîne est une valeur valide pour le format déclaré :

public class BarcodeValidator
{
    public async Task<ValidationResult> ValidateAsync(string scannedText, BarcodeEncoding preferredFormat = BarcodeEncoding.Code128)
    {
        var result = new ValidationResult { RawInput = scannedText };

        try
        {
            var barcode = BarcodeWriter.CreateBarcode(scannedText, preferredFormat);
            var readResults = await BarcodeReader.ReadAsync(barcode.ToBitmap());

            if (readResults.Any())
            {
                var first = readResults.First();
                result.IsValid = true;
                result.Format = first.BarcodeType;
                result.Value = first.Value;
                result.Confidence = first.Confidence;
            }
            else
            {
                result.IsValid = false;
                result.Error = "No barcode could be decoded from the scanned input.";
            }
        }
        catch (Exception ex)
        {
            result.IsValid = false;
            result.Error = ex.Message;
        }

        return result;
    }
}

public record ValidationResult
{
    public string RawInput { get; init; } = "";
    public bool IsValid { get; set; }
    public BarcodeEncoding Format { get; set; }
    public string Value { get; set; } = "";
    public float Confidence { get; set; }
    public string Error { get; set; } = "";
}

public class BarcodeValidator
{
    public async Task<ValidationResult> ValidateAsync(string scannedText, BarcodeEncoding preferredFormat = BarcodeEncoding.Code128)
    {
        var result = new ValidationResult { RawInput = scannedText };

        try
        {
            var barcode = BarcodeWriter.CreateBarcode(scannedText, preferredFormat);
            var readResults = await BarcodeReader.ReadAsync(barcode.ToBitmap());

            if (readResults.Any())
            {
                var first = readResults.First();
                result.IsValid = true;
                result.Format = first.BarcodeType;
                result.Value = first.Value;
                result.Confidence = first.Confidence;
            }
            else
            {
                result.IsValid = false;
                result.Error = "No barcode could be decoded from the scanned input.";
            }
        }
        catch (Exception ex)
        {
            result.IsValid = false;
            result.Error = ex.Message;
        }

        return result;
    }
}

public record ValidationResult
{
    public string RawInput { get; init; } = "";
    public bool IsValid { get; set; }
    public BarcodeEncoding Format { get; set; }
    public string Value { get; set; } = "";
    public float Confidence { get; set; }
    public string Error { get; set; } = "";
}

Pour les codes-barres GS1-128 utilisés dans les applications de la chaîne d'approvisionnement, la chaîne scannée comprend des préfixes d'identifiant d'application entre parenthèses tels que (01) pour le GTIN et (17) pour la date d'expiration. IronBarcode analyse automatiquement ces identifiants d'application lorsque vous spécifiez BarcodeEncoding.GS1_128.

Quelle logique de somme de contrôle EAN-13 les développeurs doivent-ils implémenter ?

Les applications de point de vente doivent souvent vérifier indépendamment les chiffres de contrôle EAN-13 avant de transmettre la valeur à une base de données de prix. La somme de contrôle de type Luhn pour EAN-13 alterne les valeurs 1 et 3 sur les 12 premiers chiffres :

public static bool ValidateEan13Checksum(string value)
{
    if (value.Length != 13 || !value.All(char.IsDigit))
        return false;

    int sum = 0;
    for (int i = 0; i < 12; i++)
    {
        int digit = value[i] - '0';
        sum += (i % 2 == 0) ? digit : digit * 3;
    }

    int expectedCheck = (10 - (sum % 10)) % 10;
    return expectedCheck == (value[12] - '0');
}

public static bool ValidateEan13Checksum(string value)
{
    if (value.Length != 13 || !value.All(char.IsDigit))
        return false;

    int sum = 0;
    for (int i = 0; i < 12; i++)
    {
        int digit = value[i] - '0';
        sum += (i % 2 == 0) ? digit : digit * 3;
    }

    int expectedCheck = (10 - (sum % 10)) % 10;
    return expectedCheck == (value[12] - '0');
}

Ce contrôle purement logique s'exécute avant l'encodage afin d'éviter la surcharge liée à la génération d'images aller-retour pour chaque scan dans un environnement de vente au détail à volume élevé. Selon la spécification GS1 , l'algorithme de chiffre de contrôle est identique pour UPC-A (12 chiffres) lorsque vous supprimez le zéro initial.

Quand une application doit-elle créer de nouveaux codes-barres après une numérisation ?

Un schéma courant dans la réception en entrepôt est le flux de travail " scan et réétiquetage " : un article entrant porte un code-barres fournisseur (souvent EAN-13 ou ITF-14), et le système de gestion d'entrepôt doit imprimer une étiquette interne Code 128 avec ses propres codes d'emplacement et de lot. Les fonctionnalités de génération d'IronBarcode gèrent cela en quelques lignes :

public class InventoryLabelGenerator
{
    private readonly string _outputDirectory;

    public InventoryLabelGenerator(string outputDirectory)
    {
        _outputDirectory = outputDirectory;
        Directory.CreateDirectory(_outputDirectory);
    }

    public async Task<string> GenerateLabelAsync(string internalCode, string locationCode)
    {
        string fullCode = $"{internalCode}|{locationCode}|{DateTime.UtcNow:yyyyMMdd}";

        // Primary Code 128 label for scanners
        var linearBarcode = BarcodeWriter.CreateBarcode(fullCode, BarcodeEncoding.Code128);
        linearBarcode.ResizeTo(500, 140);
        linearBarcode.SetMargins(12);
        linearBarcode.AddAnnotationTextAboveBarcode(fullCode);
        linearBarcode.ChangeBarCodeColor(IronSoftware.Drawing.Color.Black);

        // QR code companion for mobile apps
        var qrCode = BarcodeWriter.CreateQrCode(fullCode);
        qrCode.ResizeTo(200, 200);
        qrCode.SetMargins(8);

        string timestamp = DateTime.UtcNow.ToString("yyyyMMddHHmmss");
        string pngPath = Path.Combine(_outputDirectory, $"{internalCode}_{timestamp}.png");
        string pdfPath = Path.Combine(_outputDirectory, $"{internalCode}_{timestamp}.pdf");

        await Task.Run(() =>
        {
            linearBarcode.SaveAsPng(pngPath);
            linearBarcode.SaveAsPdf(pdfPath);
        });

        return pngPath;
    }
}

public class InventoryLabelGenerator
{
    private readonly string _outputDirectory;

    public InventoryLabelGenerator(string outputDirectory)
    {
        _outputDirectory = outputDirectory;
        Directory.CreateDirectory(_outputDirectory);
    }

    public async Task<string> GenerateLabelAsync(string internalCode, string locationCode)
    {
        string fullCode = $"{internalCode}|{locationCode}|{DateTime.UtcNow:yyyyMMdd}";

        // Primary Code 128 label for scanners
        var linearBarcode = BarcodeWriter.CreateBarcode(fullCode, BarcodeEncoding.Code128);
        linearBarcode.ResizeTo(500, 140);
        linearBarcode.SetMargins(12);
        linearBarcode.AddAnnotationTextAboveBarcode(fullCode);
        linearBarcode.ChangeBarCodeColor(IronSoftware.Drawing.Color.Black);

        // QR code companion for mobile apps
        var qrCode = BarcodeWriter.CreateQrCode(fullCode);
        qrCode.ResizeTo(200, 200);
        qrCode.SetMargins(8);

        string timestamp = DateTime.UtcNow.ToString("yyyyMMddHHmmss");
        string pngPath = Path.Combine(_outputDirectory, $"{internalCode}_{timestamp}.png");
        string pdfPath = Path.Combine(_outputDirectory, $"{internalCode}_{timestamp}.pdf");

        await Task.Run(() =>
        {
            linearBarcode.SaveAsPng(pngPath);
            linearBarcode.SaveAsPdf(pdfPath);
        });

        return pngPath;
    }
}

L'enregistrement au format PDF est particulièrement utile pour les imprimantes d'étiquettes qui acceptent les fichiers PDF en entrée via un partage réseau. Vous pouvez également exporter au format SVG pour obtenir des étiquettes thermiques vectorielles de haute qualité, ou exporter sous forme de flux d'octets pour l'envoyer directement à une API d'imprimante d'étiquettes.

IronBarcode prend en charge une personnalisation de style étendue, notamment les couleurs personnalisées, les ajustements de marge , les superpositions de texte lisibles par l'homme et, pour les codes QR, l'intégration de logos pour les étiquettes mobiles marquées de la marque.

À quoi ressemble une implémentation de production basée sur une file d'attente ?

Pour les applications qui traitent des dizaines d'analyses par minute, un simple gestionnaire synchrone sur le thread d'interface utilisateur devient un goulot d'étranglement. Le modèle ci-dessous dissocie la capture du scan du traitement à l'aide d'un ConcurrentQueue<t> et d'une boucle de traitement en arrière-plan. L'API asynchrone d'IronBarcode gère la validation sans bloquer l'interface utilisateur :

using IronBarCode;
using System.Collections.Concurrent;

public partial class HighVolumeScanner : Form
{
    private readonly ConcurrentQueue<(string Data, DateTime Timestamp)> _scanQueue = new();
    private readonly SemaphoreSlim _semaphore;
    private readonly CancellationTokenSource _cts = new();
    private IScannerInput _scanner;

    public HighVolumeScanner()
    {
        InitializeComponent();
        IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";
        _semaphore = new SemaphoreSlim(Environment.ProcessorCount);
        InitializeScanner();
        _ = RunProcessingLoopAsync();
    }

    private void InitializeScanner()
    {
        _scanner = System.IO.Ports.SerialPort.GetPortNames().Any()
            ? new SerialPortScanner("COM3", 115200)
            : new KeyboardWedgeScanner(txtScannerInput);

        _scanner.BarcodeScanned += (_, barcode) =>
            _scanQueue.Enqueue((barcode, DateTime.UtcNow));

        _scanner.StartListening();
    }

    private async Task RunProcessingLoopAsync()
    {
        while (!_cts.Token.IsCancellationRequested)
        {
            if (_scanQueue.TryDequeue(out var scan))
            {
                await _semaphore.WaitAsync(_cts.Token);
                _ = Task.Run(async () =>
                {
                    try { await ProcessScanAsync(scan.Data, scan.Timestamp); }
                    finally { _semaphore.Release(); }
                }, _cts.Token);
            }
            else
            {
                await Task.Delay(10, _cts.Token);
            }
        }
    }

    private async Task ProcessScanAsync(string rawData, DateTime scanTime)
    {
        var options = new BarcodeReaderOptions
        {
            Speed = ReadingSpeed.Balanced,
            ExpectMultipleBarcodes = false,
            ExpectBarcodeTypes = BarcodeEncoding.Code128 | BarcodeEncoding.QRCode,
            MaxParallelThreads = 1
        };

        var testBarcode = BarcodeWriter.CreateBarcode(rawData, BarcodeEncoding.Code128);
        var results = await BarcodeReader.ReadAsync(testBarcode.ToBitmap(), options);

        if (results.Any())
        {
            var item = results.First();
            BeginInvoke(() => UpdateInventoryDisplay(item.Value, scanTime));
        }
        else
        {
            BeginInvoke(() => LogRejectedScan(rawData, scanTime));
        }
    }

    protected override void OnFormClosing(FormClosingEventArgs e)
    {
        _cts.Cancel();
        _scanner.StopListening();
        base.OnFormClosing(e);
    }
}

using IronBarCode;
using System.Collections.Concurrent;

public partial class HighVolumeScanner : Form
{
    private readonly ConcurrentQueue<(string Data, DateTime Timestamp)> _scanQueue = new();
    private readonly SemaphoreSlim _semaphore;
    private readonly CancellationTokenSource _cts = new();
    private IScannerInput _scanner;

    public HighVolumeScanner()
    {
        InitializeComponent();
        IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";
        _semaphore = new SemaphoreSlim(Environment.ProcessorCount);
        InitializeScanner();
        _ = RunProcessingLoopAsync();
    }

    private void InitializeScanner()
    {
        _scanner = System.IO.Ports.SerialPort.GetPortNames().Any()
            ? new SerialPortScanner("COM3", 115200)
            : new KeyboardWedgeScanner(txtScannerInput);

        _scanner.BarcodeScanned += (_, barcode) =>
            _scanQueue.Enqueue((barcode, DateTime.UtcNow));

        _scanner.StartListening();
    }

    private async Task RunProcessingLoopAsync()
    {
        while (!_cts.Token.IsCancellationRequested)
        {
            if (_scanQueue.TryDequeue(out var scan))
            {
                await _semaphore.WaitAsync(_cts.Token);
                _ = Task.Run(async () =>
                {
                    try { await ProcessScanAsync(scan.Data, scan.Timestamp); }
                    finally { _semaphore.Release(); }
                }, _cts.Token);
            }
            else
            {
                await Task.Delay(10, _cts.Token);
            }
        }
    }

    private async Task ProcessScanAsync(string rawData, DateTime scanTime)
    {
        var options = new BarcodeReaderOptions
        {
            Speed = ReadingSpeed.Balanced,
            ExpectMultipleBarcodes = false,
            ExpectBarcodeTypes = BarcodeEncoding.Code128 | BarcodeEncoding.QRCode,
            MaxParallelThreads = 1
        };

        var testBarcode = BarcodeWriter.CreateBarcode(rawData, BarcodeEncoding.Code128);
        var results = await BarcodeReader.ReadAsync(testBarcode.ToBitmap(), options);

        if (results.Any())
        {
            var item = results.First();
            BeginInvoke(() => UpdateInventoryDisplay(item.Value, scanTime));
        }
        else
        {
            BeginInvoke(() => LogRejectedScan(rawData, scanTime));
        }
    }

    protected override void OnFormClosing(FormClosingEventArgs e)
    {
        _cts.Cancel();
        _scanner.StopListening();
        base.OnFormClosing(e);
    }
}

Le SemaphoreSlim limite les tâches de validation simultanées au nombre de processeurs logiques, empêchant la création de threads incontrôlés lors d'événements de balayage en rafale. L'appel BeginInvoke renvoie les mises à jour de l'interface utilisateur au thread principal en toute sécurité.

Comment optimiser les performances pour différents volumes de numérisation ?

La propriété BarcodeReaderOptions.Speed accepte ReadingSpeed.Faster, ReadingSpeed.Balanced et ReadingSpeed.Detailed. Pour l'entrée du scanner USB où la valeur de la chaîne est déjà connue, Balanced est approprié -- le décodeur n'a besoin que de confirmer le format, pas de localiser un code-barres dans une image. Selon la documentation sur la vitesse de lecture d'IronBarcode , le mode Faster ignore certains algorithmes de correction de distorsion, ce qui est sûr pour une sortie de scanner propre mais peut manquer des codes-barres endommagés dans les scénarios basés sur l'image.

Le tableau suivant récapitule quand utiliser chaque mode de vitesse :

Pour les applications qui traitent également des images ou des PDF en plus de l'entrée d'un scanner USB, IronBarcode peut lire les codes-barres des documents PDF et des fichiers TIFF multipages en utilisant la même interface API.

Quels modes de défaillance les développeurs doivent-ils anticiper ?

Les applications de numérisation USB présentent des défaillances prévisibles. Les problèmes les plus courants et leurs solutions sont les suivants :

Déconnexion du scanner -- Lorsqu'un scanner USB est débranché, le contrôle TextBox perd son clavier virtuel. La solution la plus simple consiste en une minuterie périodique qui vérifie _inputBox.Focused et la recentre si le scanner est toujours répertorié dans les périphériques HID connectés. Pour les scanners série, SerialPort.GetPortNames() détecte la reconnexion.

Formats de codes-barres ambigus -- Certains produits portent des codes-barres valides dans plusieurs symbologies. Par exemple, une chaîne de 12 chiffres est un code UPC-A valide et également un code 128 valide. Spécifier ExpectBarcodeTypes dans BarcodeReaderOptions contraint le décodeur à vos formats attendus et élimine toute ambiguïté. Le guide de dépannage IronBarcode contient des conseils de reconnaissance spécifiques au format.

Exceptions de format non valide -- Si BarcodeWriter.CreateBarcode reçoit une chaîne qui enfreint les règles d'encodage sélectionnées (par exemple, des caractères alphabétiques dans un champ EAN-13 uniquement numérique), il génère une exception IronBarCode.Exceptions.InvalidBarcodeException. Envelopper l'appel dans un bloc try-catch et recourir à une validation basée uniquement sur les chaînes de caractères permet à l'application de continuer à fonctionner.

Collisions de synchronisation des frappes au clavier -- Dans les environnements où les opérateurs saisissent également manuellement du texte dans la même zone de texte, l'approche du minuteur en rafale décrite précédemment constitue la principale défense. Une protection secondaire concerne la longueur minimale : la plupart des codes-barres réels comportent au moins 8 caractères, donc les chaînes plus courtes peuvent être traitées comme une entrée clavier.

La documentation Microsoft .NET sur System.IO.Ports.SerialPort est utile pour le dépannage de la connectivité du scanner série, en particulier autour des paramètres ReadTimeout et WriteTimeout. Pour assurer la conformité réglementaire dans le secteur du commerce de détail, les spécifications générales GS1 définissent des plages de valeurs valides pour chaque identifiant d'application.

Comment étendre l'application aux plateformes mobiles et web ?

Le modèle d'interface du scanner illustré ci-dessus -- IScannerInput avec BarcodeScanned événement -- abstrait le matériel de la logique de traitement. L'échange d'implémentations permet d'exécuter le même code de validation et de génération sur différentes plateformes :

• .NET MAUI fournit une implémentation de scanner basée sur une caméra pour les tablettes Android et iOS utilisées comme stations de réception mobiles
• Blazor Server prend en charge la numérisation basée sur le navigateur avec un accès à la caméra JavaScript alimentant le même événement BarcodeScanned
• Les implémentations natives Android et iOS offrent aux développeurs mobiles la possibilité de scanner avec l'appareil photo grâce au même décodeur IronBarcode côté serveur.

Pour les architectures natives du cloud, les étapes de validation et de génération d'étiquettes peuvent être exécutées en tant que fonctions Azure déclenchées par des messages de file d'attente, l'application de bureau servant uniquement de passerelle d'entrée du scanner. Cette séparation est particulièrement utile lorsque la logique d'impression des étiquettes doit être centralisée à des fins d'audit de conformité.