Escáner de código de barras ASP.NET : Carga de archivos y API REST con IronBarcode

Instalación mediante el gestor de paquetes NuGet

Abra la consola del gestor de paquetes en Visual Studio y ejecute:

Install-Package BarCode

Install-Package BarCode

Alternativamente, utilice la CLI de .NET :

dotnet add package BarCode

dotnet add package BarCode

O busque "BarCode" en la interfaz de usuario del Administrador de paquetes NuGet de Visual Studio y haga clic en Instalar. El paquete gestiona automáticamente todas las dependencias.

Para implementaciones específicas de la plataforma, considere usar paquetes NuGet específicos de la plataforma que estén optimizados para su entorno de destino. La biblioteca ofrece paquetes estándar y BarCode.Slim para adaptarse a diferentes escenarios de implementación. Para obtener la guía de instalación completa, consulte la guía de instalación de IronBarcode .

Configurando su proyecto

Una vez instalado, agregue la declaración using necesaria a sus archivos C#:

using IronBarCode;

using IronBarCode;

Esta importación le brinda acceso a las capacidades completas de lectura y generación de códigos de barras de IronBarcode. La biblioteca admite más de 30 formatos de códigos de barras, incluyendo QR Code, Code 128, Code 39, Data Matrix y PDF417. Consulte la lista completa de formatos de códigos de barras compatibles para confirmar la compatibilidad con su caso de uso.

Para solucionar problemas de instalación, consulte la guía de solución de problemas de paquetes NuGet o envíe una solicitud de ingeniería para obtener soporte especializado.

Cómo elegir el patrón de arquitectura adecuado

Al implementar el escaneo de códigos de barras en ASP.NET, existen dos enfoques arquitectónicos principales. Comprender estos patrones le ayudará a elegir la configuración adecuada del lector de código de barras para cada caso de uso:

// Server-side processing -- recommended for most ASP.NET scenarios
var options = new BarcodeReaderOptions
{
    Speed = ReadingSpeed.Balanced,
    ExpectMultipleBarcodes = true,
    UseConfidenceThreshold = true,
    ConfidenceThreshold = 0.85
};

var results = BarcodeReader.Read(stream, options);

foreach (var barcode in results)
{
    Console.WriteLine($"Type: {barcode.BarcodeType}, Value: {barcode.Text}");
}

// Server-side processing -- recommended for most ASP.NET scenarios
var options = new BarcodeReaderOptions
{
    Speed = ReadingSpeed.Balanced,
    ExpectMultipleBarcodes = true,
    UseConfidenceThreshold = true,
    ConfidenceThreshold = 0.85
};

var results = BarcodeReader.Read(stream, options);

foreach (var barcode in results)
{
    Console.WriteLine($"Type: {barcode.BarcodeType}, Value: {barcode.Text}");
}

El enfoque del lado del servidor le brinda el máximo control sobre el procesamiento de imágenes y funciona de manera consistente en todos los navegadores. Cuando el servidor procesa cada imagen, también obtiene un registro de auditoría limpio: cada código de barras escaneado pasa a través de su capa de aplicación, donde puede registrarlo, validarlo contra una base de datos o activar flujos de trabajo posteriores. Este patrón es particularmente adecuado para industrias reguladas como la atención médica, la logística y la fabricación, donde cada escaneo debe registrarse.

Para la integración de captura de cámara del lado del cliente, los navegadores modernos admiten la API MediaDevices para el acceso a la cámara, que puede combinarse con el procesamiento del lado del servidor de IronBarcode mediante una API REST (que se detalla más adelante en esta guía). Elegir el procesamiento del lado del servidor también simplifica el modelo de seguridad: no se expone lógica de procesamiento sensible al navegador y toda la validación se realiza fuera de los límites de la aplicación.

Creación del formulario de carga

Cree un formulario HTML adaptable en su vista ASP.NET :

@* Razor view -- barcode upload form *@
<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>

@* Razor view -- barcode upload form *@
<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>

El atributo capture="environment" activa la cámara trasera en dispositivos móviles, brindando a los usuarios una experiencia similar a una cámara nativa sin JavaScript.

Implementación de procesamiento backend seguro

La acción del controlador maneja la validación de archivos, el procesamiento del flujo de memoria y el formato de resultados:

[HttpPost]
[ValidateAntiForgeryToken]
[RequestSizeLimit(10_000_000)] // 10MB limit
public async Task<IActionResult> ScanBarcode(IFormFile barcodeFile)
{
    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;

        var options = new BarcodeReaderOptions
        {
            Speed = ReadingSpeed.Balanced,
            ExpectMultipleBarcodes = true,
            ExpectBarcodeTypes = BarcodeEncoding.AllOneDimensional |
                                BarcodeEncoding.QRCode |
                                BarcodeEncoding.DataMatrix,
            ImageFilters = new ImageFilterCollection
            {
                new SharpenFilter(),
                new ContrastFilter()
            }
        };

        var results = BarcodeReader.Read(stream, options);

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

    return View();
}

[HttpPost]
[ValidateAntiForgeryToken]
[RequestSizeLimit(10_000_000)] // 10MB limit
public async Task<IActionResult> ScanBarcode(IFormFile barcodeFile)
{
    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;

        var options = new BarcodeReaderOptions
        {
            Speed = ReadingSpeed.Balanced,
            ExpectMultipleBarcodes = true,
            ExpectBarcodeTypes = BarcodeEncoding.AllOneDimensional |
                                BarcodeEncoding.QRCode |
                                BarcodeEncoding.DataMatrix,
            ImageFilters = new ImageFilterCollection
            {
                new SharpenFilter(),
                new ContrastFilter()
            }
        };

        var results = BarcodeReader.Read(stream, options);

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

    return View();
}

Esta implementación valida el tipo de archivo antes de procesarlo, lee códigos de barras de un flujo de memoria y devuelve todos los resultados detectados. IronBarcode procesa varios formatos de imagen , incluidos documentos TIFF, GIF y PDF de varias páginas, eliminando el código de manejo específico del formato.

Cómo se ven la entrada y la salida escaneadas

El ejemplo anterior muestra un código de barras Código 128 estándar, un formato común en aplicaciones de envío e inventario. Después del escaneo, la pantalla de resultados confirma el valor decodificado junto con los metadatos de confianza:

IronBarcode devuelve el tipo de código de barras, el valor decodificado, la puntuación de confianza y los datos de posición de cada código de barras detectado en la imagen cargada.

Consideraciones de seguridad para las API de códigos de barras

Antes de escribir el controlador, planifique la capa de seguridad. Los datos del código de barras pueden contener contenido arbitrario, por lo que siempre debe validar las entradas. Siga las pautas de seguridad de IronBarcode para una protección completa:

• Validación de entrada : desinfecte el contenido del código de barras antes de almacenarlo o actuar sobre él
• Limitación de velocidad : utilice el middleware de limitación de velocidad integrado de ASP.NET Core para evitar el abuso de la API
• Autenticación : puntos finales seguros con tokens JWT o claves API
• Aplicación de HTTPS : todo el tráfico de la API de código de barras debe viajar a través de TLS
• Política CORS : restrinja qué orígenes pueden llamar a su punto final de escaneo
• Gestión de claves de licencia : aplique las claves de licencia correctamente y configúrelas en web.config para producción

Construyendo el controlador de API de producción

[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
        {
            if (string.IsNullOrEmpty(request.ImageBase64))
                return BadRequest(new ErrorResponse { Error = "Image data is required" });

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

            byte[] imageBytes = Convert.FromBase64String(request.ImageBase64);

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

            var options = new BarcodeReaderOptions
            {
                Speed = ReadingSpeed.Faster,
                ExpectMultipleBarcodes = request.ExpectMultiple ?? false,
                UseConfidenceThreshold = true,
                ConfidenceThreshold = 0.8
            };

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

            var response = new BarcodeResponse
            {
                Success = true,
                Barcodes = results.Select(r => new BarcodeData
                {
                    Type = r.BarcodeType.ToString(),
                    Value = r.Text,
                    Confidence = r.Confidence,
                    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.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" });
        }
    }
}

public record BarcodeRequest(string ImageBase64, bool? ExpectMultiple);

public record BarcodeResponse
{
    public bool Success { get; init; }
    public List<BarcodeData> Barcodes { get; init; } = new();
}

public record BarcodeData
{
    public string Type { get; init; }
    public string Value { get; init; }
    public double Confidence { get; init; }
    public BarcodePosition Position { get; init; }
}

public record BarcodePosition(int X, int Y, int Width, int Height);

public record ErrorResponse
{
    public bool Success => false;
    public string Error { get; init; }
}

[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
        {
            if (string.IsNullOrEmpty(request.ImageBase64))
                return BadRequest(new ErrorResponse { Error = "Image data is required" });

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

            byte[] imageBytes = Convert.FromBase64String(request.ImageBase64);

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

            var options = new BarcodeReaderOptions
            {
                Speed = ReadingSpeed.Faster,
                ExpectMultipleBarcodes = request.ExpectMultiple ?? false,
                UseConfidenceThreshold = true,
                ConfidenceThreshold = 0.8
            };

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

            var response = new BarcodeResponse
            {
                Success = true,
                Barcodes = results.Select(r => new BarcodeData
                {
                    Type = r.BarcodeType.ToString(),
                    Value = r.Text,
                    Confidence = r.Confidence,
                    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.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" });
        }
    }
}

public record BarcodeRequest(string ImageBase64, bool? ExpectMultiple);

public record BarcodeResponse
{
    public bool Success { get; init; }
    public List<BarcodeData> Barcodes { get; init; } = new();
}

public record BarcodeData
{
    public string Type { get; init; }
    public string Value { get; init; }
    public double Confidence { get; init; }
    public BarcodePosition Position { get; init; }
}

public record BarcodePosition(int X, int Y, int Width, int Height);

public record ErrorResponse
{
    public bool Success => false;
    public string Error { get; init; }
}

Este punto final acepta imágenes codificadas en base64, el formato estándar para transmitir imágenes por HTTP. La respuesta incluye el tipo de código de barras, el valor decodificado, el nivel de confianza y la posición. Para escenarios de gran volumen, revise las opciones de optimización de la velocidad de lectura y procesamiento de códigos de barras por lotes .

¿Cómo gestiona la API múltiples códigos de barras?

IronBarcode procesa múltiples códigos de barras en una sola imagen en una sola llamada y devuelve una matriz de resultados. Cada entrada en la respuesta incluye datos de posición para que la aplicación cliente pueda resaltar los códigos de barras detectados en la pantalla.

La respuesta JSON estructurada proporciona a las aplicaciones cliente todo lo que necesitan para procesar y mostrar resultados de códigos de barras sin búsquedas adicionales.

Diagnóstico de problemas comunes de escaneo

Antes de aplicar correcciones, identifique en qué categoría se encuentra su problema. La mayoría de las fallas de escaneo en producción se dividen en cinco grupos: problemas de calidad de imagen (borrosidad, ruido, baja resolución), problemas geométricos (rotación, inclinación, distorsión de la perspectiva), problemas de daños (etiquetas rotas, tinta manchada), problemas ambientales (resplandor, sombras, iluminación inconsistente) y detección de falsos positivos donde el lector encuentra un código de barras que no existe.

Conocer la categoría le ayudará a seleccionar la combinación de filtros y la velocidad de lectura adecuadas sin ejecutar un procesamiento innecesario en cada imagen. Para la mayoría de los escenarios de aplicaciones web, comenzar con ReadingSpeed.Balanced y AutoRotate = true cubre la mayoría de los casos. Solo escalar a ExtremeDetail cuando el primer paso no arroje resultados.

El enfoque de múltiples pasadas en el código siguiente implementa esta estrategia escalonada. El primer paso rápido maneja imágenes típicas rápidamente, manteniendo la latencia media baja para el caso común. El segundo pase detallado solo se activa cuando falla el primer pase, lo que garantiza que usted pague el costo de procesamiento adicional solo cuando realmente sea necesario. Este patrón mantiene su punto final ASP.NET receptivo bajo carga normal y al mismo tiempo maneja casos extremos difíciles de manera confiable.

Implementación del procesamiento de imágenes de múltiples pasadas

Para imágenes desafiantes, un enfoque de procesamiento por niveles produce los mejores resultados sin sacrificar el rendimiento en imágenes fáciles:

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

    public async Task<List<ScannedBarcode>> ProcessChallengingImage(Stream imageStream)
    {
        // First pass -- fast, minimal processing
        var fastOptions = new BarcodeReaderOptions
        {
            Speed = ReadingSpeed.Balanced,
            ExpectMultipleBarcodes = true,
            AutoRotate = false,
            UseConfidenceThreshold = true,
            ConfidenceThreshold = 0.85
        };

        var results = BarcodeReader.Read(imageStream, fastOptions);

        if (!results.Any())
        {
            // Second pass -- aggressive image correction
            imageStream.Position = 0;

            var detailedOptions = new BarcodeReaderOptions
            {
                Speed = ReadingSpeed.ExtremeDetail,
                ExpectMultipleBarcodes = true,
                AutoRotate = true,
                RemoveFalsePositive = true,
                UseConfidenceThreshold = true,
                ConfidenceThreshold = 0.6,
                Multithreaded = true,
                ExpectBarcodeTypes = BarcodeEncoding.All,
                ImageFilters = new ImageFilterCollection
                {
                    new SharpenFilter(2.5f),
                    new ContrastFilter(2.0f),
                    new BrightnessFilter(1.2f),
                    new InvertFilter()
                }
            };

            results = BarcodeReader.Read(imageStream, detailedOptions);
            _logger.LogInformation("Second pass detected {Count} barcodes", results.Count());
        }

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

public record ScannedBarcode
{
    public string Value { get; init; }
    public string BarcodeType { get; init; }
    public double Confidence { get; init; }
    public float RotationAngle { get; init; }
    public int PageNumber { get; init; }
}

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

    public async Task<List<ScannedBarcode>> ProcessChallengingImage(Stream imageStream)
    {
        // First pass -- fast, minimal processing
        var fastOptions = new BarcodeReaderOptions
        {
            Speed = ReadingSpeed.Balanced,
            ExpectMultipleBarcodes = true,
            AutoRotate = false,
            UseConfidenceThreshold = true,
            ConfidenceThreshold = 0.85
        };

        var results = BarcodeReader.Read(imageStream, fastOptions);

        if (!results.Any())
        {
            // Second pass -- aggressive image correction
            imageStream.Position = 0;

            var detailedOptions = new BarcodeReaderOptions
            {
                Speed = ReadingSpeed.ExtremeDetail,
                ExpectMultipleBarcodes = true,
                AutoRotate = true,
                RemoveFalsePositive = true,
                UseConfidenceThreshold = true,
                ConfidenceThreshold = 0.6,
                Multithreaded = true,
                ExpectBarcodeTypes = BarcodeEncoding.All,
                ImageFilters = new ImageFilterCollection
                {
                    new SharpenFilter(2.5f),
                    new ContrastFilter(2.0f),
                    new BrightnessFilter(1.2f),
                    new InvertFilter()
                }
            };

            results = BarcodeReader.Read(imageStream, detailedOptions);
            _logger.LogInformation("Second pass detected {Count} barcodes", results.Count());
        }

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

public record ScannedBarcode
{
    public string Value { get; init; }
    public string BarcodeType { get; init; }
    public double Confidence { get; init; }
    public float RotationAngle { get; init; }
    public int PageNumber { get; init; }
}

La clase BarcodeReaderOptions proporciona un control detallado sobre cada aspecto del escaneo. La configuración AutoRotate maneja imágenes capturadas en cualquier ángulo, mientras que los filtros de imagen mejoran la claridad de los códigos de barras borrosos o de bajo contraste. Para obtener una configuración detallada, consulte el ejemplo de configuración del lector de código de barras y la configuración del lector específico de PDF .

Al trabajar con archivos PDF, considere estampar códigos de barras en ellos o crear códigos de barras como documentos PDF . Para el procesamiento de gran volumen, habilitar subprocesos múltiples a través de las capacidades asíncronas y multiproceso mejora significativamente el rendimiento.

Adición de compatibilidad del navegador y estrategias de respaldo

La compatibilidad con diversos navegadores requiere una mejora progresiva. Los navegadores modernos en Android y el escritorio Chrome, Edge y Firefox admiten la API MediaDevices.getUserMedia() para el acceso a la cámara. Safari en iOS lo admite desde la versión 11 en adelante. Es posible que los navegadores empresariales más antiguos, los modos de compatibilidad con IE11 y ciertos entornos corporativos bloqueados no admitan el acceso a la cámara, por lo que su ruta de carga de archivos alternativa siempre debe permanecer funcional.

El enfoque recomendado es utilizar la detección de características en tiempo de ejecución en lugar de rastrear el agente de usuario y luego mostrar u ocultar la interfaz de la cámara según corresponda. Comience con una interfaz compatible con cámara y luego vuelva con elegancia a la carga de archivos:

@* Razor view with progressive enhancement *@
<div class="barcode-scanner-container">
    @* Camera capture -- hidden until JavaScript confirms support *@
    <div id="cameraSection" class="d-none">
        <video id="videoPreview" class="w-100" autoplay></video>
        <button id="captureBtn" class="btn btn-primary mt-2">Capture and Scan</button>
    </div>

    @* File upload -- always available as fallback *@
    <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 and Scan</button>
        </form>
    </div>
</div>

@* Razor view with progressive enhancement *@
<div class="barcode-scanner-container">
    @* Camera capture -- hidden until JavaScript confirms support *@
    <div id="cameraSection" class="d-none">
        <video id="videoPreview" class="w-100" autoplay></video>
        <button id="captureBtn" class="btn btn-primary mt-2">Capture and Scan</button>
    </div>

    @* File upload -- always available as fallback *@
    <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 and Scan</button>
        </form>
    </div>
</div>

La integración de Blazor proporciona soporte para aplicaciones web modernas con una configuración mínima si prefiere un enfoque basado en componentes. Para solucionar problemas de implementación, consulte la guía de excepciones de copia de tiempos de ejecución .