Como Lidar com Verificação de Nulo para Operações de Código de Barras em C

Como Lidar com Resultados de Código de Barras Nulos e Vazios?

BarcodeReader.Read() retorna BarcodeResults, que é uma coleção de objetos BarcodeResult. Existem dois modos de falha que precisam de proteção: a própria coleção sendo nula (a entrada não foi reconhecida como uma imagem válida), e a coleção sendo vazia (imagem válida, mas nenhum código de barras encontrado). Acessar .First(), .Value ou iterar sem verificar ambas as condições resulta em uma exceção em tempo de execução.

O padrão de proteção padrão verifica ambas as condições antes de entrar no loop de processamento:

using IronBarCode;

BarcodeResults results = BarcodeReader.Read("shipping-label.png");

// Null check: image may not be recognized
// Empty check: image recognized but no barcodes found
if (results is null || results.Count == 0)
{
    // Log, return a default, or throw a domain-specific exception
    Console.WriteLine("No barcodes found in the input image.");
    return;
}

foreach (BarcodeResult result in results)
{
    // Guard individual result properties
    if (string.IsNullOrWhiteSpace(result.Value))
    {
        Console.WriteLine($"Empty value detected for {result.BarcodeType}");
        continue;
    }

    Console.WriteLine($"Type: {result.BarcodeType}, Value: {result.Value}");
}

using IronBarCode;

BarcodeResults results = BarcodeReader.Read("shipping-label.png");

// Null check: image may not be recognized
// Empty check: image recognized but no barcodes found
if (results is null || results.Count == 0)
{
    // Log, return a default, or throw a domain-specific exception
    Console.WriteLine("No barcodes found in the input image.");
    return;
}

foreach (BarcodeResult result in results)
{
    // Guard individual result properties
    if (string.IsNullOrWhiteSpace(result.Value))
    {
        Console.WriteLine($"Empty value detected for {result.BarcodeType}");
        continue;
    }

    Console.WriteLine($"Type: {result.BarcodeType}, Value: {result.Value}");
}

Cada BarcodeResult expõe .Value e .Text como propriedades de string — ambas retornam o conteúdo decodificado do código de barras. Na operação normal, estes são preenchidos, mas existem casos extremos: códigos de barras severamente danificados, digitalizações parciais ou detecções de baixa confiança podem produzir resultados onde o valor está vazio ou em branco. Verificar string.IsNullOrWhiteSpace() em resultados individuais detecta esses casos antes que os dados se propaguem.

A propriedade .Confidence (um double entre 0.0 e 1.0) fornece um sinal de qualidade adicional. Para sistemas de produção, podemos combinar a verificação de nulo com um limite de confiança:

double minimumConfidence = 0.7;

var validResults = results
    .Where(r => !string.IsNullOrWhiteSpace(r.Value) && r.Confidence >= minimumConfidence)
    .ToList();

if (validResults.Count == 0)
{
    Console.WriteLine("No barcodes met the confidence threshold.");
    return;
}

double minimumConfidence = 0.7;

var validResults = results
    .Where(r => !string.IsNullOrWhiteSpace(r.Value) && r.Confidence >= minimumConfidence)
    .ToList();

if (validResults.Count == 0)
{
    Console.WriteLine("No barcodes met the confidence threshold.");
    return;
}

A classe BarcodeReaderOptions também fornece uma propriedade MinimumConfidence que filtra no nível da varredura, em vez de pós-processamento. Definir isso no objeto de opções é mais limpo para cenários de digitalização em lote de alto rendimento.

Como Aplicar Padrões Seguros para Nulos na Escrita de Códigos de Barras?

BarcodeWriter.CreateBarcode() aceita um valor de string e um enum BarcodeWriterEncoding ou BarcodeEncoding. Passar uma string nula ou vazia lança uma exceção. Além disso, aplicam-se restrições específicas de formato — o EAN-8 requer exatamente de 7-8 dígitos numéricos, o UPC-A requer 11-12 dígitos, e o Code 128 tem um limite máximo de caracteres. Violar essas restrições também lança uma exceção.

O padrão defensivo valida as entradas antes de chamar CreateBarcode():

using IronBarCode;

string inputValue = GetValueFromUserOrDatabase(); // Could be null

// Guard: null, empty, or whitespace
if (string.IsNullOrWhiteSpace(inputValue))
{
    Console.WriteLine("Cannot generate barcode: input value is null or empty.");
    return;
}

// Guard: format-specific constraints (example: EAN-8 requires 7-8 digits)
BarcodeWriterEncoding encoding = BarcodeWriterEncoding.EAN8;
if (encoding == BarcodeWriterEncoding.EAN8 && !System.Text.RegularExpressions.Regex.IsMatch(inputValue, @"^\d{7,8}$"))
{
    Console.WriteLine("EAN-8 requires exactly 7 or 8 numeric digits.");
    return;
}

GeneratedBarcode barcode = BarcodeWriter.CreateBarcode(inputValue, encoding);
barcode.SaveAsPng("output-barcode.png");

using IronBarCode;

string inputValue = GetValueFromUserOrDatabase(); // Could be null

// Guard: null, empty, or whitespace
if (string.IsNullOrWhiteSpace(inputValue))
{
    Console.WriteLine("Cannot generate barcode: input value is null or empty.");
    return;
}

// Guard: format-specific constraints (example: EAN-8 requires 7-8 digits)
BarcodeWriterEncoding encoding = BarcodeWriterEncoding.EAN8;
if (encoding == BarcodeWriterEncoding.EAN8 && !System.Text.RegularExpressions.Regex.IsMatch(inputValue, @"^\d{7,8}$"))
{
    Console.WriteLine("EAN-8 requires exactly 7 or 8 numeric digits.");
    return;
}

GeneratedBarcode barcode = BarcodeWriter.CreateBarcode(inputValue, encoding);
barcode.SaveAsPng("output-barcode.png");

A API de escrita do IronBarcode executa sua própria validação interna — verifica checksums, verifica restrições de comprimento e rejeita caracteres inválidos para a codificação selecionada. Essas verificações lançam System.Exception com mensagens descritivas. As cláusulas de proteção acima capturam problemas antes que eles alcancem a biblioteca, o que nos dá controle sobre a mensagem de erro e o fluxo. Para uma lista completa de codificações suportadas e suas restrições, veja o como criar códigos de barras e o criar código de barras a partir de dados.

Como Validar Resultados Antes do Processamento Posterior?

Quando os dados de código de barras são usados em outro sistema — uma gravação de banco de dados, uma chamada de API, uma impressora de etiquetas — precisamos de um portão de validação que verifique a contagem dos resultados, a integridade do valor individual e o tipo de código de barras antes da transferência. Isso consolida a lógica de verificação de nulos em um único método reutilizável.

using IronBarCode;
using System.Collections.Generic;
using System.Linq;

public static class BarcodeValidator
{
    public static List<BarcodeResult> GetValidResults(
        string imagePath,
        BarcodeEncoding? expectedType = null,
        double minimumConfidence = 0.7)
    {
        BarcodeResults results = BarcodeReader.Read(imagePath);

        if (results is null || results.Count == 0)
            return new List<BarcodeResult>();

        return results
            .Where(r => !string.IsNullOrWhiteSpace(r.Value))
            .Where(r => r.Confidence >= minimumConfidence)
            .Where(r => expectedType == null || r.BarcodeType == expectedType)
            .ToList();
    }
}

// Usage
var validated = BarcodeValidator.GetValidResults(
    "warehouse-scan.png",
    expectedType: BarcodeEncoding.Code128,
    minimumConfidence: 0.85);

if (validated.Count == 0)
{
    // No valid results — log and skip downstream processing
    return;
}

// Safe to pass to downstream systems
foreach (var barcode in validated)
{
    SendToInventorySystem(barcode.Value, barcode.BarcodeType.ToString());
}

using IronBarCode;
using System.Collections.Generic;
using System.Linq;

public static class BarcodeValidator
{
    public static List<BarcodeResult> GetValidResults(
        string imagePath,
        BarcodeEncoding? expectedType = null,
        double minimumConfidence = 0.7)
    {
        BarcodeResults results = BarcodeReader.Read(imagePath);

        if (results is null || results.Count == 0)
            return new List<BarcodeResult>();

        return results
            .Where(r => !string.IsNullOrWhiteSpace(r.Value))
            .Where(r => r.Confidence >= minimumConfidence)
            .Where(r => expectedType == null || r.BarcodeType == expectedType)
            .ToList();
    }
}

// Usage
var validated = BarcodeValidator.GetValidResults(
    "warehouse-scan.png",
    expectedType: BarcodeEncoding.Code128,
    minimumConfidence: 0.85);

if (validated.Count == 0)
{
    // No valid results — log and skip downstream processing
    return;
}

// Safe to pass to downstream systems
foreach (var barcode in validated)
{
    SendToInventorySystem(barcode.Value, barcode.BarcodeType.ToString());
}

O método validador retorna uma lista vazia em vez de nula — isso elimina a necessidade de os chamadores verificarem nulos no valor de retorno, que é um padrão defensivo padrão. O parâmetro opcional expectedType garante que o sistema a jusante receba apenas o formato de código de barras que espera, o que evita incompatibilidades quando uma varredura capta tanto um QR code quanto um Code 128 da mesma imagem.

Para leitura em lote de vários arquivos, aplique o mesmo padrão por arquivo e agregue resultados. A classe BarcodeReaderOptions suporta ExpectBarcodeTypes para filtrar no nível da varredura, o que reduz o ruído antes da validação.

Próximos passos

A verificação de nulos para operações do IronBarcode resume-se a dois padrões: proteja a coleção BarcodeResults (nula + vazia) antes de ler propriedades e valide strings de entrada antes de escrever. O validador reutilizável acima centraliza ambas as preocupações.

Para uma cobertura mais aprofundada, explore o tutorial de leitura de códigos de barras para configuração de varredura, o guia de formatos de dados de saída para todas as propriedades BarcodeResult e a referência de API para a superfície completa de tipos.

Inicie um teste gratuito de 30 dias para testar esses padrões contra dados reais de escaneamento. Quando estiver pronto, veja as opções de licenciamento a partir de $499.