Le problème fondamental

Scandit exige que la caméra soit en marche avant de pouvoir commencer tout traitement des codes-barres. Code-barres IronBarcode ne nécessite qu'un chemin d'accès au fichier :

// 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

L'ensemble du bloc de pipeline de la caméra — création du contexte, paramètres, activation de la symbologie, acquisition de la caméra, attribution de la source d'image, transition d'état — est remplacé par une attribution de clé de licence et un seul appel de méthode.

Étape 1 : Remplacer le package NuGet

Supprimer les paquets 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

Installer IronBarcode:

dotnet add package IronBarcode

dotnet add package IronBarcode

Étape 2 : Mise à jour des espaces de noms

Remplacez les importations du namespace Scandit par celles du namespace Code-barres 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

Étape 3 : initialisation de la licence

Ajoutez l'initialisation de licence au démarrage de l'application, en remplaçant l'appel 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"

Lecture des codes-barres à partir d'un fichier image

Le traitement d'un fichier image statique est un scénario de base pris en charge par Code-barres IronBarcode et un flux de travail non pris en charge par Scandit. Le SDK Scandit traite les images de la caméra en direct ; La lecture d'un fichier nécessite d'adapter le pipeline de capture pour traiter une image bitmap comme une source d'images, ce qui ne dispose d'aucune implémentation native.

Approche du SDK Scandit :

// Kit de développement logiciel 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.

// Kit de développement logiciel 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.

' Kit de développement logiciel 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.

Approche 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

La lecture des codes-barres à partir d'images avec Code-barres IronBarcode ne nécessite aucune configuration de pipeline. Les résultats sont disponibles immédiatement après l'exécution de la méthode, sans abonnement aux événements.

Extraction des codes-barres d'un document PDF

L'extraction de codes-barres PDF est un domaine totalement nouveau lors de la migration depuis Scandit, qui ne prend pas en charge les fichiers PDF. Code-barres IronBarcode lit directement les documents PDF et renvoie des résultats indexés par numéro de page.

Approche du SDK 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.

Approche 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

Pour obtenir des instructions complètes sur la lecture des codes-barres dans les documents PDF , y compris la sélection de la plage de pages et la gestion de plusieurs codes-barres, la documentation Code-barres IronBarcode couvre l'ensemble des scénarios de traitement PDF. Aucune dépendance supplémentaire à une bibliothèque PDF n'est requise.

Conversion des rappels d'événements en valeurs de retour directes

Scandit transmet les résultats de code-barres via l'événement BarcodeScanned car le balayage de caméra en direct est intrinsèquement asynchrone — les résultats arrivent lorsque la caméra détecte un code-barres dans le cadre actuel. Code-barres IronBarcode renvoie les résultats sous forme de collection typée car la lecture basée sur les fichiers a une limite d'achèvement connue. Il s'agit là de l'un des changements structurels les plus importants de cette migration.

Approche du SDK 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

Approche 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

Toute la logique de traitement qui était intégrée aux fonctions de rappel des gestionnaires d'événements est désormais déplacée vers du code séquentiel standard. La gestion des erreurs, la journalisation et les opérations en aval peuvent être structurées à l'aide d'un flux de contrôle ordinaire plutôt que de modèles de gestionnaires d'événements.

Point de terminaison ASP.NET Core pour le téléchargement de fichiers

Un point de terminaison de serveur sans état lisant les codes-barres d'un fichier téléchargé représente le principal cas d'utilisation côté serveur d' IronBarcode. Ce modèle n'est pas pris en charge par l'architecture de pipeline de caméra de Scandit.

Approche du SDK 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.

Approche 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

La méthode BarcodeReader.Read accepte un Stream directement depuis IFormFile.OpenReadStream(), sans nécessiter de création de fichier temporaire. Les résultats sont renvoyés de manière synchrone au sein du cycle requête-réponse, sans gestion asynchrone de la caméra.

Traitement par lots simultané de plusieurs documents

Les files d'attente de documents à volume élevé nécessitent un traitement parallèle sur plusieurs threads. Parce que l'API de Code-barres IronBarcode est sans état, elle est intrinsèquement sûre pour les threads et se compose directement avec Parallel.ForEach et les motifs de tâches asynchrones.

Approche du SDK 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.

Approche 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

Pour les modèles avancés couvrant la lecture asynchrone et multithread des codes-barres , y compris l'optimisation du débit et la configuration du nombre de threads, la documentation Code-barres IronBarcode fournit des instructions détaillées.

Problème 1 : Le code du pipeline de la caméra n'a pas de traduction directe

Scandit SDK : Le bloc de configuration DataCaptureContext, BarcodeCaptureSettings, Camera, et BarcodeCapture s'étend sur 7 à 10 lignes de code d'initialisation avec des transitions d'état asynchrones.

Solution : Ce bloc est entièrement supprimé. Il n'a pas d'équivalent à Code-barres IronBarcode car l'API d'IronBarcode, basée sur des fichiers, ne nécessite aucune initialisation de session. Remplacez tout le bloc par :

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

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

Imports IronBarCode

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

Problème 2 : Logique du gestionnaire d'événements BarcodeScanned

Scandit SDK : La logique de traitement est intégrée dans les gestionnaires d'événements lambdas ou méthodes BarcodeScanned +=. Ce modèle n'existe pas dans IronBarcode.

Solution : Déplacez le corps du gestionnaire dans le code standard suivant l'appel 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

Problème n° 3 : Appels EnableSymbologies dispersés dans le code source

Scandit SDK : Plusieurs endroits dans la base de code peuvent appeler settings.EnableSymbologies(...) avec différents ensembles de symbologies pour différents contextes de balayage.

Solution : Supprimez tous les appels EnableSymbologies. Code-barres IronBarcode détecte automatiquement tous les formats pris en charge par défaut. Si une restriction de format est nécessaire pour la performance dans des scénarios spécifiques, utilisez 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)

Problème n° 4 : Absence de lecture de fichiers PDF dans le code source existant

Kit de développement logiciel Scandit : Si le code source existant convertit les pages PDF en images avant de les intégrer au pipeline Scandit, cette infrastructure de rendu personnalisée n'est plus nécessaire.

Solution : Supprimer complètement l'étape de rendu PDF-image. Transmettez directement le chemin du PDF à 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

Problème 5 : Modèles d'initialisation asynchrone de la caméra

Scandit SDK : L'initialisation de la caméra utilise await pour SetFrameSourceAsync et SwitchToDesiredStateAsync. Si le code appelant est structuré autour de ces opérations asynchrones, leur suppression simplifie la chaîne asynchrone.

Solution : Supprimer complètement l'initialisation asynchrone de la caméra. BarcodeReader.Read est synchrone. Si une exécution asynchrone est nécessaire pour la réactivité dans un contexte d'interface utilisateur ou de serveur, enveloppez-la dans 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"))

Tâches préalables à la migration

Auditez tous les points d'intégration Scandit dans le code source :

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

Documentez tous les contextes de numérisation — identifiez les chemins de code qui gèrent la numérisation par caméra en temps réel (en restant sur Scandit) par rapport au traitement des fichiers ou des documents (en migrant vers IronBarcode). Veuillez noter tous les endroits où les pages PDF sont converties en images avant le traitement Scandit, car cette étape de conversion sera éliminée.

Tâches de mise à jour du code

1. Supprimez les paquets NuGet Scandit (Scandit.BarcodePicker, Scandit.DataCapture.Core, Scandit.DataCapture.Barcode)
2. Installez le paquet NuGet IronBarcode
3. Remplacez les importations using Scandit.DataCapture.* par using IronBarCode
4. Supprimez entièrement le bloc d'initialisation DataCaptureContext
5. Supprimez tous les appels Camera.GetDefaultCamera() et SetFrameSourceAsync
6. Supprimez tous les appels EnableSymbologies
7. Remplacez barcodeCapture.IsEnabled = true par BarcodeReader.Read(filePath)
8. Convertissez les gestionnaires d'événements BarcodeScanned += en foreach sur les résultats BarcodeReader.Read()
9. Remplacez barcode.Data par result.Value
10. Remplacez barcode.Symbology par result.Format
11. Supprimer les chaînes de rendu PDF-image, car Code-barres IronBarcode lit désormais directement les PDF.
12. Ajoutez IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY" au démarrage de l'application

Test de post-migration

Après avoir effectué les mises à jour du code, veuillez vérifier les points suivants :

• Vérifier que les valeurs des codes-barres renvoyées par Code-barres IronBarcode correspondent aux valeurs précédemment renvoyées par Scandit pour les mêmes documents d'entrée.
• Vérifiez que tous les formats de code-barres pris en charge dans le jeu de documents sont détectés sans configuration ExpectBarcodeTypes
• Testez que l'extraction PDF renvoie les valeurs PageNumber correctes pour les documents multi-pages
• Vérifier que les points de terminaison ASP.NET Core renvoient des résultats dans des délais de réponse acceptables sous la charge prévue.
• Vérifier que les déploiements Docker ou conteneurisés effectuent correctement la lecture des codes-barres sans matériel de caméra.
• Vérifiez que le traitement par lots concurrent avec Parallel.ForEach produit des résultats corrects sans conditions de concurrence
• Vérifiez que l'application démarre et s'initialise correctement avec la clé de licence Code-barres IronBarcode à la place du contexte Scandit