Scanner de codes-barres ASP.NET : Téléchargement de fichiers et API REST avec IronBarcode

Installation via le gestionnaire de packages NuGet

Ouvrez la console du Package Manager dans Visual Studio et exécutez :

Install-Package BarCode

Install-Package BarCode

Vous pouvez également utiliser l'interface de ligne de commande .NET :

dotnet add package BarCode

dotnet add package BarCode

Vous pouvez également rechercher " BarCode " dans l'interface utilisateur du gestionnaire de packages NuGet de Visual Studio et cliquer sur Installer. Le package gère automatiquement toutes les dépendances.

Pour les déploiements spécifiques à une plateforme, envisagez d'utiliser des packages NuGet spécifiques à la plateforme et optimisés pour votre environnement cible. La bibliothèque propose des packages standard et BarCode.Slim pour s'adapter à différents scénarios de déploiement. Pour obtenir la procédure d'installation complète, consultez le guide d'installation IronBarcode .

Configuration de votre projet

Une fois installé, ajoutez l'instruction using nécessaire à vos fichiers C# :

using IronBarCode;

using IronBarCode;

Cette importation vous donne accès aux fonctionnalités complètes de lecture et de génération de codes-barres d'IronBarcode. La bibliothèque prend en charge plus de 30 formats de codes-barres, notamment QR Code, Code 128, Code 39, Data Matrix et PDF417. Consultez la liste complète des formats de codes-barres pris en charge pour vérifier la compatibilité avec votre cas d'utilisation.

Pour résoudre les problèmes d'installation, consultez le guide de dépannage des packages NuGet ou soumettez une demande d'assistance technique spécialisée.

Choisir le bon modèle architectural

Lors de la mise en œuvre de la lecture de codes-barres dans ASP.NET, vous avez deux approches architecturales principales. Comprendre ces modèles vous aide à choisir les paramètres de lecteur de codes-barres adaptés à chaque cas d'utilisation :

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

L'approche côté serveur vous offre un contrôle maximal sur le traitement des images et fonctionne de manière cohérente sur tous les navigateurs. Lorsque le serveur traite chaque image, vous obtenez également une piste d'audit complète : chaque code-barres scanné passe par votre couche applicative où vous pouvez l'enregistrer, le valider par rapport à une base de données ou déclencher des flux de travail en aval. Ce modèle est particulièrement adapté aux secteurs réglementés comme la santé, la logistique et la fabrication, où chaque scan doit être enregistré.

Pour l'intégration de la capture vidéo côté client, les navigateurs modernes prennent en charge l'API MediaDevices d'accès à la caméra, qui peut être combinée avec le traitement côté serveur d'IronBarcode via une API REST – décrite en détail plus loin dans ce guide. Le choix du traitement côté serveur simplifie également votre modèle de sécurité : aucune logique de traitement sensible n'est exposée au navigateur et toute la validation s'effectue en dehors de votre application.

Création du formulaire de téléchargement

Créez un formulaire HTML réactif dans votre vue 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>

L'attribut capture="environment" active la caméra arrière sur les appareils mobiles, offrant aux utilisateurs une expérience similaire à celle d'une caméra native sans JavaScript.

Mise en œuvre d'un traitement backend sécurisé

L'action du contrôleur gère la validation des fichiers, le traitement du flux mémoire et la mise en forme des résultats :

[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();
}

Cette implémentation valide le type de fichier avant traitement, lit les codes-barres à partir d'un flux mémoire et renvoie tous les résultats détectés. IronBarcode traite différents formats d'image , notamment les documents TIFF et GIF multipages et les documents PDF , éliminant ainsi le code de gestion spécifique au format.

À quoi ressemblent les entrées et sorties scannées ?

L'exemple ci-dessus illustre un code-barres standard Code 128, un format courant dans les applications d'expédition et de gestion des stocks. Après l'analyse, l'écran de résultats confirme la valeur décodée ainsi que les métadonnées de confiance :

IronBarcode renvoie le type de code-barres, la valeur décodée, le score de confiance et les données de position pour chaque code-barres détecté dans l'image téléchargée.

Considérations de sécurité pour les API de codes-barres

Avant d'écrire le contrôleur, planifiez la couche de sécurité. Les données des codes-barres peuvent contenir des informations arbitraires ; il est donc impératif de toujours valider les données saisies. Suivez les consignes de sécurité IronBarcode pour une protection complète :

• Validation des données saisies : Nettoyer le contenu du code-barres avant de le stocker ou de l'utiliser.
• Limitation du débit : Utilisez le middleware de limitation de débit intégré à ASP.NET Core pour empêcher les abus d'API.
• Authentification : Sécurisez les points de terminaison avec des jetons JWT ou des clés API.
• Application du protocole HTTPS : Tout le trafic de l'API de codes-barres doit transiter par TLS.
• Politique CORS : limitez les origines autorisées à appeler votre point de terminaison d'analyse
• Gestion des clés de licence : Appliquer correctement les clés de licence et les configurer dans le fichier web.config pour la production

Création du contrôleur d'API de production

[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; }
}

Ce point de terminaison accepte les images encodées en base64, le format standard pour la transmission d'images via HTTP. La réponse comprend le type de code-barres, sa valeur décodée, son score de confiance et sa position. Pour les scénarios à volume élevé, examinez les options d'optimisation du traitement par lots des codes-barres et de la vitesse de lecture .

Comment l'API gère-t-elle plusieurs codes-barres ?

IronBarcode traite plusieurs codes-barres dans une seule image en un seul appel, et renvoie un tableau de résultats. Chaque entrée de la réponse comprend des données de position permettant à l'application cliente de mettre en évidence les codes-barres détectés à l'écran.

La réponse JSON structurée fournit aux applications clientes tout ce dont elles ont besoin pour traiter et afficher les résultats des codes-barres sans recherches supplémentaires.

Diagnostic des problèmes de numérisation courants

Avant d'appliquer des corrections, identifiez la catégorie à laquelle appartient votre problème. La plupart des échecs de numérisation en production se répartissent en cinq groupes : problèmes de qualité d'image (flou, bruit, faible résolution), problèmes géométriques (rotation, inclinaison, distorsion de perspective), problèmes de dommages (étiquettes déchirées, encre bavée), problèmes environnementaux (reflets, ombres, éclairage irrégulier) et faux positifs, lorsque le lecteur détecte un code-barres inexistant.

Connaître la catégorie vous aide à sélectionner la bonne combinaison de filtres et la vitesse de lecture sans effectuer de traitement inutile sur chaque image. Pour la plupart des scénarios d'application Web, commencer par ReadingSpeed.Balanced et AutoRotate = true couvre la majorité des cas. N'utilisez le code ExtremeDetail que lorsque la première passe ne donne aucun résultat.

L'approche multi-passes du code ci-dessous met en œuvre cette stratégie hiérarchisée. Le premier passage rapide traite rapidement les images typiques, maintenant ainsi une latence médiane faible dans la plupart des cas. La seconde analyse détaillée n'est déclenchée que lorsque la première échoue, vous assurant ainsi de ne payer les frais de traitement supplémentaires que lorsqu'ils sont réellement nécessaires. Ce modèle permet à votre point de terminaison ASP.NET de rester réactif sous une charge normale tout en gérant de manière fiable les cas limites difficiles.

Mise en œuvre du traitement d'images multi-passes

Pour les images complexes, une approche de traitement par étapes donne les meilleurs résultats sans sacrifier les performances sur les images faciles :

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 classe BarcodeReaderOptions offre un contrôle précis sur chaque aspect de la numérisation. Le paramètre AutoRotate gère les images capturées sous n'importe quel angle, tandis que les filtres d'image améliorent la clarté des codes-barres flous ou à faible contraste. Pour une configuration détaillée, consultez l' exemple de paramètres du lecteur de codes-barres et les paramètres spécifiques au lecteur PDF .

Lorsque vous travaillez avec des fichiers PDF, pensez à y apposer des codes-barres ou à créer des codes-barres sous forme de documents PDF . Pour le traitement de volumes importants, l'activation du multithreading via les fonctionnalités asynchrones et multithread améliore considérablement le débit.

Ajout de la compatibilité navigateur et de stratégies de repli

La prise en charge de différents navigateurs nécessite une amélioration progressive. Les navigateurs modernes sur Android et sur ordinateur Chrome, Edge et Firefox prennent en charge l'API MediaDevices.getUserMedia() pour l'accès à la caméra. Safari sur iOS le prend en charge à partir de la version 11. Les navigateurs Enterprise plus anciens, les modes de compatibilité IE11 et certains environnements d'entreprise verrouillés peuvent ne pas prendre en charge l'accès à la caméra ; votre solution de secours pour le téléchargement de fichiers doit donc toujours rester fonctionnelle.

L'approche recommandée consiste à utiliser la détection de caractéristiques en temps réel plutôt que la détection de l'agent utilisateur, puis à afficher ou masquer l'interface de la caméra en conséquence. Commencez par une interface compatible avec une caméra et basculez facilement vers le téléchargement de fichiers :

@* 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>

L' intégration Blazor offre une prise en charge des applications web modernes avec une configuration minimale si vous préférez une approche basée sur les composants. Pour le dépannage du déploiement, consultez le guide des exceptions de copie des environnements d' exécution.