C# USB BarCodeスキャナ：IronBarcode完全統合ガイド

// Example: Handling different scanner input modes
public interface IScannerInput
{
    event EventHandler<string> BarcodeScanned;
    void StartListening();
    void StopListening();
}

// Keyboard wedge implementation
public class KeyboardWedgeScanner : IScannerInput
{
    public event EventHandler<string> BarcodeScanned;
    private readonly TextBox _inputBox;

    public KeyboardWedgeScanner(TextBox inputBox)
    {
        _inputBox = inputBox;
        _inputBox.KeyPress += OnKeyPress;
    }

    private void OnKeyPress(object sender, KeyPressEventArgs e)
    {
        if (e.KeyChar == (char)Keys.Enter)
        {
            BarcodeScanned?.Invoke(this, _inputBox.Text);
            _inputBox.Clear();
        }
    }

    public void StartListening() => _inputBox.Focus();
    public void StopListening() => _inputBox.Enabled = false;
}

// Serial port implementation for professional scanners
public class SerialPortScanner : IScannerInput
{
    public event EventHandler<string> BarcodeScanned;
    private System.IO.Ports.SerialPort _port;

    public SerialPortScanner(string portName, int baudRate = 9600)
    {
        _port = new System.IO.Ports.SerialPort(portName, baudRate);
        _port.DataReceived += OnDataReceived;
    }

    private void OnDataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
    {
        string data = _port.ReadLine().Trim();
        BarcodeScanned?.Invoke(this, data);
    }

    public void StartListening() => _port.Open();
    public void StopListening() => _port.Close();
}

Imports System
Imports System.Windows.Forms
Imports System.IO.Ports

' Example: Handling different scanner input modes
Public Interface IScannerInput
    Event BarcodeScanned As EventHandler(Of String)
    Sub StartListening()
    Sub StopListening()
End Interface

' Keyboard wedge implementation
Public Class KeyboardWedgeScanner
    Implements IScannerInput

    Public Event BarcodeScanned As EventHandler(Of String) Implements IScannerInput.BarcodeScanned
    Private ReadOnly _inputBox As TextBox

    Public Sub New(inputBox As TextBox)
        _inputBox = inputBox
        AddHandler _inputBox.KeyPress, AddressOf OnKeyPress
    End Sub

    Private Sub OnKeyPress(sender As Object, e As KeyPressEventArgs)
        If e.KeyChar = ChrW(Keys.Enter) Then
            RaiseEvent BarcodeScanned(Me, _inputBox.Text)
            _inputBox.Clear()
        End If
    End Sub

    Public Sub StartListening() Implements IScannerInput.StartListening
        _inputBox.Focus()
    End Sub

    Public Sub StopListening() Implements IScannerInput.StopListening
        _inputBox.Enabled = False
    End Sub
End Class

' Serial port implementation for professional scanners
Public Class SerialPortScanner
    Implements IScannerInput

    Public Event BarcodeScanned As EventHandler(Of String) Implements IScannerInput.BarcodeScanned
    Private _port As SerialPort

    Public Sub New(portName As String, Optional baudRate As Integer = 9600)
        _port = New SerialPort(portName, baudRate)
        AddHandler _port.DataReceived, AddressOf OnDataReceived
    End Sub

    Private Sub OnDataReceived(sender As Object, e As SerialDataReceivedEventArgs)
        Dim data As String = _port.ReadLine().Trim()
        RaiseEvent BarcodeScanned(Me, data)
    End Sub

    Public Sub StartListening() Implements IScannerInput.StartListening
        _port.Open()
    End Sub

    Public Sub StopListening() Implements IScannerInput.StopListening
        _port.Close()
    End Sub
End Class

// Capture scanner input and validate with IronBarcode
private async void ProcessScannerInput(string scannedData)
{
    try
    {
        // Validate the scanned data format
        var validationBarcode = BarcodeWriter.CreateBarcode(scannedData, BarcodeEncoding.Code128);
        var results = await BarcodeReader.ReadAsync(validationBarcode.ToBitmap());

        if (results.Any())
        {
            var result = results.First();

            // Extract metadata for enterprise systems
            var scanMetadata = new ScanMetadata
            {
                BarcodeType = result.BarcodeType,
                Value = result.Value,
                Confidence = result.Confidence,
                ScanTimestamp = DateTime.UtcNow,
                ScannerDevice = GetCurrentScannerInfo()
            };

            await ProcessValidBarcode(scanMetadata);
        }
        else
        {
            HandleInvalidScan(scannedData);
        }
    }
    catch (Exception ex)
    {
        LogScanError(ex, scannedData);
    }
}

Imports System
Imports System.Linq
Imports System.Threading.Tasks
Imports IronBarCode

Private Async Sub ProcessScannerInput(scannedData As String)
    Try
        ' Validate the scanned data format
        Dim validationBarcode = BarcodeWriter.CreateBarcode(scannedData, BarcodeEncoding.Code128)
        Dim results = Await BarcodeReader.ReadAsync(validationBarcode.ToBitmap())

        If results.Any() Then
            Dim result = results.First()

            ' Extract metadata for enterprise systems
            Dim scanMetadata As New ScanMetadata With {
                .BarcodeType = result.BarcodeType,
                .Value = result.Value,
                .Confidence = result.Confidence,
                .ScanTimestamp = DateTime.UtcNow,
                .ScannerDevice = GetCurrentScannerInfo()
            }

            Await ProcessValidBarcode(scanMetadata)
        Else
            HandleInvalidScan(scannedData)
        End If
    Catch ex As Exception
        LogScanError(ex, scannedData)
    End Try
End Sub

using IronBarCode;
using System.Drawing;
using System.Linq;
using System.Threading.Tasks;
using System.IO.Ports; // For serial scanners
using System.Diagnostics; // For performance monitoring

Imports IronBarCode
Imports System.Drawing
Imports System.Linq
Imports System.Threading.Tasks
Imports System.IO.Ports ' For serial scanners
Imports System.Diagnostics ' For performance monitoring

public class ScannerConfiguration
{
    public string ScannerType { get; set; } // "KeyboardWedge", "Serial", "USB-HID"
    public string PortName { get; set; } // For serial scanners
    public int BaudRate { get; set; } = 9600;
    public string Terminator { get; set; } = "\r\n";
    public bool EnableBeep { get; set; } = true;

    // Brand-specific settings
    public Dictionary<string, string> BrandSettings { get; set; } = new();

    // Common scanner brand configurations
    public static ScannerConfiguration GetHoneywellConfig()
    {
        return new ScannerConfiguration
        {
            ScannerType = "Serial",
            BaudRate = 115200,
            BrandSettings = new Dictionary<string, string>
            {
                {"Prefix", "STX"},
                {"Suffix", "ETX"},
                {"TriggerMode", "Manual"}
            }
        };
    }

    public static ScannerConfiguration GetSymbolConfig()
    {
        return new ScannerConfiguration
        {
            ScannerType = "KeyboardWedge",
            BrandSettings = new Dictionary<string, string>
            {
                {"ScanMode", "Continuous"},
                {"BeepVolume", "High"}
            }
        };
    }
}

Option Strict On



Public Class ScannerConfiguration
    Public Property ScannerType As String ' "KeyboardWedge", "Serial", "USB-HID"
    Public Property PortName As String ' For serial scanners
    Public Property BaudRate As Integer = 9600
    Public Property Terminator As String = vbCrLf
    Public Property EnableBeep As Boolean = True

    ' Brand-specific settings
    Public Property BrandSettings As Dictionary(Of String, String) = New Dictionary(Of String, String)()

    ' Common scanner brand configurations
    Public Shared Function GetHoneywellConfig() As ScannerConfiguration
        Return New ScannerConfiguration With {
            .ScannerType = "Serial",
            .BaudRate = 115200,
            .BrandSettings = New Dictionary(Of String, String) From {
                {"Prefix", "STX"},
                {"Suffix", "ETX"},
                {"TriggerMode", "Manual"}
            }
        }
    End Function

    Public Shared Function GetSymbolConfig() As ScannerConfiguration
        Return New ScannerConfiguration With {
            .ScannerType = "KeyboardWedge",
            .BrandSettings = New Dictionary(Of String, String) From {
                {"ScanMode", "Continuous"},
                {"BeepVolume", "High"}
            }
        }
    End Function
End Class

public class BarcodeValidator
{
    private readonly Dictionary<BarcodeType, Func<string, bool>> _validators;

    public BarcodeValidator()
    {
        _validators = new Dictionary<BarcodeType, Func<string, bool>>
        {
            { BarcodeType.Code128, ValidateCode128 },
            { BarcodeType.EAN13, ValidateEAN13 },
            { BarcodeType.UPCA, ValidateUPCA },
            { BarcodeType.QRCode, ValidateQRCode }
        };
    }

    public async Task<ValidationResult> ValidateScannedBarcodeAsync(string scannedText)
    {
        var result = new ValidationResult();

        try
        {
            // Attempt multiple barcode formats for flexibility
            var encodings = new[] { 
                BarcodeEncoding.Code128, 
                BarcodeEncoding.EAN13,
                BarcodeEncoding.UPCA,
                BarcodeEncoding.QRCode 
            };

            foreach (var encoding in encodings)
            {
                try
                {
                    var barcode = BarcodeWriter.CreateBarcode(scannedText, encoding);
                    var validationResults = await BarcodeReader.ReadAsync(barcode.ToBitmap());

                    if (validationResults.Any())
                    {
                        var validated = validationResults.First();
                        result.IsValid = true;
                        result.Format = validated.BarcodeType;
                        result.Value = validated.Value;
                        result.Confidence = validated.Confidence;

                        // Apply format-specific validation
                        if (_validators.ContainsKey(validated.BarcodeType))
                        {
                            result.PassesBusinessRules = _validators___PROTECTED_LINK_35___;
                        }

                        break;
                    }
                }
                catch { /* Try next format */ }
            }

            // Handle GS1-128 for supply chain applications
            if (!result.IsValid && IsGS1Format(scannedText))
            {
                result = await ValidateGS1BarcodeAsync(scannedText);
            }
        }
        catch (Exception ex)
        {
            result.Error = ex.Message;
        }

        return result;
    }

    private bool ValidateEAN13(string value)
    {
        // EAN-13 checksum validation
        if (value.Length != 13) return false;

        int sum = 0;
        for (int i = 0; i < 12; i++)
        {
            int digit = int.Parse(value[i].ToString());
            sum += (i % 2 == 0) ? digit : digit * 3;
        }

        int checkDigit = (10 - (sum % 10)) % 10;
        return checkDigit == int.Parse(value[12].ToString());
    }
}

Imports System
Imports System.Collections.Generic
Imports System.Linq
Imports System.Threading.Tasks

Public Class BarcodeValidator
    Private ReadOnly _validators As Dictionary(Of BarcodeType, Func(Of String, Boolean))

    Public Sub New()
        _validators = New Dictionary(Of BarcodeType, Func(Of String, Boolean)) From {
            {BarcodeType.Code128, AddressOf ValidateCode128},
            {BarcodeType.EAN13, AddressOf ValidateEAN13},
            {BarcodeType.UPCA, AddressOf ValidateUPCA},
            {BarcodeType.QRCode, AddressOf ValidateQRCode}
        }
    End Sub

    Public Async Function ValidateScannedBarcodeAsync(scannedText As String) As Task(Of ValidationResult)
        Dim result As New ValidationResult()

        Try
            ' Attempt multiple barcode formats for flexibility
            Dim encodings = {BarcodeEncoding.Code128, BarcodeEncoding.EAN13, BarcodeEncoding.UPCA, BarcodeEncoding.QRCode}

            For Each encoding In encodings
                Try
                    Dim barcode = BarcodeWriter.CreateBarcode(scannedText, encoding)
                    Dim validationResults = Await BarcodeReader.ReadAsync(barcode.ToBitmap())

                    If validationResults.Any() Then
                        Dim validated = validationResults.First()
                        result.IsValid = True
                        result.Format = validated.BarcodeType
                        result.Value = validated.Value
                        result.Confidence = validated.Confidence

                        ' Apply format-specific validation
                        If _validators.ContainsKey(validated.BarcodeType) Then
                            result.PassesBusinessRules = _validators(validated.BarcodeType).Invoke(validated.Value)
                        End If

                        Exit For
                    End If
                Catch
                    ' Try next format
                End Try
            Next

            ' Handle GS1-128 for supply chain applications
            If Not result.IsValid AndAlso IsGS1Format(scannedText) Then
                result = Await ValidateGS1BarcodeAsync(scannedText)
            End If
        Catch ex As Exception
            result.Error = ex.Message
        End Try

        Return result
    End Function

    Private Function ValidateEAN13(value As String) As Boolean
        ' EAN-13 checksum validation
        If value.Length <> 13 Then Return False

        Dim sum As Integer = 0
        For i As Integer = 0 To 11
            Dim digit As Integer = Integer.Parse(value(i).ToString())
            sum += If(i Mod 2 = 0, digit, digit * 3)
        Next

        Dim checkDigit As Integer = (10 - (sum Mod 10)) Mod 10
        Return checkDigit = Integer.Parse(value(12).ToString())
    End Function
End Class

public class InventoryBarcodeGenerator
{
    private readonly string _labelPath = "labels";

    public InventoryBarcodeGenerator()
    {
        // Ensure proper licensing for production use
        IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";
        System.IO.Directory.CreateDirectory(_labelPath);
    }

    public async Task<GeneratedBarcode> GenerateInventoryLabelAsync(string productCode, InventoryAction action)
    {
        try
        {
            // Generate structured inventory code
            var inventoryCode = GenerateStructuredCode(productCode, action);

            // Create high-quality barcode with production settings
            var barcode = BarcodeWriter.CreateBarcode(inventoryCode, BarcodeEncoding.Code128);

            // Apply enterprise styling
            barcode.ResizeTo(400, 120);
            barcode.SetMargins(10);
            barcode.AddAnnotationTextAboveBarcode(inventoryCode, IronSoftware.Drawing.Font.Arial, 12);
            barcode.ChangeBarCodeColor(IronSoftware.Drawing.Color.Black);

            // Add data matrix for redundancy in warehouse environments
            var dataMatrix = BarcodeWriter.CreateBarcode(inventoryCode, BarcodeEncoding.DataMatrix);
            dataMatrix.ResizeTo(100, 100);

            // Save with error handling
            var timestamp = DateTime.Now.ToString("yyyyMMddHHmmss");
            var fileName = $"{inventoryCode}_{timestamp}";

            // Save as multiple formats for flexibility
            await Task.Run(() =>
            {
                barcode.SaveAsPng($"{_labelPath}\\{fileName}.png");
                barcode.SaveAsPdf($"{_labelPath}\\{fileName}.pdf");
                barcode.SaveAsSvg($"{_labelPath}\\{fileName}.svg");
            });

            return new GeneratedBarcode
            {
                Code = inventoryCode,
                LinearBarcodePath = $"{_labelPath}\\{fileName}.png",
                DataMatrixPath = $"{_labelPath}\\{fileName}_dm.png",
                Timestamp = DateTime.UtcNow
            };
        }
        catch (Exception ex)
        {
            throw new BarcodeGenerationException($"Failed to generate barcode for {productCode}", ex);
        }
    }

    private string GenerateStructuredCode(string productCode, InventoryAction action)
    {
        // Implement GS1 Application Identifiers for enterprise compatibility
        var ai = action switch
        {
            InventoryAction.Receive => "10", // Batch/Lot number
            InventoryAction.Ship => "400", // Customer purchase order
            InventoryAction.Count => "37", // Quantity
            _ => "91" // Internal use
        };

        return $"({ai}){DateTime.Now:yyMMdd}{productCode}";
    }
}

Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports IronBarCode

Public Class InventoryBarcodeGenerator
    Private ReadOnly _labelPath As String = "labels"

    Public Sub New()
        ' Ensure proper licensing for production use
        IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY"
        Directory.CreateDirectory(_labelPath)
    End Sub

    Public Async Function GenerateInventoryLabelAsync(productCode As String, action As InventoryAction) As Task(Of GeneratedBarcode)
        Try
            ' Generate structured inventory code
            Dim inventoryCode = GenerateStructuredCode(productCode, action)

            ' Create high-quality barcode with production settings
            Dim barcode = BarcodeWriter.CreateBarcode(inventoryCode, BarcodeEncoding.Code128)

            ' Apply enterprise styling
            barcode.ResizeTo(400, 120)
            barcode.SetMargins(10)
            barcode.AddAnnotationTextAboveBarcode(inventoryCode, IronSoftware.Drawing.Font.Arial, 12)
            barcode.ChangeBarCodeColor(IronSoftware.Drawing.Color.Black)

            ' Add data matrix for redundancy in warehouse environments
            Dim dataMatrix = BarcodeWriter.CreateBarcode(inventoryCode, BarcodeEncoding.DataMatrix)
            dataMatrix.ResizeTo(100, 100)

            ' Save with error handling
            Dim timestamp = DateTime.Now.ToString("yyyyMMddHHmmss")
            Dim fileName = $"{inventoryCode}_{timestamp}"

            ' Save as multiple formats for flexibility
            Await Task.Run(Sub()
                               barcode.SaveAsPng($"{_labelPath}\{fileName}.png")
                               barcode.SaveAsPdf($"{_labelPath}\{fileName}.pdf")
                               barcode.SaveAsSvg($"{_labelPath}\{fileName}.svg")
                           End Sub)

            Return New GeneratedBarcode With {
                .Code = inventoryCode,
                .LinearBarcodePath = $"{_labelPath}\{fileName}.png",
                .DataMatrixPath = $"{_labelPath}\{fileName}_dm.png",
                .Timestamp = DateTime.UtcNow
            }
        Catch ex As Exception
            Throw New BarcodeGenerationException($"Failed to generate barcode for {productCode}", ex)
        End Try
    End Function

    Private Function GenerateStructuredCode(productCode As String, action As InventoryAction) As String
        ' Implement GS1 Application Identifiers for enterprise compatibility
        Dim ai As String = action Select Case action
            Case InventoryAction.Receive
                ai = "10" ' Batch/Lot number
            Case InventoryAction.Ship
                ai = "400" ' Customer purchase order
            Case InventoryAction.Count
                ai = "37" ' Quantity
            Case Else
                ai = "91" ' Internal use
        End Select

        Return $"({ai}){DateTime.Now:yyMMdd}{productCode}"
    End Function
End Class

using IronBarCode;
using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace EnterpriseBarcodeScanner
{
    public partial class HighVolumeScanner : Form
    {
        private readonly ConcurrentQueue<ScanData> _scanQueue = new();
        private readonly SemaphoreSlim _processingSemaphore;
        private readonly CancellationTokenSource _cancellationTokenSource = new();
        private IScannerInput _activeScanner;
        private int _maxConcurrentProcessing = Environment.ProcessorCount;

        public HighVolumeScanner()
        {
            InitializeComponent();
            _processingSemaphore = new SemaphoreSlim(_maxConcurrentProcessing);
            InitializeScanner();
            StartProcessingQueue();
        }

        private void InitializeScanner()
        {
            // Auto-detect scanner type
            if (SerialPort.GetPortNames().Any(p => p.Contains("COM")))
            {
                _activeScanner = new SerialPortScanner("COM3", 115200);
            }
            else
            {
                _activeScanner = new KeyboardWedgeScanner(txtScanner);
            }

            _activeScanner.BarcodeScanned += OnBarcodeScanned;
            _activeScanner.StartListening();
        }

        private void OnBarcodeScanned(object sender, string barcode)
        {
            // Queue for async processing to maintain scanner responsiveness
            _scanQueue.Enqueue(new ScanData 
            { 
                RawData = barcode, 
                ScanTime = DateTime.UtcNow 
            });
        }

        private async void StartProcessingQueue()
        {
            while (!_cancellationTokenSource.Token.IsCancellationRequested)
            {
                if (_scanQueue.TryDequeue(out var scanData))
                {
                    await _processingSemaphore.WaitAsync();

                    _ = Task.Run(async () =>
                    {
                        try
                        {
                            await ProcessScanAsync(scanData);
                        }
                        finally
                        {
                            _processingSemaphore.Release();
                        }
                    }, _cancellationTokenSource.Token);
                }
                else
                {
                    await Task.Delay(10); // Prevent CPU spinning
                }
            }
        }

        private async Task ProcessScanAsync(ScanData scanData)
        {
            try
            {
                // Validate with timeout for performance
                using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(2));
                var validationTask = ValidateAndProcessBarcodeAsync(scanData.RawData);
                var completedTask = await Task.WhenAny(validationTask, Task.Delay(Timeout.Infinite, cts.Token));

                if (completedTask == validationTask)
                {
                    var result = await validationTask;

                    if (result.Success)
                    {
                        // Update UI thread-safe
                        BeginInvoke(new Action(() =>
                        {
                            AddToInventory(result);
                            GenerateLabelsIfNeeded(result);
                        }));
                    }
                    else
                    {
                        LogScanError(scanData, result.Error);
                    }
                }
                else
                {
                    LogScanTimeout(scanData);
                }
            }
            catch (Exception ex)
            {
                LogCriticalError(ex, scanData);
            }
        }

        private async Task<ProcessingResult> ValidateAndProcessBarcodeAsync(string rawData)
        {
            // Implement smart caching for repeated scans
            if (BarcodeCache.TryGetCached(rawData, out var cachedResult))
            {
                return cachedResult;
            }

            // Use IronBarcode with optimized settings
            var barcodeOptions = new BarcodeReaderOptions
            {
                Speed = ReadingSpeed.Balanced,
                ExpectMultipleBarcodes = false,
                ExpectBarcodeTypes = BarcodeEncoding.Code128 | BarcodeEncoding.QRCode,
                MaxParallelThreads = 1 // Single barcode, no need for parallel
            };

            // Generate and validate
            var testBarcode = BarcodeWriter.CreateBarcode(rawData, BarcodeEncoding.Code128);
            var results = await BarcodeReader.ReadAsync(testBarcode.ToBitmap(), barcodeOptions);

            var result = new ProcessingResult
            {
                Success = results.Any(),
                BarcodeData = results.FirstOrDefault(),
                ProcessingTime = DateTime.UtcNow
            };

            BarcodeCache.Add(rawData, result);
            return result;
        }
    }
}

Imports IronBarCode
Imports System
Imports System.Collections.Concurrent
Imports System.Threading
Imports System.Threading.Tasks
Imports System.Windows.Forms

Namespace EnterpriseBarcodeScanner
    Partial Public Class HighVolumeScanner
        Inherits Form

        Private ReadOnly _scanQueue As New ConcurrentQueue(Of ScanData)()
        Private ReadOnly _processingSemaphore As SemaphoreSlim
        Private ReadOnly _cancellationTokenSource As New CancellationTokenSource()
        Private _activeScanner As IScannerInput
        Private _maxConcurrentProcessing As Integer = Environment.ProcessorCount

        Public Sub New()
            InitializeComponent()
            _processingSemaphore = New SemaphoreSlim(_maxConcurrentProcessing)
            InitializeScanner()
            StartProcessingQueue()
        End Sub

        Private Sub InitializeScanner()
            ' Auto-detect scanner type
            If SerialPort.GetPortNames().Any(Function(p) p.Contains("COM")) Then
                _activeScanner = New SerialPortScanner("COM3", 115200)
            Else
                _activeScanner = New KeyboardWedgeScanner(txtScanner)
            End If

            AddHandler _activeScanner.BarcodeScanned, AddressOf OnBarcodeScanned
            _activeScanner.StartListening()
        End Sub

        Private Sub OnBarcodeScanned(sender As Object, barcode As String)
            ' Queue for async processing to maintain scanner responsiveness
            _scanQueue.Enqueue(New ScanData With {
                .RawData = barcode,
                .ScanTime = DateTime.UtcNow
            })
        End Sub

        Private Async Sub StartProcessingQueue()
            While Not _cancellationTokenSource.Token.IsCancellationRequested
                Dim scanData As ScanData = Nothing
                If _scanQueue.TryDequeue(scanData) Then
                    Await _processingSemaphore.WaitAsync()

                    _ = Task.Run(Async Function()
                                     Try
                                         Await ProcessScanAsync(scanData)
                                     Finally
                                         _processingSemaphore.Release()
                                     End Try
                                 End Function, _cancellationTokenSource.Token)
                Else
                    Await Task.Delay(10) ' Prevent CPU spinning
                End If
            End While
        End Sub

        Private Async Function ProcessScanAsync(scanData As ScanData) As Task
            Try
                ' Validate with timeout for performance
                Using cts As New CancellationTokenSource(TimeSpan.FromSeconds(2))
                    Dim validationTask = ValidateAndProcessBarcodeAsync(scanData.RawData)
                    Dim completedTask = Await Task.WhenAny(validationTask, Task.Delay(Timeout.Infinite, cts.Token))

                    If completedTask Is validationTask Then
                        Dim result = Await validationTask

                        If result.Success Then
                            ' Update UI thread-safe
                            BeginInvoke(New Action(Sub()
                                                       AddToInventory(result)
                                                       GenerateLabelsIfNeeded(result)
                                                   End Sub))
                        Else
                            LogScanError(scanData, result.Error)
                        End If
                    Else
                        LogScanTimeout(scanData)
                    End If
                End Using
            Catch ex As Exception
                LogCriticalError(ex, scanData)
            End Try
        End Function

        Private Async Function ValidateAndProcessBarcodeAsync(rawData As String) As Task(Of ProcessingResult)
            ' Implement smart caching for repeated scans
            Dim cachedResult As ProcessingResult = Nothing
            If BarcodeCache.TryGetCached(rawData, cachedResult) Then
                Return cachedResult
            End If

            ' Use IronBarcode with optimized settings
            Dim barcodeOptions As New BarcodeReaderOptions With {
                .Speed = ReadingSpeed.Balanced,
                .ExpectMultipleBarcodes = False,
                .ExpectBarcodeTypes = BarcodeEncoding.Code128 Or BarcodeEncoding.QRCode,
                .MaxParallelThreads = 1 ' Single barcode, no need for parallel
            }

            ' Generate and validate
            Dim testBarcode = BarcodeWriter.CreateBarcode(rawData, BarcodeEncoding.Code128)
            Dim results = Await BarcodeReader.ReadAsync(testBarcode.ToBitmap(), barcodeOptions)

            Dim result As New ProcessingResult With {
                .Success = results.Any(),
                .BarcodeData = results.FirstOrDefault(),
                .ProcessingTime = DateTime.UtcNow
            }

            BarcodeCache.Add(rawData, result)
            Return result
        End Function
    End Class
End Namespace