Das grundsätzliche Problem

Scandit benötigt eine laufende Kamera, bevor mit der Barcode-Verarbeitung begonnen werden kann. IronBarcode benötigt lediglich einen Dateipfad:

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

Der gesamte Kamera-Pipeline-Block – Kontext-Erstellung, Einstellungen, Symbolisierungsaktivierung, Kameraerfassung, Frame-Quellen-Zuweisung, Zustandsübergang – wird durch eine Lizenzschlüsselzuweisung und einen einzigen Methodenaufruf ersetzt.

Schritt 1: Ersetzen des NuGet-Pakets

Scandit-Pakete entfernen:

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

IronBarcode installieren:

dotnet add package IronBarcode

dotnet add package IronBarcode

Schritt 2: Namespaces aktualisieren

Ersetzen Sie Scandit-Namespace-Importe durch den IronBarcode-Namespace:

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

Schritt 3: Lizenz initialisieren

Fügen Sie die Lizenzinitialisierung beim Start der Anwendung hinzu, indem Sie den DataCaptureContext.ForLicenseKey-Aufruf ersetzen:

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

Barcodes aus einer Bilddatei lesen

Die Verarbeitung einer statischen Bilddatei ist ein von IronBarcode standardmäßig unterstützter Anwendungsfall, während dies in Scandit ein nicht unterstützter Workflow ist. Das Scandit SDKverarbeitet Live-Kamerabilder; Das Lesen einer Datei erfordert die Anpassung der Aufnahmepipeline, um eine Bitmap als Framequelle zu behandeln, wofür es keine native Implementierung gibt.

Scandit SDK-Ansatz:

// Scandit SDKhas 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.

// Scandit SDKhas 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.

' Scandit SDK 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.

IronBarcode -Ansatz:

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

Das Einlesen von Barcodes aus Bildern mit IronBarcode erfordert keine Pipeline-Einrichtung. Die Ergebnissammlung steht unmittelbar nach Rückgabe der Methode zur Verfügung; ein Ereignisabonnement ist nicht erforderlich.

Barcodes aus einem PDF-Dokument extrahieren

Die Extraktion von PDF-Barcodes ist ein völlig neues Gebiet bei der Migration von Scandit, da Scandit keine PDF-Unterstützung bietet. IronBarcode liest PDF-Dokumente direkt und liefert Ergebnisse, die nach Seitenzahl indexiert sind.

Scandit SDK-Ansatz:

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

IronBarcode -Ansatz:

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

Eine vollständige Anleitung zum Lesen von Barcodes aus PDF-Dokumenten , einschließlich der Auswahl von Seitenbereichen und der Verarbeitung mehrerer Barcodes, finden Sie in der IronBarcode Dokumentation, die das gesamte Spektrum der PDF-Verarbeitungsszenarien abdeckt. Es ist keine zusätzliche PDF-Bibliothek erforderlich.

Umwandlung von Ereignis-Callbacks in direkte Rückgabewerte

Scandit liefert Barcode-Ergebnisse durch das BarcodeScanned-Ereignis, weil die Echtzeit-Kamera-Scannung inhärent asynchron ist – Ergebnisse treffen ein, wenn die Kamera einen Barcode im aktuellen Frame erkennt. IronBarcode gibt Ergebnisse als typisierte Sammlung zurück, da das dateibasierte Lesen eine bekannte Abschlussgrenze hat. Dies ist eine der strukturell bedeutendsten Veränderungen in der Migration.

Scandit SDK-Ansatz:

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

IronBarcode -Ansatz:

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

Die gesamte Verarbeitungslogik, die in Ereignisbehandlungs-Callbacks eingebettet war, wird in standardmäßigen sequenziellen Code verschoben. Fehlerbehandlung, Protokollierung und nachgelagerte Operationen können mithilfe gewöhnlicher Kontrollflussmuster anstatt Ereignisbehandlungsmuster strukturiert werden.

ASP.NET Core -Endpunkt für Datei-Upload

Ein zustandsloser Serverendpunkt, der Barcodes aus einer hochgeladenen Datei liest, stellt den primären serverseitigen Anwendungsfall für IronBarcode dar. Dieses Muster wird von der Kamera-Pipeline-Architektur von Scandit nicht unterstützt.

Scandit SDK-Ansatz:

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

IronBarcode -Ansatz:

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

Die BarcodeReader.Read-Methode akzeptiert ein Stream direkt von IFormFile.OpenReadStream(), ohne dass eine temporäre Datei erstellt werden muss. Die Ergebnisse werden synchron innerhalb des Anfrage-Antwort-Zyklus zurückgegeben, ohne asynchrone Kameraverwaltung.

Gleichzeitige Stapelverarbeitung mehrerer Dokumente

Bei der Verarbeitung großer Dokumentenmengen ist eine parallele Verarbeitung über mehrere Threads erforderlich. Da die API von IronBarcode zustandslos ist, ist sie von Natur aus thread-sicher und fügt sich direkt in Parallel.ForEach und asynchrone Aufgabenmuster ein.

Scandit SDK-Ansatz:

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

IronBarcode -Ansatz:

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

Für fortgeschrittene Muster, die das asynchrone und multithreadfähige Lesen von Barcodes abdecken, einschließlich Durchsatzoptimierung und Konfiguration der Threadanzahl, bietet die IronBarcode Dokumentation eine detaillierte Anleitung.

Problem 1: Der Kamera-Pipeline-Code hat keine direkte Übersetzung

Scandit SDK: Der DataCaptureContext, BarcodeCaptureSettings, Camera, und BarcodeCapture Einrichtungsblock umfasst 7–10 Zeilen Initialisierungscode mit asynchronen Zustandsübergängen.

Lösung: Dieser Block wird vollständig gelöscht. Es gibt kein Äquivalent zu IronBarcode , da die dateibasierte API von IronBarcode keine Sitzungsinitialisierung erfordert. Ersetzen Sie den gesamten Block durch:

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

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

Imports IronBarCode

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

Problem 2: Logik des Ereignishandlers für "Barcode gescannt"

Scandit SDK: Verarbeitungslogik ist in BarcodeScanned += Ereignishandler-Lambdas oder -Methoden eingebettet. Dieses Muster existiert nicht in IronBarcode.

Lösung: Verschieben Sie den Handlerkörper in den Standardcode nach dem BarcodeReader.Read-Aufruf:

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

Problem 3: Aufrufe von EnableSymbologies über den gesamten Quellcode verteilt

Scandit SDK: An mehreren Stellen im Code können settings.EnableSymbologies(...) mit unterschiedlichen Symbologie-Sets für unterschiedliche Scannkontexte aufgerufen werden.

Lösung: Entfernen Sie alle EnableSymbologies-Aufrufe. IronBarcode erkennt standardmäßig alle unterstützten Formate automatisch. Wenn eine Formatbeschränkung zur Leistungsoptimierung in bestimmten Szenarien erforderlich ist, verwenden Sie 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)

Problem 4: Keine PDF-Lesefunktion im bestehenden Quellcode

Scandit SDK: Wenn die bestehende Codebasis PDF-Seiten in Bilder umwandelt, bevor sie in die Scandit-Pipeline eingespeist werden, wird diese benutzerdefinierte Rendering-Infrastruktur nicht mehr benötigt.

Lösung: Den Schritt der PDF-zu-Bild-Konvertierung vollständig entfernen. Übergeben Sie den PDF-Pfad direkt an 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

Ausgabe 5: Muster für die asynchrone Kamerainitialisierung

Scandit SDK: Kamerainitialisierung verwendet await für SetFrameSourceAsync und SwitchToDesiredStateAsync. Wenn der aufrufende Code um diese asynchronen Operationen herum strukturiert ist, vereinfacht deren Entfernung die asynchrone Kette.

Lösung: Die asynchrone Kamerainitialisierung vollständig entfernen. BarcodeReader.Read ist synchron. Wenn eine asynchrone Ausführung zur Reaktionsfähigkeit in einer Benutzeroberflächen- oder Serverkontext erforderlich ist, wickeln Sie sie in Task.Run ein:

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

Vor der Migration anfallende Aufgaben

Überprüfen Sie alle Scandit-Integrationspunkte im Quellcode:

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

Dokumentieren Sie alle Scankontexte – identifizieren Sie, welche Codepfade das Echtzeit-Kamerascannen (bei Scandit) bzw. die Datei- oder Dokumentenverarbeitung (Migration zu IronBarcode) übernehmen. Beachten Sie alle Stellen, an denen PDF-Seiten vor der Scandit-Verarbeitung in Bilder umgewandelt werden, da dieser Rendering-Schritt entfällt.

Aufgaben der Code-Aktualisierung

1. Entfernen Sie Scandit NuGet-Pakete (Scandit.BarcodePicker, Scandit.DataCapture.Core, Scandit.DataCapture.Barcode)
2. Installieren Sie das IronBarcode NuGet-Paket
3. Ersetzen Sie using Scandit.DataCapture.* Importe durch using IronBarCode
4. Löschen Sie den DataCaptureContext Initialisierungsblock in seiner Gesamtheit
5. Löschen Sie alle Camera.GetDefaultCamera() und SetFrameSourceAsync-Aufrufe
6. Löschen Sie alle EnableSymbologies-Aufrufe
7. Ersetzen Sie barcodeCapture.IsEnabled = true durch BarcodeReader.Read(filePath)
8. Konvertieren Sie BarcodeScanned += Ereignishandler in foreach über BarcodeReader.Read()-Ergebnisse
9. Ersetzen Sie barcode.Data durch result.Value
10. Ersetzen Sie barcode.Symbology durch result.Format
11. Entfernen Sie die PDF-zu-Bild-Rendering-Pipelines, da IronBarcode PDFs jetzt direkt liest.
12. Fügen Sie IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY" beim Start der Anwendung hinzu

Post-Migrationstests

Bitte überprüfen Sie nach Abschluss der Codeaktualisierungen Folgendes:

• Prüfen Sie, ob die von IronBarcode zurückgegebenen Barcode-Werte mit den Werten übereinstimmen, die Scandit zuvor für dieselben Eingabedokumente zurückgegeben hat.
• Verifizieren Sie, dass alle unterstützten Barcode-Formate im Dokumentenset ohne ExpectBarcodeTypes-Konfiguration erkannt werden
• Testen Sie, ob PDF-Extraktion korrekte PageNumber-Werte für Dokumente mit mehreren Seiten zurückgibt
• Sicherstellen, dass die ASP.NET Core Endpunkte unter der erwarteten Last innerhalb akzeptabler Antwortzeiten Ergebnisse liefern.
• Überprüfen Sie, ob Docker- oder containerisierte Bereitstellungen Barcode-Lesevorgänge auch ohne Kamerahardware erfolgreich abschließen.
• Testen Sie, ob die gleichzeitige Batch-Verarbeitung mit Parallel.ForEach korrekte Ergebnisse ohne Rennbedingungen liefert
• Stellen Sie sicher, dass die Anwendung mit dem IronBarcode -Lizenzschlüssel anstelle des Scandit-Kontexts korrekt startet und initialisiert wird.