O problema fundamental

O Scandit exige que a câmera esteja ligada antes que qualquer trabalho com código de barras possa começar. O IronBarcode requer apenas o caminho do arquivo:

// Scandit SDK: mandatory camera pipeline before first barcode read
var dataCaptureContext = DataCaptureContext.ForLicenseKey("YOUR-SCANDIT-LICENSE");
var settings = BarcodeCaptureSettings.Create();
settings.EnableSymbologies(new HashSet<Symbology>
{
    Symbology.Ean13Upca,
    Symbology.Ean8,
    Symbology.Code128,
    Symbology.QrCode
});
var barcodeCapture = BarcodeCapture.Create(dataCaptureContext, settings);
var camera = Camera.GetDefaultCamera();
await dataCaptureContext.SetFrameSourceAsync(camera);
await camera.SwitchToDesiredStateAsync(FrameSourceState.On);
barcodeCapture.IsEnabled = true;
// Results arrive later via BarcodeScanned event callback

// Scandit SDK: mandatory camera pipeline before first barcode read
var dataCaptureContext = DataCaptureContext.ForLicenseKey("YOUR-SCANDIT-LICENSE");
var settings = BarcodeCaptureSettings.Create();
settings.EnableSymbologies(new HashSet<Symbology>
{
    Symbology.Ean13Upca,
    Symbology.Ean8,
    Symbology.Code128,
    Symbology.QrCode
});
var barcodeCapture = BarcodeCapture.Create(dataCaptureContext, settings);
var camera = Camera.GetDefaultCamera();
await dataCaptureContext.SetFrameSourceAsync(camera);
await camera.SwitchToDesiredStateAsync(FrameSourceState.On);
barcodeCapture.IsEnabled = true;
// Results arrive later via BarcodeScanned event callback

Imports Scandit.DataCapture.Core
Imports Scandit.DataCapture.Barcode
Imports System.Collections.Generic

' Scandit SDK: mandatory camera pipeline before first barcode read
Dim dataCaptureContext = DataCaptureContext.ForLicenseKey("YOUR-SCANDIT-LICENSE")
Dim settings = BarcodeCaptureSettings.Create()
settings.EnableSymbologies(New HashSet(Of Symbology) From {
    Symbology.Ean13Upca,
    Symbology.Ean8,
    Symbology.Code128,
    Symbology.QrCode
})
Dim barcodeCapture = BarcodeCapture.Create(dataCaptureContext, settings)
Dim camera = Camera.GetDefaultCamera()
Await dataCaptureContext.SetFrameSourceAsync(camera)
Await camera.SwitchToDesiredStateAsync(FrameSourceState.On)
barcodeCapture.IsEnabled = True
' Results arrive later via BarcodeScanned event callback

// IronBarcode: direct file reading
// NuGet: dotnet add package IronBarcode
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";
var results = BarcodeReader.Read("barcode.png");
foreach (var result in results)
    Console.WriteLine($"{result.Value} ({result.Format})");

// IronBarcode: direct file reading
// NuGet: dotnet add package IronBarcode
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";
var results = BarcodeReader.Read("barcode.png");
foreach (var result in results)
    Console.WriteLine($"{result.Value} ({result.Format})");

Imports IronBarCode

' IronBarcode: direct file reading
' NuGet: dotnet add package IronBarcode
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY"
Dim results = BarcodeReader.Read("barcode.png")
For Each result In results
    Console.WriteLine($"{result.Value} ({result.Format})")
Next

Todo o bloco do pipeline da câmera — criação de contexto, configurações, ativação de simbologia, aquisição da câmera, atribuição da fonte do quadro, transição de estado — é substituído por uma atribuição de chave de licença e uma única chamada de método.

Passo 1: Substitua o pacote NuGet

Remover pacotes Scandit:

dotnet remove package Scandit.BarcodePicker
dotnet remove package Scandit.DataCapture.Core
dotnet remove package Scandit.DataCapture.Barcode

dotnet remove package Scandit.BarcodePicker
dotnet remove package Scandit.DataCapture.Core
dotnet remove package Scandit.DataCapture.Barcode

Instale o IronBarcode:

dotnet add package IronBarcode

dotnet add package IronBarcode

Etapa 2: Atualizar Namespaces

Substitua importações de namespaces do Scandit pelo namespace do IronBarcode:

// Before (Scandit SDK)
using Scandit.DataCapture.Core;
using Scandit.DataCapture.Barcode;
using Scandit.DataCapture.Barcode.Data;

// After (IronBarcode)
using IronBarCode;

// Before (Scandit SDK)
using Scandit.DataCapture.Core;
using Scandit.DataCapture.Barcode;
using Scandit.DataCapture.Barcode.Data;

// After (IronBarcode)
using IronBarCode;

' Before (Scandit SDK)
Imports Scandit.DataCapture.Core
Imports Scandit.DataCapture.Barcode
Imports Scandit.DataCapture.Barcode.Data

' After (IronBarcode)
Imports IronBarCode

Etapa 3: Inicializar a licença

Adicione a inicialização da licença no início da aplicação, substituindo a chamada DataCaptureContext.ForLicenseKey:

// Before (Scandit SDK)
var dataCaptureContext = DataCaptureContext.ForLicenseKey("YOUR-SCANDIT-LICENSE");

// After (IronBarcode)
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";

// Before (Scandit SDK)
var dataCaptureContext = DataCaptureContext.ForLicenseKey("YOUR-SCANDIT-LICENSE");

// After (IronBarcode)
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";

' Before (Scandit SDK)
Dim dataCaptureContext = DataCaptureContext.ForLicenseKey("YOUR-SCANDIT-LICENSE")

' After (IronBarcode)
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY"

Leitura de códigos de barras a partir de um arquivo de imagem

O processamento de um arquivo de imagem estática é um cenário de suporte principal no IronBarcode, mas um fluxo de trabalho não suportado no Scandit. O SDK da Scandit processa quadros de câmera ao vivo; A leitura de um arquivo exige a adaptação do pipeline de captura para tratar um bitmap como uma fonte de quadro, o que não possui implementação nativa.

Abordagem do SDK da Scandit:

// SDK Scandit has no direct file-read API.
// Reading a static image requires constructing a bitmap frame source
// and routing it through the capture pipeline — an unsupported workaround.
// The standard Scandit integration assumes a running camera at all times.

// SDK Scandit has no direct file-read API.
// Reading a static image requires constructing a bitmap frame source
// and routing it through the capture pipeline — an unsupported workaround.
// The standard Scandit integration assumes a running camera at all times.

' SDK Scandit has no direct file-read API.
' Reading a static image requires constructing a bitmap frame source
' and routing it through the capture pipeline — an unsupported workaround.
' The standard Scandit integration assumes a running camera at all times.

Abordagem do IronBarcode:

// NuGet: dotnet add package IronBarcode
using IronBarCode;

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

var results = BarcodeReader.Read("product-label.png");
foreach (var result in results)
{
    Console.WriteLine($"Value: {result.Value}");
    Console.WriteLine($"Format: {result.Format}");
    Console.WriteLine($"Confidence: {result.Confidence}%");
}

// NuGet: dotnet add package IronBarcode
using IronBarCode;

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

var results = BarcodeReader.Read("product-label.png");
foreach (var result in results)
{
    Console.WriteLine($"Value: {result.Value}");
    Console.WriteLine($"Format: {result.Format}");
    Console.WriteLine($"Confidence: {result.Confidence}%");
}

Imports IronBarCode

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

Dim results = BarcodeReader.Read("product-label.png")
For Each result In results
    Console.WriteLine($"Value: {result.Value}")
    Console.WriteLine($"Format: {result.Format}")
    Console.WriteLine($"Confidence: {result.Confidence}%")
Next

A leitura de códigos de barras em imagens com o IronBarcode não requer nenhuma configuração de pipeline. A coleção de resultados fica disponível imediatamente após o retorno do método, sem necessidade de inscrição em eventos.

Extraindo códigos de barras de um documento PDF

A extração de códigos de barras em PDF é um território totalmente novo para quem migra do Scandit, que não oferece suporte a PDFs. O IronBarcode lê documentos PDF diretamente, retornando resultados indexados por número de página.

Abordagem do SDK da Scandit:

// Scandit SDK: no PDF support.
// Implementing PDF barcode extraction with Scandit requires:
// 1. A separate PDF rendering library to convert pages to raster images
// 2. Routing each rendered image through the camera simulation pipeline
// 3. Correlating results back to page numbers manually
// This is not a supported workflow and requires significant custom engineering.

// Scandit SDK: no PDF support.
// Implementing PDF barcode extraction with Scandit requires:
// 1. A separate PDF rendering library to convert pages to raster images
// 2. Routing each rendered image through the camera simulation pipeline
// 3. Correlating results back to page numbers manually
// This is not a supported workflow and requires significant custom engineering.

' Scandit SDK: no PDF support.
' Implementing PDF barcode extraction with Scandit requires:
' 1. A separate PDF rendering library to convert pages to raster images
' 2. Routing each rendered image through the camera simulation pipeline
' 3. Correlating results back to page numbers manually
' This is not a supported workflow and requires significant custom engineering.

Abordagem do IronBarcode:

// NuGet: dotnet add package IronBarcode
using IronBarCode;

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

var results = BarcodeReader.Read("shipping-manifest.pdf");
foreach (var result in results)
{
    Console.WriteLine($"Page {result.PageNumber}: {result.Value} ({result.Format})");
}

// NuGet: dotnet add package IronBarcode
using IronBarCode;

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

var results = BarcodeReader.Read("shipping-manifest.pdf");
foreach (var result in results)
{
    Console.WriteLine($"Page {result.PageNumber}: {result.Value} ({result.Format})");
}

Imports IronBarCode

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

Dim results = BarcodeReader.Read("shipping-manifest.pdf")
For Each result In results
    Console.WriteLine($"Page {result.PageNumber}: {result.Value} ({result.Format})")
Next

Para obter orientações completas sobre como ler códigos de barras em documentos PDF , incluindo a seleção de intervalo de páginas e o processamento de múltiplos códigos de barras, a documentação do IronBarcode abrange toda a gama de cenários de processamento de PDF. Não é necessária nenhuma biblioteca PDF adicional.

Convertendo retornos de chamada de eventos em valores de retorno diretos

Scandit entrega resultados de códigos de barras através do evento BarcodeScanned porque a digitalização com câmera ao vivo é inerentemente assíncrona — os resultados chegam quando a câmera detecta um código de barras no quadro atual. O IronBarcode retorna os resultados como uma coleção tipada porque a leitura baseada em arquivos tem um limite de conclusão conhecido. Esta é uma das mudanças estruturalmente mais significativas na migração.

Abordagem do SDK da Scandit:

// Scandit SDK: event-driven result delivery
barcodeCapture.BarcodeScanned += (sender, args) =>
{
    foreach (var barcode in args.Session.NewlyRecognizedBarcodes)
    {
        string value = barcode.Data;
        string symbology = barcode.Symbology.ToString();

        // Processing logic embedded inside event handler
        LogBarcodeResult(value, symbology);
        UpdateInventory(value);
    }
};

// Scan continues indefinitely until camera session is terminated

// Scandit SDK: event-driven result delivery
barcodeCapture.BarcodeScanned += (sender, args) =>
{
    foreach (var barcode in args.Session.NewlyRecognizedBarcodes)
    {
        string value = barcode.Data;
        string symbology = barcode.Symbology.ToString();

        // Processing logic embedded inside event handler
        LogBarcodeResult(value, symbology);
        UpdateInventory(value);
    }
};

// Scan continues indefinitely until camera session is terminated

Imports System

' Scandit SDK: event-driven result delivery
AddHandler barcodeCapture.BarcodeScanned, Sub(sender, args)
    For Each barcode In args.Session.NewlyRecognizedBarcodes
        Dim value As String = barcode.Data
        Dim symbology As String = barcode.Symbology.ToString()

        ' Processing logic embedded inside event handler
        LogBarcodeResult(value, symbology)
        UpdateInventory(value)
    Next
End Sub

' Scan continues indefinitely until camera session is terminated

Abordagem do IronBarcode:

// NuGet: dotnet add package IronBarcode
using IronBarCode;

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

var results = BarcodeReader.Read("document.png");
foreach (var result in results)
{
    // Same processing logic, now in standard control flow
    LogBarcodeResult(result.Value, result.Format.ToString());
    UpdateInventory(result.Value);
}

// NuGet: dotnet add package IronBarcode
using IronBarCode;

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

var results = BarcodeReader.Read("document.png");
foreach (var result in results)
{
    // Same processing logic, now in standard control flow
    LogBarcodeResult(result.Value, result.Format.ToString());
    UpdateInventory(result.Value);
}

Imports IronBarCode

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

Dim results = BarcodeReader.Read("document.png")
For Each result In results
    ' Same processing logic, now in standard control flow
    LogBarcodeResult(result.Value, result.Format.ToString())
    UpdateInventory(result.Value)
Next

Toda a lógica de processamento que estava incorporada nos callbacks dos manipuladores de eventos é movida para código sequencial padrão. O tratamento de erros, o registro de logs e as operações subsequentes podem ser estruturados usando fluxo de controle comum em vez de padrões de tratamento de eventos.

Endpoint ASP.NET Core para upload de arquivos

Um endpoint de servidor sem estado que lê códigos de barras de um arquivo carregado representa o principal caso de uso do IronBarcode no lado do servidor. Esse padrão não é suportado pela arquitetura de pipeline de câmera da Scandit.

Abordagem do SDK da Scandit:

// Scandit SDK: not applicable to ASP.NET Core file upload scenarios.
// The DataCaptureContext requires a camera hardware session.
// There is no mechanism to process an IFormFile through the Scandit pipeline
// without substantial custom camera-simulation infrastructure.

// Scandit SDK: not applicable to ASP.NET Core file upload scenarios.
// The DataCaptureContext requires a camera hardware session.
// There is no mechanism to process an IFormFile through the Scandit pipeline
// without substantial custom camera-simulation infrastructure.

' Scandit SDK: not applicable to ASP.NET Core file upload scenarios.
' The DataCaptureContext requires a camera hardware session.
' There is no mechanism to process an IFormFile through the Scandit pipeline
' without substantial custom camera-simulation infrastructure.

Abordagem do IronBarcode:

// NuGet: dotnet add package IronBarcode
using IronBarCode;

[ApiController]
[Route("api/[controller]")]
public class BarcodeController : ControllerBase
{
    [HttpPost("scan")]
    public IActionResult ScanUploadedDocument(IFormFile file)
    {
        if (file == null || file.Length == 0)
            return BadRequest("No file provided");

        using var stream = file.OpenReadStream();
        var results = BarcodeReader.Read(stream);

        if (!results.Any())
            return NotFound("No barcodes detected");

        return Ok(results.Select(r => new
        {
            r.Value,
            Format = r.Format.ToString(),
            r.PageNumber
        }));
    }
}

// NuGet: dotnet add package IronBarcode
using IronBarCode;

[ApiController]
[Route("api/[controller]")]
public class BarcodeController : ControllerBase
{
    [HttpPost("scan")]
    public IActionResult ScanUploadedDocument(IFormFile file)
    {
        if (file == null || file.Length == 0)
            return BadRequest("No file provided");

        using var stream = file.OpenReadStream();
        var results = BarcodeReader.Read(stream);

        if (!results.Any())
            return NotFound("No barcodes detected");

        return Ok(results.Select(r => new
        {
            r.Value,
            Format = r.Format.ToString(),
            r.PageNumber
        }));
    }
}

Imports IronBarCode
Imports Microsoft.AspNetCore.Mvc

<ApiController>
<Route("api/[controller]")>
Public Class BarcodeController
    Inherits ControllerBase

    <HttpPost("scan")>
    Public Function ScanUploadedDocument(file As IFormFile) As IActionResult
        If file Is Nothing OrElse file.Length = 0 Then
            Return BadRequest("No file provided")
        End If

        Using stream = file.OpenReadStream()
            Dim results = BarcodeReader.Read(stream)

            If Not results.Any() Then
                Return NotFound("No barcodes detected")
            End If

            Return Ok(results.Select(Function(r) New With {
                .Value = r.Value,
                .Format = r.Format.ToString(),
                .PageNumber = r.PageNumber
            }))
        End Using
    End Function
End Class

O método BarcodeReader.Read aceita um Stream diretamente de IFormFile.OpenReadStream(), não exigindo a criação de um arquivo temporário. Os resultados são retornados de forma síncrona dentro do ciclo de solicitação-resposta, sem gerenciamento assíncrono da câmera.

Processamento simultâneo em lote de vários documentos

Filas de documentos de alto volume exigem processamento paralelo em várias threads. Como a API do IronBarcode é sem estado, ela é inerentemente segura para threads e se compõe diretamente com Parallel.ForEach e padrões de tarefas assíncronas.

Abordagem do SDK da Scandit:

// Scandit SDK: no supported batch file processing pattern.
// The FrameSourceState model assumes a continuous camera session,
// not a queue of discrete documents. Batch processing would require
// one camera simulation pipeline per document or serialized processing
// through a shared pipeline — neither is a supported workflow.

// Scandit SDK: no supported batch file processing pattern.
// The FrameSourceState model assumes a continuous camera session,
// not a queue of discrete documents. Batch processing would require
// one camera simulation pipeline per document or serialized processing
// through a shared pipeline — neither is a supported workflow.

' Scandit SDK: no supported batch file processing pattern.
' The FrameSourceState model assumes a continuous camera session,
' not a queue of discrete documents. Batch processing would require
' one camera simulation pipeline per document or serialized processing
' through a shared pipeline — neither is a supported workflow.

Abordagem do IronBarcode:

// NuGet: dotnet add package IronBarcode
using IronBarCode;
using System.Collections.Concurrent;

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

var options = new BarcodeReaderOptions
{
    Speed = ReadingSpeed.Balanced,
    ExpectMultipleBarcodes = true,
    MaxParallelThreads = 4
};

var files = Directory.GetFiles("./documents/", "*.pdf");
var allResults = new ConcurrentBag<(string File, BarcodeResult Result)>();

Parallel.ForEach(files, file =>
{
    var results = BarcodeReader.Read(file, options);
    foreach (var result in results)
        allResults.Add((file, result));
});

foreach (var (file, result) in allResults)
    Console.WriteLine($"{Path.GetFileName(file)}: {result.Value} ({result.Format})");

// NuGet: dotnet add package IronBarcode
using IronBarCode;
using System.Collections.Concurrent;

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

var options = new BarcodeReaderOptions
{
    Speed = ReadingSpeed.Balanced,
    ExpectMultipleBarcodes = true,
    MaxParallelThreads = 4
};

var files = Directory.GetFiles("./documents/", "*.pdf");
var allResults = new ConcurrentBag<(string File, BarcodeResult Result)>();

Parallel.ForEach(files, file =>
{
    var results = BarcodeReader.Read(file, options);
    foreach (var result in results)
        allResults.Add((file, result));
});

foreach (var (file, result) in allResults)
    Console.WriteLine($"{Path.GetFileName(file)}: {result.Value} ({result.Format})");

Imports IronBarCode
Imports System.Collections.Concurrent
Imports System.IO
Imports System.Threading.Tasks

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

Dim options As New BarcodeReaderOptions With {
    .Speed = ReadingSpeed.Balanced,
    .ExpectMultipleBarcodes = True,
    .MaxParallelThreads = 4
}

Dim files = Directory.GetFiles("./documents/", "*.pdf")
Dim allResults As New ConcurrentBag(Of (File As String, Result As BarcodeResult))()

Parallel.ForEach(files, Sub(file)
    Dim results = BarcodeReader.Read(file, options)
    For Each result In results
        allResults.Add((file, result))
    Next
End Sub)

For Each item In allResults
    Console.WriteLine($"{Path.GetFileName(item.File)}: {item.Result.Value} ({item.Result.Format})")
Next

Para padrões avançados que abrangem leitura assíncrona e multithread de códigos de barras , incluindo ajuste de throughput e configuração do número de threads, a documentação do IronBarcode fornece orientações detalhadas.

Problema 1: O código do pipeline da câmera não possui tradução direta.

Scandit SDK: O DataCaptureContext, BarcodeCaptureSettings, Camera, e o bloco de configuração BarcodeCapture abrangem 7–10 linhas de código de inicialização com transições de estado assíncronas.

Solução: Este bloco foi completamente apagado. Não possui equivalente ao IronBarcode porque a API baseada em arquivos do IronBarcode não requer inicialização de sessão. Substitua todo o bloco por:

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

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

Imports IronBarCode

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

Problema 2: Lógica do manipulador de eventos BarcodeScanned

Scandit SDK: A lógica de processamento é incorporada dentro de lambdas de manipulador de eventos BarcodeScanned += ou métodos. Esse padrão não existe no IronBarcode.

Solução: Mova o corpo do manipulador para o código padrão após a chamada BarcodeReader.Read:

// Before: event handler
barcodeCapture.BarcodeScanned += (s, args) =>
{
    foreach (var b in args.Session.NewlyRecognizedBarcodes)
        Console.WriteLine(b.Data);
};

// After: direct iteration
foreach (var result in BarcodeReader.Read("document.png"))
    Console.WriteLine(result.Value);

// Before: event handler
barcodeCapture.BarcodeScanned += (s, args) =>
{
    foreach (var b in args.Session.NewlyRecognizedBarcodes)
        Console.WriteLine(b.Data);
};

// After: direct iteration
foreach (var result in BarcodeReader.Read("document.png"))
    Console.WriteLine(result.Value);

Imports System

' Before: event handler
AddHandler barcodeCapture.BarcodeScanned, Sub(s, args)
    For Each b In args.Session.NewlyRecognizedBarcodes
        Console.WriteLine(b.Data)
    Next
End Sub

' After: direct iteration
For Each result In BarcodeReader.Read("document.png")
    Console.WriteLine(result.Value)
Next

Problema 3: Chamadas EnableSymbologies espalhadas pelo código-fonte

Scandit SDK: Múltiplos lugares na base de código podem chamar settings.EnableSymbologies(...) com diferentes conjuntos de simbologia para diferentes contextos de digitalização.

Solução: Remova todas as chamadas EnableSymbologies. Por padrão, o IronBarcode detecta automaticamente todos os formatos suportados. Se restrição de formato for necessária para desempenho em cenários específicos, use BarcodeReaderOptions.ExpectBarcodeTypes:

var options = new BarcodeReaderOptions
{
    ExpectBarcodeTypes = BarcodeEncoding.Code128 | BarcodeEncoding.QRCode
};
var results = BarcodeReader.Read("document.png", options);

var options = new BarcodeReaderOptions
{
    ExpectBarcodeTypes = BarcodeEncoding.Code128 | BarcodeEncoding.QRCode
};
var results = BarcodeReader.Read("document.png", options);

Imports System

Dim options As New BarcodeReaderOptions With {
    .ExpectBarcodeTypes = BarcodeEncoding.Code128 Or BarcodeEncoding.QRCode
}
Dim results = BarcodeReader.Read("document.png", options)

Problema 4: Ausência de leitura de PDF na base de código existente

SDK da Scandit: Se a base de código existente converte páginas PDF em imagens antes de enviá-las para o pipeline da Scandit, essa infraestrutura de renderização personalizada não é mais necessária.

Solução: Elimine completamente a etapa de conversão de PDF em imagem. Passe o caminho do PDF diretamente para o IronBarcode:

// Before: render PDF pages to images, then pass each image to Scandit pipeline
// (multiple steps, external PDF library dependency)

// After: pass PDF directly to IronBarcode
var results = BarcodeReader.Read("document.pdf");
// Results include PageNumber property for each detected barcode

// Before: render PDF pages to images, then pass each image to Scandit pipeline
// (multiple steps, external PDF library dependency)

// After: pass PDF directly to IronBarcode
var results = BarcodeReader.Read("document.pdf");
// Results include PageNumber property for each detected barcode

' Before: render PDF pages to images, then pass each image to Scandit pipeline
' (multiple steps, external PDF library dependency)

' After: pass PDF directly to IronBarcode
Dim results = BarcodeReader.Read("document.pdf")
' Results include PageNumber property for each detected barcode

Problema 5: Padrões de inicialização assíncrona da câmera

Scandit SDK: A inicialização da câmera usa await para SetFrameSourceAsync e SwitchToDesiredStateAsync. Se o código de chamada estiver estruturado em torno dessas operações assíncronas, removê-las simplifica a cadeia assíncrona.

Solução: Remova completamente a inicialização assíncrona da câmera. BarcodeReader.Read é síncrono. Se executar assíncronamente for necessário para a capacidade de resposta em um contexto de interface do usuário ou servidor, envolva-o em Task.Run:

// Async wrapper for non-blocking execution
var results = await Task.Run(() => BarcodeReader.Read("document.png"));

// Async wrapper for non-blocking execution
var results = await Task.Run(() => BarcodeReader.Read("document.png"));

Imports System.Threading.Tasks

' Async wrapper for non-blocking execution
Dim results = Await Task.Run(Function() BarcodeReader.Read("document.png"))

Tarefas pré-migração

Audite todos os pontos de integração do Scandit na base de código:

grep -r "DataCaptureContext\|BarcodeCaptureSettings\|BarcodeCapture" --include="*.cs" .
grep -r "EnableSymbologies\|BarcodeScanned\|NewlyRecognizedBarcodes" --include="*.cs" .
grep -r "using Scandit" --include="*.cs" .
grep -r "barcode\.Data\|barcode\.Symbology\|FrameSourceState" --include="*.cs" .

grep -r "DataCaptureContext\|BarcodeCaptureSettings\|BarcodeCapture" --include="*.cs" .
grep -r "EnableSymbologies\|BarcodeScanned\|NewlyRecognizedBarcodes" --include="*.cs" .
grep -r "using Scandit" --include="*.cs" .
grep -r "barcode\.Data\|barcode\.Symbology\|FrameSourceState" --include="*.cs" .

Documente todos os contextos de digitalização — identifique quais caminhos de código lidam com a digitalização da câmera em tempo real (permanecendo no Scandit) versus o processamento de arquivos ou documentos (migrando para o IronBarcode). Observe todos os locais onde as páginas PDF são renderizadas em imagens antes do processamento do Scandit, pois essa etapa de renderização será eliminada.

Tarefas de atualização de código

1. Remova os pacotes NuGet do Scandit (Scandit.BarcodePicker, Scandit.DataCapture.Core, Scandit.DataCapture.Barcode)
2. Instale o pacote NuGet IronBarcode
3. Substitua as importações de using Scandit.DataCapture.* por using IronBarCode
4. Apague todo o bloco de inicialização DataCaptureContext
5. Apague todas as chamadas de Camera.GetDefaultCamera() e SetFrameSourceAsync
6. Apague todas as chamadas de EnableSymbologies
7. Substitua barcodeCapture.IsEnabled = true por BarcodeReader.Read(filePath)
8. Converta manipuladores de eventos BarcodeScanned += para foreach sobre resultados de BarcodeReader.Read()
9. Substitua barcode.Data por result.Value
10. Substitua barcode.Symbology por result.Format
11. Remover os pipelines de renderização de PDF para imagem nos casos em que o IronBarcode lê PDFs diretamente.
12. Adicione IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY" na inicialização da aplicação

Testes pós-migração

Verifique o seguinte após concluir as atualizações de código:

• Confirme se os valores dos códigos de barras retornados pelo IronBarcode correspondem aos valores retornados anteriormente pelo Scandit para os mesmos documentos de entrada.
• Verifique se todos os formatos de códigos de barra suportados no conjunto de documentos são detectados sem configuração ExpectBarcodeTypes
• Teste se a extração de PDF retorna valores corretos de PageNumber para documentos de várias páginas
• Confirme se os endpoints do ASP.NET Core retornam resultados dentro de tempos de resposta aceitáveis ​​sob a carga esperada.
• Verificar se as implantações em Docker ou contêineres concluem a leitura de código de barras com sucesso sem o hardware da câmera.
• Teste o processamento em lote concorrente com Parallel.ForEach que produz resultados corretos sem condições de corrida
• Confirme se o aplicativo inicia e inicializa corretamente com a chave de licença do IronBarcode no lugar do contexto do Scandit.