Tutoriel sur le générateur de codes-barres ASP.NET : Guide du générateur de codes-barres C#

Pourquoi choisir IronBarcode plutôt que des alternatives open source ?

Lors de l'évaluation des bibliothèques de codes-barres, on considère souvent des options open source comme ZXing.NET, BarcodeLib ou SkiaSharp . Cependant, IronBarcode offre des avantages distincts qui justifient sa licence commerciale :

Tests de performance : IronBarcode traite les codes-barres 3 à 5 fois plus rapidement que ZXing.NET en situation de production, notamment avec des images endommagées ou pivotées. Sa prise en charge du multithreading évolue linéairement avec le nombre de cœurs du processeur, tandis que la plupart des alternatives open source sont monothread. Les fonctionnalités asynchrones et multithread permettent un traitement efficace de plusieurs codes-barres simultanément.

Gestion de la qualité d'image : Contrairement à ZXing qui nécessite des images de codes-barres impeccables, le moteur d'IronBarcode, basé sur l'apprentissage automatique, lit avec précision les codes-barres à partir de photos prises sous certains angles, avec un éclairage médiocre ou partiellement endommagés. La correction d'image et d'orientation intégrée élimine les étapes de prétraitement requises par d'autres bibliothèques.

Support aux entreprises : Les licences commerciales incluent un support dédié, des mises à jour régulières et des SLA professionnels. Les projets open source reposent sur le soutien de la communauté sans aucune garantie quant aux délais de réponse ou à la correction des bugs. Le système de demandes d'ingénierie garantit une résolution rapide des problèmes techniques.

Simplicité de l'API : La lecture d'un code-barres avec IronBarcode ne nécessite qu'une seule ligne de code, contre 10 à 20 lignes pour une fonctionnalité équivalente dans les alternatives open source. Cela se traduit par un développement plus rapide et des coûts de maintenance réduits. Consultez les exemples de démarrage rapide des codes-barres pour constater la simplicité en action.

Quelles sont les méthodes d'installation disponibles ?

Tout d'abord, installez IronBarcode en utilisant la console du gestionnaire de packages NuGet :

Install-Package BarCode

Install-Package BarCode

Vous pouvez également l'installer via l'interface utilisateur du gestionnaire de packages NuGet de Visual Studio en recherchant " IronBarCode " et en cliquant 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 qui améliorent les performances de votre environnement cible. La bibliothèque propose des packages standard et BarCode.Slim pour s'adapter à différents scénarios de déploiement. Pour des instructions détaillées d'installation, consultez le guide d'installation IronBarcode.

Comment configurer IronBarcode dans votre projet ?

Une fois installé, ajoutez l'instruction using nécessaire à vos fichiers de lecteur de code-barres C# :

using IronBarCode;

using IronBarCode;

Cette simple 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 la génération de codes QR , les codes Code 128, Code 39, Data Matrix et PDF417. Consultez la liste complète des formats de codes-barres pris en charge pour garantir la compatibilité. La bibliothèque offre des fonctionnalités avancées, notamment des options de style et des améliorations de lecture . Selon la documentation Microsoft sur ASP.NET, une gestion appropriée des packages est cruciale pour maintenir la sécurité des applications. Pour résoudre les problèmes, consultez le guide de dépannage des packages NuGet ou soumettez une demande d'assistance technique spécialisée.

Quels modèles d'architecture sont les plus adaptés à la numérisation sur le Web ?

Lors de la mise en œuvre de la lecture de codes-barres dans les applications ASP.NET, deux approches architecturales principales s'offrent à vous. Comprendre ces modèles vous aide à choisir les paramètres de lecteur de codes-barres adaptés à chaque cas d'utilisation. La bibliothèque fournit des formats de données de sortie complets pour répondre à divers besoins architecturaux :

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

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

Cette approche côté serveur offre un contrôle maximal sur le traitement des images et fonctionne de manière cohérente sur tous les navigateurs. Pour l'intégration de la capture côté client, les navigateurs modernes prennent en charge l'API MediaDevices pour l'accès à la caméra, qui peut être combinée avec l'optimisation des vitesses de traitement et de lecture de l'API REST d'IronBarcode. Envisagez la mise en œuvre de l'asynchronisme et du multithreading pour améliorer les performances. La documentation de référence de l'API de la bibliothèque fournit des informations détaillées sur toutes les options disponibles.

Quand faut-il utiliser le traitement côté client plutôt que le traitement côté serveur ?

Le choix entre la capture côté client avec traitement côté serveur et une implémentation purement côté serveur dépend de plusieurs facteurs :

Capture côté client + traitement côté serveur :

• Idéal pour les scénarios de numérisation en temps réel
• Réduit la bande passante en traitant les données sur l'appareil avant le chargement.
• Nécessite la prise en charge des navigateurs modernes
• Une meilleure expérience utilisateur grâce à un retour d'information instantané
• Envisagez la lecture asynchrone des codes-barres pour améliorer les performances

Traitement côté serveur pur :

• Compatibilité maximale avec tous les appareils
• Contrôle total du pipeline de traitement
• Plus adapté aux scénarios de traitement par lots avec lecture de plusieurs codes-barres
• Modèle de sécurité simplifié
• Prend en charge la lecture à partir de flux pour une utilisation optimale de la mémoire

Quelle structure HTML permet un téléchargement de fichiers amélioré ?

Créez un formulaire HTML réactif dans votre vue ASP.NET :

<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" /> <!-- Mobile camera support -->
    </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>

<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" /> <!-- Mobile camera support -->
    </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>

Comment mettre en œuvre un traitement backend sécurisé ?

Implémentez maintenant le contrôleur backend avec des validations de sécurité et améliorez le traitement pour votre lecteur de codes-barres ASP.NET, utilisez des formats de données de sortie pour une gestion flexible des résultats. Envisagez la mise en œuvre d' une prévention des faux positifs et la prise en charge de la norme GS1-128 pour les exigences spécifiques en matière de codes-barres :

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

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

Cette implémentation traite les fichiers téléchargés en les copiant dans un flux mémoire, puis en utilisant la méthode BarcodeReader.Read d'IronBarcode pour extraire tous les codes-barres. La méthode détecte automatiquement le format du code-barres et renvoie des résultats détaillés. IronBarcode traite différents formats d'image , y compris les fichiers TIFF et GIF multipages , et même les documents PDF , éliminant ainsi le code de gestion spécifique au format. Pour une précision accrue, explorez les techniques de correction d'image et de correction d'orientation . Les fonctionnalités de la bibliothèque s'étendent à la création de codes-barres sous forme d'images et à l'enregistrement des codes-barres générés . Cette polyvalence le rend idéal pour les scénarios de traitement de documents discutés dans les fils de discussion d'implémentation de code-barres de Stack Overflow. Pour plus d'informations sur les types de codes-barres spécifiques, consultez la section sur les codes-barres Code 39 et l' exemple Code 39 .

À quoi ressemble l'image du code-barres d'entrée ?

! L'URL d'encodage du code-barres Code 128 " https://ironsoftware.com/csharp/barcode/ " affiche des barres lisibles par machine avec du texte lisible par l'humain en dessous pour une lecture précise dans les applications de lecture de codes-barres ASP.NET

L'exemple ci-dessus illustre un code-barres Code 128 typique qu'IronBarcode traite efficacement, en maintenant la précision même avec des variations de qualité d'image.

Quels résultats renvoie le lecteur de codes-barres ?

Interface d'application web ASP.NET Core affichant les résultats de lecture de codes-barres réussis, avec un formulaire de téléchargement de fichier présentant la valeur du code-barres Code128 décodé et les métadonnées relatives au score de confiance.

IronBarcode renvoie des métadonnées complètes, notamment le type de code-barres, la valeur décodée, les scores de confiance et les données de position pour chaque code-barres détecté.## Comment créer une API REST pour la lecture de codes-barres ou de codes QR ?

Les applications web ASP.NET modernes ont souvent besoin de fonctionnalités de lecture de codes-barres fournies par les API REST, permettant l'intégration avec des applications mobiles, des SPA ou des services tiers. Cette méthode prend en charge la capture caméra côté client avec traitement côté serveur. La fonctionnalité de création de codes-barres de la bibliothèque complète ses capacités de lecture pour des solutions de codes-barres complètes. Voici comment créer une API de lecteur de codes-barres fiable et prête pour la production en utilisant ASP.NET Core avec des capacités d'exportation vers des flux . Pour les implémentations spécifiques aux codes QR, explorez la création de codes QR et le style personnalisé des codes QR :

Quelles sont les considérations de sécurité applicables aux API de codes-barres ?

La mise en œuvre d'une API de lecture de codes-barres exige une attention particulière à la sécurité, notamment lors du traitement de données sensibles encodées dans les codes-barres. Suivez les consignes de sécurité d'IronBarcode pour une protection complète :

Validation des entrées : Validez toujours les données entrantes afin de prévenir les attaques par injection. Les codes-barres peuvent contenir des charges utiles malveillantes s'ils ne sont pas correctement nettoyés.

Limitation du débit : Mettez en œuvre une limitation du débit des requêtes afin d'empêcher les abus d'API et les attaques par déni de service. Envisagez d'utiliser le middleware de limitation de débit intégré à ASP.NET Core.

Authentification et autorisation : Sécurisez les points de terminaison d'API avec des mécanismes d'authentification appropriés tels que les jetons JWT ou les clés API. Appliquez correctement les clés de licence pour les déploiements en production.

Chiffrement des données : Utilisez HTTPS pour toutes les communications API et envisagez de chiffrer les données sensibles des codes-barres au repos. Pour les applications web, configurez les clés de licence de manière sécurisée dans le fichier web.config .

Configuration CORS : Configurez soigneusement les politiques de partage de ressources entre origines (CORS) afin d'empêcher les domaines non autorisés d'accéder à votre API.

Comment créer une API de codes-barres prête pour la 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
        {
            // 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; }
}

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

Ce point de terminaison d'API accepte les images encodées en base64, un format standard pour la transmission d'images via HTTP. La réponse inclut les informations complètes du code-barres, avec les scores de confiance et les données de position. L'implémentation suit les meilleures pratiques RESTful , garantissant une intégration fluide avec n'importe quel framework frontend. Pour les scénarios à volume élevé, envisagez la mise en œuvre d' un traitement par lots des codes-barres et l'optimisation de la vitesse de lecture . Les options de licence de la bibliothèque incluent une prise en charge de niveau entreprise pour les déploiements d'API, avec des possibilités de mise à niveau et des extensions pour la mise à l'échelle.

Quelles sont les options d'implémentation côté client disponibles ?

Le code JavaScript suivant illustre une intégration moderne côté client avec la capture par caméra, qui peut être utilisée avec la lecture asynchrone des codes-barres . Pour d'autres besoins en matière de génération de codes-barres, explorez les styles de codes-barres personnalisés et la création de codes-barres à partir de diverses sources de données :

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

Cette approche API permet une intégration fluide avec les frameworks JavaScript modernes et les applications mobiles. Pour les implémentations spécifiques aux appareils mobiles, explorez les options de déploiement iOS et Android , ainsi que la lecture de codes-barres .NET MAUI . Parmi les fonctionnalités supplémentaires, citons l'exportation des codes-barres au format HTML et la création de codes-barres à partir de sources de données . Pour vos besoins en génération de codes-barres, explorez la création d'images de codes-barres 1-BPP et l'écriture de codes-barres Unicode .

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

Trois formats de codes-barres différents, étiquetés ABC, illustrent les symbologies QR Code, Code128 et DataMatrix qu'IronBarcode traite simultanément en production.

IronBarcode traite efficacement plusieurs codes-barres dans une seule image, en renvoyant des informations détaillées pour chaque code-barres détecté, avec des données de position et des scores de confiance.

À quoi ressemble la structure de la réponse JSON ?

! L'onglet Réseau des outils de développement du navigateur affiche une réponse API JSON réussie contenant un tableau de trois codes-barres détectés avec des métadonnées complètes, notamment le type, la valeur, le niveau de confiance et les coordonnées de position.

La réponse JSON structurée inclut toutes les métadonnées nécessaires aux applications clientes pour traiter et afficher efficacement les résultats des codes-barres.## Comment gérer les images de codes-barres difficiles ?

La lecture des codes-barres en situation réelle implique souvent des images imparfaites : photos prises de biais, mauvais éclairage ou codes-barres partiellement endommagés. IronBarcode excelle dans ces scénarios grâce à ses capacités avancées de traitement d'images et à ses seuils de confiance d'apprentissage automatique . Les fonctionnalités de tolérance aux pannes de la bibliothèque garantissent une lecture fiable même dans des conditions difficiles. Pour des défis spécifiques, explorez les solutions aux problèmes de codes-barres non reconnus et aux problèmes de reconnaissance des codes-barres MSI . La bibliothèque gère également les codes-barres imparfaits grâce à la correction d'image .

À quels scénarios de dépannage courants devez-vous vous préparer ?

Les applications de lecture de codes-barres en production rencontrent divers défis qui nécessitent des approches de dépannage systématiques. Le guide de dépannage des faux positifs contribue à améliorer la précision de la détection :

Images floues ou de mauvaise qualité :

• Appliquer des filtres de netteté à l'aide de filtres de correction d'image
• Utilisez les réglages de contraste pour les codes-barres estompés.
• Envisagez plusieurs passes de traitement avec des paramètres différents

Codes-barres pivotés ou obliques :

• Activer AutoRotate pour la correction automatique de l'orientation
• Traiter les images à plusieurs angles de rotation si nécessaire
• Utilisez la correction de perspective pour les images fortement déformées.

Codes-barres endommagés ou partiels :

• Utiliser les fonctions de correction d'erreurs
• Essayez plusieurs algorithmes avec différentes options de vitesse de lecture
• Mettre en place un système de saisie manuelle en cas d'échec de la lecture automatisée.

Détection de faux positifs :

• Définir des seuils de confiance appropriés
• Valider le format du code-barres par rapport aux modèles attendus
• Vérification croisée avec les bases de données de codes-barres connues

Problèmes de performance :

• Ajustez la taille de l'image avant le traitement
• Utilisez les paramètres de vitesse de lecture appropriés
• Mettre en place un système de cache pour les analyses répétées
• Tenir compte des régions de culture pour se concentrer sur des zones spécifiques

Comment mettre en œuvre un traitement d'images avancé ?

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
}

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
}

La classe BarcodeReaderOptions offre un contrôle précis de la numérisation. Le paramètre de AutoRotate gère les images capturées sous n'importe quel angle, tandis que les filtres d'image améliorent la netteté des codes-barres flous ou à faible contraste. La propriété Vitesse permet d'équilibrer la vitesse de traitement et la précision en fonction des exigences de votre application. 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 spécifiquement avec des fichiers PDF, envisagez d'imprimer des codes-barres sur les PDF ou de créer des codes-barres sous forme de documents PDF . Pour le traitement de volumes importants, l'activation du multithreading améliore considérablement les performances. Cette approche est conforme aux meilleures pratiques de l'industrie en matière de traitement d'images . Pour gérer des scénarios spécifiques, explorez la correction imparfaite des codes-barres et la spécification de la région de recadrage . Le tutoriel de la bibliothèque sur la lecture des codes-barres fournit des informations supplémentaires sur les configurations avancées.

Comment mettre en œuvre la compatibilité navigateur et les stratégies de repli ?

La prise en charge de différents navigateurs nécessite la mise en œuvre de l'amélioration progressive. Envisagez d'utiliser la compatibilité System.Drawing pour la gestion des images multiplateformes. L'intégration Blazor de la bibliothèque offre une prise en charge des applications web modernes avec une configuration minimale. Pour les problèmes de déploiement, consultez le guide des exceptions de copie des environnements d'exécution :

@* 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() {
    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>

Quelles sont les bonnes pratiques de sécurité à suivre ?

Les systèmes de lecture de codes-barres en production doivent mettre en œuvre des mesures de sécurité complètes pour se protéger contre les différentes attaques. Consultez la CVE de sécurité d'IronBarcode pour obtenir les dernières mises à jour de sécurité :

Validation et assainissement des données :

• Valider le contenu de tous les codes-barres avant traitement
• Mettre en œuvre une validation par liste blanche pour les formats attendus
• Nettoyer les données avant leur stockage dans la base de données
• Prévenir les injections SQL grâce à des requêtes paramétrées

Contrôle d'accès et authentification :

• Mettre en œuvre le contrôle d'accès basé sur les rôles (RBAC)
• Utilisez des mécanismes d'authentification sécurisés
• Consigner toutes les activités de lecture de codes-barres
• Surveiller les schémas de balayage inhabituels
• Appliquer correctement les clés de licence

Communication sécurisée :

• Imposer le protocole HTTPS pour tous les points de terminaison de l'API
• Mettre en œuvre l'épinglage de certificats pour les applications mobiles
• Utilisez des connexions WebSocket sécurisées pour l'analyse en temps réel
• Chiffrer les données sensibles des codes-barres en transit et au repos

Quelles techniques d'optimisation des performances s'appliquent ?

Pour les déploiements en production, tenez compte de ces recommandations architecturales afin d'optimiser les performances et la fiabilité :

Mettre en œuvre la limitation du nombre de requêtes : Protégez vos API contre les abus en limitant le débit grâce à des algorithmes de fenêtre glissante pour une utilisation équitable. Mettre en place des quotas par client afin de garantir une répartition équitable des ressources.

Utiliser la mise en cache de manière stratégique : Mise en cache des résultats de codes-barres pour les scans en double avec mise en cache distribuée pour une meilleure évolutivité. Définissez des valeurs TTL appropriées et utilisez l'exportation vers des flux pour une utilisation efficace de la mémoire.

Surveiller les indicateurs de performance : Suivre les temps de traitement par type de code-barres et surveiller les taux de réussite/d'échec à l'aide de seuils de confiance . Alerte en cas de dégradation des performances et analyse des formats de données de sortie pour identifier les opportunités d'optimisation.

Pour une sécurité renforcée, validez les fichiers téléchargés, mettez en œuvre une gestion appropriée des clés de licence, notamment la configuration du fichier web.config et l'application correcte des clés de licence , et envisagez l'utilisation de méthodes de diffusion en continu pour les fichiers volumineux. Les mesures de sécurité d'IronBarcode garantissent un fonctionnement sûr grâce à la certification DigiCert et à la protection contre la falsification . La compatibilité multiplateforme de la bibliothèque garantit un fonctionnement optimal de vos solutions dans les conteneurs Docker et les environnements cloud. Pour le packaging de déploiement, reportez-vous au guide d'installation MSI et au dépannage des DLL manquantes .

Prêt à révolutionner vos applications ASP.NET grâce à la lecture professionnelle de codes-barres ? Explorez la documentation complète de l'API pour découvrir des fonctionnalités avancées telles que le traitement par lots , l'extraction de codes-barres PDF , l'estampillage de codes-barres sur les PDF et les options de style personnalisées . Pour accéder aux fonctionnalités spécifiques aux codes QR, consultez les paramètres de style et de correction d'erreurs des codes QR . Les options de sortie supplémentaires incluent la création de codes-barres au format PDF , image , image 1-BPP et la définition des marges des codes-barres . Démarrez un essai gratuit pour découvrir tout le potentiel d'IronBarcode dans vos environnements de production.