Leitor de código de barras USB em C#: Crie um aplicativo de leitura completo

Por Que o Modo de Teclado HID Facilita a Integração?

A maioria dos scanners de código de barras USB vem configurada em modo de teclado HID por padrão. Quando você conecta um em uma máquina Windows, o sistema operacional o registra como um dispositivo de armazenamento USB (para configuração) e um teclado (para entrada de dados). Quando um código de barras é digitalizado, o dispositivo traduz o valor decodificado do código de barras em pressionamentos de teclas e os envia para qualquer janela de aplicativo que esteja em foco, adicionando um retorno de carro no final.

Do ponto de vista de um desenvolvedor C#, isso significa que você não precisa de SDKs de fornecedores, bibliotecas COM ou APIs USB especiais. Um TextBox padrão com um manipulador KeyDown é tudo o que é necessário para capturar a entrada. O principal desafio de integração é distinguir a entrada do scanner da digitação genuína do teclado. Os scanners normalmente entregam todos os caracteres em uma explosão muito curta -- muitas vezes abaixo de 50 milissegundos -- enquanto a digitação humana espalha os pressionamentos de teclas por centenas de milissegundos. Cronometrar a explosão é uma maneira confiável de filtrar pressionamentos de teclas acidentais.

Scanners de grau profissional também suportam modos seriais (RS-232 ou porta COM virtual) e USB HID diretos, que dão mais controle sobre caracteres de prefixo/sufixo e gatilhos de digitalização. O padrão de interface abaixo lida com ambos os casos:

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

O cronômetro de explosão na implementação de teclado HID é o detalhe chave. Ele é redefinido a cada pressionamento de tecla e somente dispara se os caracteres pararem de chegar -- significando que usuários de teclado genuínos que digitam devagar terão sua entrada incompleta descartada em vez de tratada como uma digitalização de código de barras.

Como Você Lida com Múltiplas Marcas de Scanners?

Ambientes corporativos frequentemente operam uma mistura de scanners Honeywell, Zebra (anteriormente Symbol/Motorola) e Datalogic no mesmo piso. Cada fornecedor tem seus próprios caracteres de término padrão, taxas de baud e convenções de prefixo/sufixo. Um modelo de configuração mantém seu aplicativo flexível:

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

Armazenar essas configurações em um arquivo de configurações ou banco de dados significa que o pessoal do armazém pode trocar os modelos de scanners sem necessitar de uma redistribuição. O campo ScannerType determina qual implementação IScannerInput é instanciada na inicialização.

Qual É a Maneira Mais Rápida de Adicionar IronBarcode via NuGet?

Abra o Console do Gerenciador de Pacotes no Visual Studio e execute:

Install-Package IronBarCode

Install-Package IronBarCode

Alternativamente, use o .NET CLI:

dotnet add package IronBarCode

dotnet add package IronBarCode

Ambos os comandos puxam a versão atual do NuGet.org e adicionam a referência do assembly ao seu arquivo de projeto. A biblioteca visa o .NET Standard 2.0, portanto, funciona em .NET Framework 4.6.2 até .NET 10 sem necessidade de shims de compatibilidade adicionais.

Após instalar, defina sua chave de licença antes de chamar qualquer método IronBarcode. Para desenvolvimento e avaliação, uma chave de teste gratuita está disponível na página de licenciamento IronBarcode:

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

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

Para implantações containerizadas, IronBarcode funciona com Docker no Linux, e para funções de nuvem, suporta AWS Lambda e Azure Functions.

Qual É a Abordagem Correta para Verificação de Formato?

IronBarcode suporta mais de 30 simbologias de códigos de barras, incluindo Code 128, EAN-13, Code 39, códigos QR e Data Matrix. Para aplicações com scanner USB, o padrão de validação re-codifica a string digitalizada como uma imagem de código de barras e a lê imediatamente de volta através do decodificador. Este ciclo confirma que a string é um valor válido para o formato declarado:

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; } = "";
}

Para códigos de barras GS1-128 usados em aplicações de cadeia de suprimentos, a string escaneada inclui prefixos identificadores de aplicação entre parênteses, como (01) para GTIN e (17) para data de validade. IronBarcode analisa automaticamente esses identificadores de aplicação quando você especifica BarcodeEncoding.GS1_128.

Que Lógica de Verificação de Dígitos de Controle EAN-13 Os Desenvolvedores Devem Implementar?

Aplicações de ponto de venda no varejo frequentemente precisam verificar dígitos de controle EAN-13 independentemente antes de passar o valor para uma pesquisa de preços. O checksum estilo Luhn para EAN-13 alterna pesos de 1 e 3 nos primeiros 12 dígitos:

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

Esta verificação puramente lógica é executada antes da codificação para evitar a sobrecarga de geração de imagens em ciclo para cada digitalização em um ambiente de varejo de alto volume. De acordo com a especificação GS1, o algoritmo de dígito de controle é idêntico para UPC-A (12 dígitos) quando você remove o zero inicial.

Quando um Aplicativo Deve Criar Novos Códigos de Barras Após uma Digitalização?

Um padrão comum no recebimento de armazém é o fluxo de trabalho "digitalizar e re-etiquetar": um item recebido traz um código de barras do fornecedor (comumente EAN-13 ou ITF-14), e o sistema de gestão de armazém precisa imprimir uma etiqueta interna Code 128 com seus próprios códigos de local e lote. As capacidades de geração do IronBarcode lidam com isso em poucas linhas:

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

Salvar como PDF é especialmente útil para impressoras de etiquetas que aceitam entrada PDF através de compartilhamento de rede. Você também pode exportar como SVG para saída de etiqueta térmica de qualidade vetorial, ou exportar como um fluxo de bytes para enviar diretamente para uma API de impressora de etiquetas.

IronBarcode suporta customização extensa de estilo, incluindo cores personalizadas, ajustes de margem, sobreposições de texto legível por humanos e, para códigos QR, incorporação de logotipo para etiquetas móveis marcadas por marca.

Como é uma Implementação Baseada em Fila de Produção?

Para aplicativos que processam dezenas de escaneamentos por minuto, um manipulador síncrono simples na thread da interface se torna um gargalo. O padrão abaixo desacopla a captura de escaneamento do processamento usando um ConcurrentQueue<t> e um loop de processamento em segundo plano. A API assíncrona do IronBarcode lida com a validação sem bloquear a interface do usuário:

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.Equilibrado,
            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.Equilibrado,
            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);
    }
}

O SemaphoreSlim limita tarefas de validação concorrente ao número de processadores lógicos, evitando a criação descontrolada de threads durante eventos de escaneamento em massa. As chamadas BeginInvoke gerenciam atualizações de UI de volta à thread principal de forma segura.

Como Ajustar o Desempenho para Diferentes Volumes de Escaneamento?

A propriedade BarcodeReaderOptions.Speed aceita ReadingSpeed.Mais Rápido, ReadingSpeed.Equilibrado e ReadingSpeed.Detalhado. Para entrada de scanner USB onde o valor da string já é conhecido, Equilibrado é apropriado -- o decodificador apenas precisa confirmar o formato, não localizar um código de barras em uma imagem. De acordo com a documentação de velocidade de leitura do IronBarcode, o modo Mais Rápido ignora alguns algoritmos de correção de distorção, o que é seguro para saída limpa de scanners mas pode perder códigos de barras danificados em cenários baseados em imagens.

A tabela a seguir resume quando usar cada modo de velocidade:

Para aplicativos que também processam imagens ou PDFs junto com entrada de scanner USB, IronBarcode pode ler códigos de barras de documentos PDF e arquivos TIFF de várias páginas usando a mesma superfície de API.

Quais Modos de Falha os Desenvolvedores Devem Antecipar?

Aplicativos de scanner USB falham de maneiras previsíveis. Os problemas mais comuns e suas mitigações são:

Desconexão do scanner -- Quando um scanner USB é desconectado, o TextBox da cunha do teclado perde seu teclado virtual. A mitigação mais simples é um temporizador periódico que verifica _inputBox.Focused e o refoca se o scanner ainda estiver listado em dispositivos HID conectados. Para scanners seriais, SerialPort.GetPortNames() detecta reconexão.

Formatos de código de barras ambíguos -- Alguns produtos possuem códigos de barras válidos em múltiplas simbologias. Por exemplo, uma string de 12 dígitos é um UPC-A válido e também um Código 128 válido. Especificar ExpectBarcodeTypes em BarcodeReaderOptions limita o decodificador aos seus formatos esperados e elimina a ambiguidade. O guia de solução de problemas do IronBarcode cobre dicas de reconhecimento específicas para cada formato.

Exceções de formato inválido -- Se BarcodeWriter.CreateBarcode receber uma string que viole as regras da codificação selecionada (por exemplo, caracteres alfabéticos em um campo EAN-13 numérico), ele lança um IronBarCode.Exceptions.InvalidBarcodeException. Envolver a chamada em um try-catch e recorrer a um caminho de validação apenas de string mantém o aplicativo funcionando.

Colisões de tempo de pressionamento de tecla -- Em ambientes onde os operadores também digitam manualmente no mesmo TextBox, a abordagem de temporizador de explosão descrita anteriormente é a principal defesa. Uma proteção secundária é o comprimento mínimo: a maioria dos códigos de barras reais tem pelo menos 8 caracteres, então cadeias de caracteres mais curtas que isso podem ser tratadas como entrada de teclado.

A documentação da Microsoft .NET sobre System.IO.Ports.SerialPort é útil ao solucionar problemas de conectividade de scanner serial, particularmente em relação às configurações ReadTimeout e WriteTimeout. Para conformidade regulatória no varejo, as Especificações Gerais GS1 definem faixas de valores válidos para cada identificador de aplicação.

Como você estende o aplicativo para plataformas móveis e web?

O padrão de interface do scanner mostrado acima -- IScannerInput com o evento BarcodeScanned -- abstrai o hardware da lógica de processamento. Trocar implementações permite que o mesmo código de validação e geração seja executado em diferentes plataformas:

• .NET MAUI oferece uma implementação de scanner baseada em câmera para tablets Android e iOS usados como estações móveis de recebimento
• Blazor Server suporta escaneamento baseado em navegador com acesso a câmera via JavaScript alimentando no mesmo evento BarcodeScanned
• Implementações nativas do Android e iOS oferecem aos desenvolvedores móveis a capacidade de digitalizar com a câmera usando o mesmo decodificador IronBarcode no backend

Para arquiteturas nativas de nuvem, as etapas de validação e geração de etiquetas podem ser executadas como Azure Functions acionadas por mensagens de fila, com o aplicativo desktop atuando apenas como a porta de entrada de entrada do scanner. Essa separação é particularmente útil quando a lógica de impressão de etiquetas deve ser centralizada para auditoria de conformidade.