ASP.NET 條碼掃描器教學：C# 條碼產生器指南

Install-Package BarCode

using IronBarCode;

Imports IronBarCode

// Server-side processing architecture
public class BarcodeService
{
    private readonly ILogger<BarcodeService> _logger;

    public async Task<BarcodeResult> ProcessUploadedImage(IFormFile file)
    {
        using var stream = file.OpenReadStream();
        var options = new BarcodeReaderOptions
        {
            Speed = ReadingSpeed.Balanced,
            ExpectMultipleBarcodes = true,
            // Enable ML confidence threshold
            UseConfidenceThreshold = true,
            ConfidenceThreshold = 0.85
        };

        var results = await Task.Run(() => 
            BarcodeReader.Read(stream, options));

        return new BarcodeResult
        {
            Barcodes = results.Select(r => new ScannedBarcode
            {
                Type = r.BarcodeType.ToString(),
                Value = r.Text,
                Confidence = r.Confidence
            }).ToList()
        };
    }
}

Imports System.Threading.Tasks

' Server-side processing architecture
Public Class BarcodeService
    Private ReadOnly _logger As ILogger(Of BarcodeService)

    Public Async Function ProcessUploadedImage(file As IFormFile) As Task(Of BarcodeResult)
        Using stream = file.OpenReadStream()
            Dim options As New BarcodeReaderOptions With {
                .Speed = ReadingSpeed.Balanced,
                .ExpectMultipleBarcodes = True,
                .UseConfidenceThreshold = True,
                .ConfidenceThreshold = 0.85
            }

            Dim results = Await Task.Run(Function() BarcodeReader.Read(stream, options))

            Return New BarcodeResult With {
                .Barcodes = results.Select(Function(r) New ScannedBarcode With {
                    .Type = r.BarcodeType.ToString(),
                    .Value = r.Text,
                    .Confidence = r.Confidence
                }).ToList()
            }
        End Using
    End Function
End Class

<form method="post" enctype="multipart/form-data" id="barcodeForm">
    <div class="form-group">
        <label for="barcodeFile">Select Barcode Image:</label>
        <input type="file" name="barcodeFile" id="barcodeFile" 
               accept="image/*,.pdf" class="form-control" 
               capture="environment" /> 
    </div>
    <button type="submit" class="btn btn-primary" id="scanBtn">
        <span class="spinner-border spinner-border-sm d-none" role="status"></span>
        Scan Barcode
    </button>
</form>
<div id="results">
    @ViewBag.BarcodeResult
</div>

<script>
// Progressive enhancement for modern browsers
if ('mediaDevices' in navigator) {
    document.getElementById('barcodeFile')
        .setAttribute('accept', 'image/*,.pdf,capture=camera');
}

// Show loading state
document.getElementById('barcodeForm').addEventListener('submit', function() {
    const spinner = document.querySelector('.spinner-border');
    spinner.classList.remove('d-none');
    document.getElementById('scanBtn').disabled = true;
});
</script>

The provided code is HTML and JavaScript, not C#. Therefore, it doesn't require conversion to VB.NET. If you have any C# code that needs conversion, please provide it, and I'll be happy to assist.

[HttpPost]
[ValidateAntiForgeryToken]
[RequestSizeLimit(10_000_000)] // 10MB limit
public async Task<IActionResult> ScanBarcode(IFormFile barcodeFile)
{
    // Security: Validate file type
    var allowedExtensions = new[] { ".jpg", ".jpeg", ".png", ".gif", 
                                    ".tiff", ".bmp", ".pdf" };
    var extension = Path.GetExtension(barcodeFile.FileName).ToLowerInvariant();

    if (!allowedExtensions.Contains(extension))
    {
        ModelState.AddModelError("", "Invalid file type");
        return View();
    }

    if (barcodeFile != null && barcodeFile.Length > 0)
    {
        using (var stream = new MemoryStream())
        {
            await barcodeFile.CopyToAsync(stream);
            stream.Position = 0;

            // Configure reader for improved web performance
            var options = new BarcodeReaderOptions
            {
                Speed = ReadingSpeed.Balanced,
                ExpectMultipleBarcodes = true,
                // Set specific barcode types for faster processing
                ExpectBarcodeTypes = BarcodeEncoding.AllOneDimensional | 
                                    BarcodeEncoding.QRCode | 
                                    BarcodeEncoding.DataMatrix,
                ImageFilters = new ImageFilterCollection
                {
                    new SharpenFilter(),
                    new ContrastFilter()
                }
            };

            // Read barcode from the uploaded image
            var results = BarcodeReader.Read(stream, options);

            if (results.Any())
            {
                ViewBag.BarcodeResult = string.Join("<br/>", 
                    results.Select(r => $"<strong>{r.BarcodeType}:</strong> {r.Text}"));
            }
            else
            {
                ViewBag.BarcodeResult = "No barcodes found in the image.";
            }
        }
    }
    return View();
}

Imports Microsoft.AspNetCore.Mvc
Imports System.IO
Imports System.Linq

<HttpPost>
<ValidateAntiForgeryToken>
<RequestSizeLimit(10_000_000)> ' 10MB limit
Public Async Function ScanBarcode(barcodeFile As IFormFile) As Task(Of IActionResult)
    ' Security: Validate file type
    Dim allowedExtensions = {".jpg", ".jpeg", ".png", ".gif", ".tiff", ".bmp", ".pdf"}
    Dim extension = Path.GetExtension(barcodeFile.FileName).ToLowerInvariant()

    If Not allowedExtensions.Contains(extension) Then
        ModelState.AddModelError("", "Invalid file type")
        Return View()
    End If

    If barcodeFile IsNot Nothing AndAlso barcodeFile.Length > 0 Then
        Using stream As New MemoryStream()
            Await barcodeFile.CopyToAsync(stream)
            stream.Position = 0

            ' Configure reader for improved web performance
            Dim options As New BarcodeReaderOptions With {
                .Speed = ReadingSpeed.Balanced,
                .ExpectMultipleBarcodes = True,
                ' Set specific barcode types for faster processing
                .ExpectBarcodeTypes = BarcodeEncoding.AllOneDimensional Or
                                      BarcodeEncoding.QRCode Or
                                      BarcodeEncoding.DataMatrix,
                .ImageFilters = New ImageFilterCollection From {
                    New SharpenFilter(),
                    New ContrastFilter()
                }
            }

            ' Read barcode from the uploaded image
            Dim results = BarcodeReader.Read(stream, options)

            If results.Any() Then
                ViewBag.BarcodeResult = String.Join("<br/>", results.Select(Function(r) $"<strong>{r.BarcodeType}:</strong> {r.Text}"))
            Else
                ViewBag.BarcodeResult = "No barcodes found in the image."
            End If
        End Using
    End If
    Return View()
End Function

[ApiController]
[Route("api/[controller]")]
public class BarcodeController : ControllerBase
{
    private readonly ILogger<BarcodeController> _logger;
    private readonly IMemoryCache _cache;

    public BarcodeController(ILogger<BarcodeController> logger, IMemoryCache cache)
    {
        _logger = logger;
        _cache = cache;
    }

    [HttpPost("scan")]
    [ProducesResponseType(typeof(BarcodeResponse), 200)]
    [ProducesResponseType(typeof(ErrorResponse), 400)]
    public async Task<IActionResult> ScanBarcode([FromBody] BarcodeRequest request)
    {
        try
        {
            // Input validation
            if (string.IsNullOrEmpty(request.ImageBase64))
                return BadRequest(new ErrorResponse { Error = "Image data is required" });

            // Check cache for duplicate requests
            var cacheKey = $"barcode_{request.ImageBase64.GetHashCode()}";
            if (_cache.TryGetValue(cacheKey, out BarcodeResponse cachedResult))
            {
                return Ok(cachedResult);
            }

            // Convert base64 string to byte array
            byte[] imageBytes = Convert.FromBase64String(request.ImageBase64);

            // Security: Validate image size
            if (imageBytes.Length > 10 * 1024 * 1024) // 10MB limit
                return BadRequest(new ErrorResponse { Error = "Image size exceeds 10MB limit" });

            // Configure reader for API usage
            var options = new BarcodeReaderOptions
            {
                Speed = ReadingSpeed.Faster, // Improve for API response time
                ExpectMultipleBarcodes = request.ExpectMultiple ?? false,
                UseConfidenceThreshold = true,
                ConfidenceThreshold = 0.8
            };

            // Read barcodes from the image
            var results = await Task.Run(() => BarcodeReader.Read(imageBytes, options));

            var response = new BarcodeResponse
            {
                Success = true,
                ProcessingTimeMs = 0, // Would be set by middleware
                Barcodes = results.Select(r => new BarcodeData
                {
                    Type = r.BarcodeType.ToString(),
                    Value = r.Text,
                    Confidence = r.Confidence,
                    Format = r.BarcodeType.ToString().ToLower(),
                    Position = new BarcodePosition 
                    { 
                        X = r.Points.Select(p => p.X).Min(), 
                        Y = r.Points.Select(p => p.Y).Min(), 
                        Width = r.Width, 
                        Height = r.Height 
                    }
                }).ToList()
            };

            // Cache successful results for 5 minutes
            _cache.Set(cacheKey, response, TimeSpan.FromMinutes(5));

            return Ok(response);
        }
        catch (FormatException)
        {
            return BadRequest(new ErrorResponse { Error = "Invalid base64 image data" });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error processing barcode scan");
            return StatusCode(500, new ErrorResponse { Error = "Internal server error" });
        }
    }

    [HttpPost("scan-stream")]
    public async Task<IActionResult> ScanBarcodeStream()
    {
        // Alternative endpoint for direct file uploads
        var file = Request.Form.Files.FirstOrDefault();
        if (file == null)
            return BadRequest(new ErrorResponse { Error = "No file uploaded" });

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

        return Ok(new BarcodeResponse
        {
            Success = true,
            Barcodes = results.Select(r => new BarcodeData
            {
                Type = r.BarcodeType.ToString(),
                Value = r.Text
            }).ToList()
        });
    }
}

public class BarcodeRequest
{
    public string ImageBase64 { get; set; }
    public bool? ExpectMultiple { get; set; }
}

public class BarcodeResponse
{
    public bool Success { get; set; }
    public List<BarcodeData> Barcodes { get; set; }
    public int ProcessingTimeMs { get; set; }
}

public class BarcodeData
{
    public string Type { get; set; }
    public string Value { get; set; }
    public double Confidence { get; set; }
    public string Format { get; set; }
    public BarcodePosition Position { get; set; }
}

public class BarcodePosition
{
    public int X { get; set; }
    public int Y { get; set; }
    public int Width { get; set; }
    public int Height { get; set; }
}

public class ErrorResponse
{
    public bool Success => false;
    public string Error { get; set; }
}

Imports System
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.Extensions.Logging
Imports Microsoft.Extensions.Caching.Memory
Imports System.Threading.Tasks
Imports System.Linq

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

    Private ReadOnly _logger As ILogger(Of BarcodeController)
    Private ReadOnly _cache As IMemoryCache

    Public Sub New(logger As ILogger(Of BarcodeController), cache As IMemoryCache)
        _logger = logger
        _cache = cache
    End Sub

    <HttpPost("scan")>
    <ProducesResponseType(GetType(BarcodeResponse), 200)>
    <ProducesResponseType(GetType(ErrorResponse), 400)>
    Public Async Function ScanBarcode(<FromBody> request As BarcodeRequest) As Task(Of IActionResult)
        Try
            ' Input validation
            If String.IsNullOrEmpty(request.ImageBase64) Then
                Return BadRequest(New ErrorResponse With {.Error = "Image data is required"})
            End If

            ' Check cache for duplicate requests
            Dim cacheKey = $"barcode_{request.ImageBase64.GetHashCode()}"
            Dim cachedResult As BarcodeResponse = Nothing
            If _cache.TryGetValue(cacheKey, cachedResult) Then
                Return Ok(cachedResult)
            End If

            ' Convert base64 string to byte array
            Dim imageBytes As Byte() = Convert.FromBase64String(request.ImageBase64)

            ' Security: Validate image size
            If imageBytes.Length > 10 * 1024 * 1024 Then ' 10MB limit
                Return BadRequest(New ErrorResponse With {.Error = "Image size exceeds 10MB limit"})
            End If

            ' Configure reader for API usage
            Dim options As New BarcodeReaderOptions With {
                .Speed = ReadingSpeed.Faster, ' Improve for API response time
                .ExpectMultipleBarcodes = request.ExpectMultiple.GetValueOrDefault(False),
                .UseConfidenceThreshold = True,
                .ConfidenceThreshold = 0.8
            }

            ' Read barcodes from the image
            Dim results = Await Task.Run(Function() BarcodeReader.Read(imageBytes, options))

            Dim response As New BarcodeResponse With {
                .Success = True,
                .ProcessingTimeMs = 0, ' Would be set by middleware
                .Barcodes = results.Select(Function(r) New BarcodeData With {
                    .Type = r.BarcodeType.ToString(),
                    .Value = r.Text,
                    .Confidence = r.Confidence,
                    .Format = r.BarcodeType.ToString().ToLower(),
                    .Position = New BarcodePosition With {
                        .X = r.Points.Select(Function(p) p.X).Min(),
                        .Y = r.Points.Select(Function(p) p.Y).Min(),
                        .Width = r.Width,
                        .Height = r.Height
                    }
                }).ToList()
            }

            ' Cache successful results for 5 minutes
            _cache.Set(cacheKey, response, TimeSpan.FromMinutes(5))

            Return Ok(response)
        Catch ex As FormatException
            Return BadRequest(New ErrorResponse With {.Error = "Invalid base64 image data"})
        Catch ex As Exception
            _logger.LogError(ex, "Error processing barcode scan")
            Return StatusCode(500, New ErrorResponse With {.Error = "Internal server error"})
        End Try
    End Function

    <HttpPost("scan-stream")>
    Public Async Function ScanBarcodeStream() As Task(Of IActionResult)
        ' Alternative endpoint for direct file uploads
        Dim file = Request.Form.Files.FirstOrDefault()
        If file Is Nothing Then
            Return BadRequest(New ErrorResponse With {.Error = "No file uploaded"})
        End If

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

            Return Ok(New BarcodeResponse With {
                .Success = True,
                .Barcodes = results.Select(Function(r) New BarcodeData With {
                    .Type = r.BarcodeType.ToString(),
                    .Value = r.Text
                }).ToList()
            })
        End Using
    End Function
End Class

Public Class BarcodeRequest
    Public Property ImageBase64 As String
    Public Property ExpectMultiple As Boolean?
End Class

Public Class BarcodeResponse
    Public Property Success As Boolean
    Public Property Barcodes As List(Of BarcodeData)
    Public Property ProcessingTimeMs As Integer
End Class

Public Class BarcodeData
    Public Property Type As String
    Public Property Value As String
    Public Property Confidence As Double
    Public Property Format As String
    Public Property Position As BarcodePosition
End Class

Public Class BarcodePosition
    Public Property X As Integer
    Public Property Y As Integer
    Public Property Width As Integer
    Public Property Height As Integer
End Class

Public Class ErrorResponse
    Public ReadOnly Property Success As Boolean
        Get
            Return False
        End Get
    End Property
    Public Property Error As String
End Class

// Modern JavaScript client with camera support
class BarcodeScanner {
    constructor(apiEndpoint = '/api/barcode/scan') {
        this.apiEndpoint = apiEndpoint;
        this.videoElement = null;
        this.canvasElement = null;
    }

    // Initialize camera for live capture
    async initializeCamera(videoElementId) {
        this.videoElement = document.getElementById(videoElementId);

        try {
            const stream = await navigator.mediaDevices.getUserMedia({
                video: { 
                    facingMode: 'environment', // Use rear camera on mobile
                    width: { ideal: 1280 },
                    height: { ideal: 720 }
                }
            });
            this.videoElement.srcObject = stream;

            // Create canvas for capturing frames
            this.canvasElement = document.createElement('canvas');
            this.canvasElement.width = 1280;
            this.canvasElement.height = 720;

            return true;
        } catch (error) {
            console.error('Camera initialization failed:', error);
            return false;
        }
    }

    // Capture frame and scan
    async captureAndScan() {
        if (!this.videoElement || !this.canvasElement) {
            throw new Error('Camera not initialized');
        }

        const context = this.canvasElement.getContext('2d');
        context.drawImage(this.videoElement, 0, 0, 
                         this.canvasElement.width, 
                         this.canvasElement.height);

        // Convert to base64
        const imageData = this.canvasElement.toDataURL('image/jpeg', 0.8);
        const base64 = imageData.split(',')[1];

        // Send to API
        const response = await fetch(this.apiEndpoint, {
            method: 'POST',
            headers: { 
                'Content-Type': 'application/json',
                'X-Requested-With': 'XMLHttpRequest' // CSRF protection
            },
            body: JSON.stringify({ 
                imageBase64: base64,
                expectMultiple: true 
            })
        });

        if (!response.ok) {
            throw new Error(`API error: ${response.statusText}`);
        }

        return await response.json();
    }

    // Scan from file upload with progress
    async scanFile(file, progressCallback) {
        const base64 = await this.fileToBase64(file);

        const xhr = new XMLHttpRequest();

        return new Promise((resolve, reject) => {
            xhr.upload.addEventListener('progress', (e) => {
                if (progressCallback && e.lengthComputable) {
                    progressCallback(Math.round((e.loaded / e.total) * 100));
                }
            });

            xhr.addEventListener('load', () => {
                if (xhr.status === 200) {
                    resolve(JSON.parse(xhr.responseText));
                } else {
                    reject(new Error(`Server error: ${xhr.status}`));
                }
            });

            xhr.addEventListener('error', () => reject(new Error('Network error')));

            xhr.open('POST', this.apiEndpoint);
            xhr.setRequestHeader('Content-Type', 'application/json');
            xhr.send(JSON.stringify({ imageBase64: base64 }));
        });
    }

    fileToBase64(file) {
        return new Promise((resolve, reject) => {
            const reader = new FileReader();
            reader.onload = () => resolve(reader.result.split(',')[1]);
            reader.onerror = reject;
            reader.readAsDataURL(file);
        });
    }
}

// Usage example
const scanner = new BarcodeScanner();

// Initialize camera scanning
document.getElementById('startCamera').addEventListener('click', async () => {
    const initialized = await scanner.initializeCamera('videoPreview');
    if (initialized) {
        // Start continuous scanning
        setInterval(async () => {
            try {
                const result = await scanner.captureAndScan();
                if (result.barcodes.length > 0) {
                    console.log('Barcodes detected:', result.barcodes);
                    // Process results
                }
            } catch (error) {
                console.error('Scan error:', error);
            }
        }, 1000); // Scan every second
    }
});

' Modern JavaScript client with camera support
Public Class BarcodeScanner
    Private apiEndpoint As String
    Private videoElement As Object
    Private canvasElement As Object

    Public Sub New(Optional apiEndpoint As String = "/api/barcode/scan")
        Me.apiEndpoint = apiEndpoint
        Me.videoElement = Nothing
        Me.canvasElement = Nothing
    End Sub

    ' Initialize camera for live capture
    Public Async Function InitializeCamera(videoElementId As String) As Task(Of Boolean)
        Me.videoElement = document.getElementById(videoElementId)

        Try
            Dim stream = Await navigator.mediaDevices.getUserMedia(New With {
                .video = New With {
                    .facingMode = "environment", ' Use rear camera on mobile
                    .width = New With {.ideal = 1280},
                    .height = New With {.ideal = 720}
                }
            })
            Me.videoElement.srcObject = stream

            ' Create canvas for capturing frames
            Me.canvasElement = document.createElement("canvas")
            Me.canvasElement.width = 1280
            Me.canvasElement.height = 720

            Return True
        Catch ex As Exception
            console.error("Camera initialization failed:", ex)
            Return False
        End Try
    End Function

    ' Capture frame and scan
    Public Async Function CaptureAndScan() As Task(Of Object)
        If Me.videoElement Is Nothing OrElse Me.canvasElement Is Nothing Then
            Throw New Exception("Camera not initialized")
        End If

        Dim context = Me.canvasElement.getContext("2d")
        context.drawImage(Me.videoElement, 0, 0, Me.canvasElement.width, Me.canvasElement.height)

        ' Convert to base64
        Dim imageData = Me.canvasElement.toDataURL("image/jpeg", 0.8)
        Dim base64 = imageData.Split(","c)(1)

        ' Send to API
        Dim response = Await fetch(Me.apiEndpoint, New With {
            .method = "POST",
            .headers = New With {
                .ContentType = "application/json",
                .XRequestedWith = "XMLHttpRequest" ' CSRF protection
            },
            .body = JSON.stringify(New With {
                .imageBase64 = base64,
                .expectMultiple = True
            })
        })

        If Not response.ok Then
            Throw New Exception($"API error: {response.statusText}")
        End If

        Return Await response.json()
    End Function

    ' Scan from file upload with progress
    Public Async Function ScanFile(file As Object, progressCallback As Action(Of Integer)) As Task(Of Object)
        Dim base64 = Await Me.FileToBase64(file)

        Dim xhr = New XMLHttpRequest()

        Return Await Task.Run(Function()
                                  Dim tcs = New TaskCompletionSource(Of Object)()

                                  AddHandler xhr.upload.progress, Sub(e)
                                                                      If progressCallback IsNot Nothing AndAlso e.lengthComputable Then
                                                                          progressCallback(Math.Round((e.loaded / e.total) * 100))
                                                                      End If
                                                                  End Sub

                                  AddHandler xhr.load, Sub()
                                                           If xhr.status = 200 Then
                                                               tcs.SetResult(JSON.parse(xhr.responseText))
                                                           Else
                                                               tcs.SetException(New Exception($"Server error: {xhr.status}"))
                                                           End If
                                                       End Sub

                                  AddHandler xhr.error, Sub() tcs.SetException(New Exception("Network error"))

                                  xhr.open("POST", Me.apiEndpoint)
                                  xhr.setRequestHeader("Content-Type", "application/json")
                                  xhr.send(JSON.stringify(New With {.imageBase64 = base64}))

                                  Return tcs.Task
                              End Function)
    End Function

    Private Function FileToBase64(file As Object) As Task(Of String)
        Return Task.Run(Function()
                            Dim tcs = New TaskCompletionSource(Of String)()
                            Dim reader = New FileReader()

                            AddHandler reader.onload, Sub() tcs.SetResult(reader.result.Split(","c)(1))
                            AddHandler reader.onerror, Sub() tcs.SetException(New Exception("File read error"))

                            reader.readAsDataURL(file)

                            Return tcs.Task
                        End Function)
    End Function
End Class

' Usage example
Dim scanner = New BarcodeScanner()

' Initialize camera scanning
document.getElementById("startCamera").addEventListener("click", Async Sub()
    Dim initialized = Await scanner.InitializeCamera("videoPreview")
    If initialized Then
        ' Start continuous scanning
        setInterval(Async Sub()
                        Try
                            Dim result = Await scanner.CaptureAndScan()
                            If result.barcodes.length > 0 Then
                                console.log("Barcodes detected:", result.barcodes)
                                ' Process results
                            End If
                        Catch ex As Exception
                            console.error("Scan error:", ex)
                        End Try
                    End Sub, 1000) ' Scan every second
    End If
End Sub)

public class AdvancedBarcodeProcessor
{
    private readonly ILogger<AdvancedBarcodeProcessor> _logger;

    public async Task<List<BarcodeResult>> ProcessChallengingImage(
        Stream imageStream, 
        BarcodeProcessingProfile profile = BarcodeProcessingProfile.Balanced)
    {
        var options = GetOptionsForProfile(profile);

        // First pass: Try with standard settings
        var results = BarcodeReader.Read(imageStream, options);

        if (!results.Any() && profile == BarcodeProcessingProfile.Aggressive)
        {
            // Second pass: Apply aggressive image corrections
            imageStream.Position = 0;
            options.ImageFilters = new ImageFilterCollection
            {
                new SharpenFilter(2.5f),
                new ContrastFilter(2.0f),
                new BrightnessFilter(1.2f),
                new InvertFilter() // Try inverted colors
            };
            options.AutoRotate = true;
            options.Speed = ReadingSpeed.ExtremeDetail;

            results = BarcodeReader.Read(imageStream, options);
        }

        return results.Select(r => new BarcodeResult
        {
            Value = r.Text,
            Type = r.BarcodeType,
            Confidence = r.Confidence,
            Metadata = ExtractMetadata(r)
        }).ToList();
    }

    private BarcodeReaderOptions GetOptionsForProfile(BarcodeProcessingProfile profile)
    {
        return profile switch
        {
            BarcodeProcessingProfile.Fast => new BarcodeReaderOptions
            {
                Speed = ReadingSpeed.Faster,
                ExpectMultipleBarcodes = false,
                UseConfidenceThreshold = false,
                Multithreaded = false
            },
            BarcodeProcessingProfile.Balanced => new BarcodeReaderOptions
            {
                Speed = ReadingSpeed.Balanced,
                ExpectBarcodeTypes = BarcodeEncoding.QRCode | 
                                    BarcodeEncoding.Code128 | 
                                    BarcodeEncoding.Code39,
                AutoRotate = true,
                ImageFilters = new ImageFilterCollection
                {
                    new SharpenFilter(),
                    new ContrastFilter(1.5f)
                },
                Multithreaded = true,
                UseConfidenceThreshold = true,
                ConfidenceThreshold = 0.75
            },
            BarcodeProcessingProfile.Aggressive => new BarcodeReaderOptions
            {
                Speed = ReadingSpeed.Detailed,
                ExpectMultipleBarcodes = true,
                AutoRotate = true,
                RemoveFalsePositive = true,
                UseConfidenceThreshold = true,
                ConfidenceThreshold = 0.6,
                Multithreaded = true,
                // Try multiple barcode types
                ExpectBarcodeTypes = BarcodeEncoding.All
            },
            _ => throw new ArgumentException($"Unknown profile: {profile}")
        };
    }

    private Dictionary<string, object> ExtractMetadata(BarcodeResult result)
    {
        return new Dictionary<string, object>
        {
            ["Width"] = result.Width,
            ["Height"] = result.Height,
            ["RotationAngle"] = result.RotationAngle,
            ["PageNumber"] = result.PageNumber,
            ["Confidence"] = result.Confidence
        };
    }
}

public enum BarcodeProcessingProfile
{
    Fast,      // For real-time scanning
    Balanced,  // Default for most scenarios  
    Aggressive // For challenging images
}

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

Public Class AdvancedBarcodeProcessor
    Private ReadOnly _logger As ILogger(Of AdvancedBarcodeProcessor)

    Public Async Function ProcessChallengingImage(imageStream As Stream, Optional profile As BarcodeProcessingProfile = BarcodeProcessingProfile.Balanced) As Task(Of List(Of BarcodeResult))
        Dim options = GetOptionsForProfile(profile)

        ' First pass: Try with standard settings
        Dim results = BarcodeReader.Read(imageStream, options)

        If Not results.Any() AndAlso profile = BarcodeProcessingProfile.Aggressive Then
            ' Second pass: Apply aggressive image corrections
            imageStream.Position = 0
            options.ImageFilters = New ImageFilterCollection From {
                New SharpenFilter(2.5F),
                New ContrastFilter(2.0F),
                New BrightnessFilter(1.2F),
                New InvertFilter() ' Try inverted colors
            }
            options.AutoRotate = True
            options.Speed = ReadingSpeed.ExtremeDetail

            results = BarcodeReader.Read(imageStream, options)
        End If

        Return results.Select(Function(r) New BarcodeResult With {
            .Value = r.Text,
            .Type = r.BarcodeType,
            .Confidence = r.Confidence,
            .Metadata = ExtractMetadata(r)
        }).ToList()
    End Function

    Private Function GetOptionsForProfile(profile As BarcodeProcessingProfile) As BarcodeReaderOptions
        Select Case profile
            Case BarcodeProcessingProfile.Fast
                Return New BarcodeReaderOptions With {
                    .Speed = ReadingSpeed.Faster,
                    .ExpectMultipleBarcodes = False,
                    .UseConfidenceThreshold = False,
                    .Multithreaded = False
                }
            Case BarcodeProcessingProfile.Balanced
                Return New BarcodeReaderOptions With {
                    .Speed = ReadingSpeed.Balanced,
                    .ExpectBarcodeTypes = BarcodeEncoding.QRCode Or BarcodeEncoding.Code128 Or BarcodeEncoding.Code39,
                    .AutoRotate = True,
                    .ImageFilters = New ImageFilterCollection From {
                        New SharpenFilter(),
                        New ContrastFilter(1.5F)
                    },
                    .Multithreaded = True,
                    .UseConfidenceThreshold = True,
                    .ConfidenceThreshold = 0.75
                }
            Case BarcodeProcessingProfile.Aggressive
                Return New BarcodeReaderOptions With {
                    .Speed = ReadingSpeed.Detailed,
                    .ExpectMultipleBarcodes = True,
                    .AutoRotate = True,
                    .RemoveFalsePositive = True,
                    .UseConfidenceThreshold = True,
                    .ConfidenceThreshold = 0.6,
                    .Multithreaded = True,
                    .ExpectBarcodeTypes = BarcodeEncoding.All
                }
            Case Else
                Throw New ArgumentException($"Unknown profile: {profile}")
        End Select
    End Function

    Private Function ExtractMetadata(result As BarcodeResult) As Dictionary(Of String, Object)
        Return New Dictionary(Of String, Object) From {
            {"Width", result.Width},
            {"Height", result.Height},
            {"RotationAngle", result.RotationAngle},
            {"PageNumber", result.PageNumber},
            {"Confidence", result.Confidence}
        }
    End Function
End Class

Public Enum BarcodeProcessingProfile
    Fast      ' For real-time scanning
    Balanced  ' Default for most scenarios  
    Aggressive ' For challenging images
End Enum

@* Razor view with progressive enhancement *@
<div class="barcode-scanner-container">
    @* Modern camera capture for supported browsers *@
    <div id="cameraSection" class="d-none">
        <video id="videoPreview" class="w-100" autoplay></video>
        <button id="captureBtn" class="btn btn-primary mt-2">
            Capture & Scan
        </button>
    </div>

    @* Fallback file upload for all browsers *@
    <div id="uploadSection">
        <form method="post" enctype="multipart/form-data" 
              asp-action="ScanBarcode" asp-controller="Barcode">
            <div class="form-group">
                <label>Upload Barcode Image:</label>
                <input type="file" name="file" accept="image/*,.pdf" 
                       class="form-control" required />
            </div>
            <button type="submit" class="btn btn-primary">
                Upload & Scan
            </button>
        </form>
    </div>
</div>

<script>
// Feature detection and progressive enhancement
(function() {
    const hasMediaDevices = 'mediaDevices' in navigator;
    const hasGetUserMedia = hasMediaDevices && 
                           'getUserMedia' in navigator.mediaDevices;

    if (hasGetUserMedia) {
        // Show camera section for modern browsers
        document.getElementById('cameraSection').classList.remove('d-none');

        // Optional: Hide upload section or make it secondary
        const uploadSection = document.getElementById('uploadSection');
        uploadSection.innerHTML = '<p class="text-muted">Or upload a file:</p>' + 
                                 uploadSection.innerHTML;
    }

    // Browser-specific optimizations
    const isIOS = /iPad|iPhone|iPod/.test(navigator.userAgent);
    const isAndroid = /Android/.test(navigator.userAgent);

    if (isIOS) {
        // iOS-specific handling
        document.querySelector('input[type="file"]')
                .setAttribute('accept', 'image/*');
    }
})();
</script>

@* Razor view with progressive enhancement *@
<div class="barcode-scanner-container">
    @* Modern camera capture for supported browsers *@
    <div id="cameraSection" class="d-none">
        <video id="videoPreview" class="w-100" autoplay></video>
        <button id="captureBtn" class="btn btn-primary mt-2">
            Capture & Scan
        </button>
    </div>

    @* Fallback file upload for all browsers *@
    <div id="uploadSection">
        <form method="post" enctype="multipart/form-data" 
              asp-action="ScanBarcode" asp-controller="Barcode">
            <div class="form-group">
                <label>Upload Barcode Image:</label>
                <input type="file" name="file" accept="image/*,.pdf" 
                       class="form-control" required />
            </div>
            <button type="submit" class="btn btn-primary">
                Upload & Scan
            </button>
        </form>
    </div>
</div>

<script>
' Feature detection and progressive enhancement
(function()
    Dim hasMediaDevices As Boolean = "mediaDevices" In navigator
    Dim hasGetUserMedia As Boolean = hasMediaDevices AndAlso 
                                     "getUserMedia" In navigator.mediaDevices

    If hasGetUserMedia Then
        ' Show camera section for modern browsers
        document.getElementById("cameraSection").classList.remove("d-none")

        ' Optional: Hide upload section or make it secondary
        Dim uploadSection = document.getElementById("uploadSection")
        uploadSection.innerHTML = "<p class='text-muted'>Or upload a file:</p>" & 
                                  uploadSection.innerHTML
    End If

    ' Browser-specific optimizations
    Dim isIOS As Boolean = /iPad|iPhone|iPod/.test(navigator.userAgent)
    Dim isAndroid As Boolean = /Android/.test(navigator.userAgent)

    If isIOS Then
        ' iOS-specific handling
        document.querySelector("input[type='file']")
                .setAttribute("accept", "image/*")
    End If
End Function)()
</script>