Comment créer une API de scanner de codes-barres en C# en utilisant IronBarcode

Comment installer et configurer IronBarcode ?

Commencer avec IronBarcode est aussi simple que d'installer un seul package NuGet. Ouvrez votre projet ASP.NET Core et exécutez cette commande dans la Console du Gestionnaire de Packages :

Install-Package BarCode

Après installation, ajoutez l'espace de noms IronBarcode à votre contrôleur et testez la bibliothèque avec cet exemple en une ligne :

using IronBarCode;
// Simple test to verify installation
var result = BarcodeReader.Read("test-barcode.png");
Console.WriteLine($"Scanned: {result.First().Value}");

using IronBarCode;
// Simple test to verify installation
var result = BarcodeReader.Read("test-barcode.png");
Console.WriteLine($"Scanned: {result.First().Value}");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Ce code lit une image de code-barres et affiche sa valeur. La méthode BarcodeReader.Read() détecte automatiquement le format du code-barres et renvoie une collection de résultats, rendant extrêmement simple l'extraction des données de codes-barres d'images prises en charge (jpeg, bmp, png, tiff) et le travail avec des formats de données tableau ou binaire.

Comment puis-je créer un contrôleur d'API de scanner complet ?

Créer une API de scanner avec ASP.NET Core implique de configurer un contrôleur avec des paramètres qui acceptent diverses sources d'entrée. Voici une implémentation complète :

using Microsoft.AspNetCore.Mvc;
using IronBarCode;
using System.Drawing;
namespace BarcodeScannerAPI.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class ScannerController : ControllerBase
    {
        // Model for API responses
        public class ScanResult
        {
            public bool Success { get; set; }
            public List<string> BarcodeValues { get; set; } = new List<string>();
            public string BarcodeFormat { get; set; }
            public string ErrorMessage { get; set; }
        }
        [HttpPost("scan-file")]
        public async Task<ActionResult<ScanResult>> ScanFile(IFormFile file)
        {
            if (file == null || file.Length == 0)
                return BadRequest(new ScanResult
                {
                    Success = false,
                    ErrorMessage = "No file uploaded"
                });
            try
            {
                using var stream = new MemoryStream();
                await file.CopyToAsync(stream);
                // Configure scanner options for better accuracy
                var options = new BarcodeReaderOptions
                {
                    Speed = ReadingSpeed.Balanced,
                    ExpectMultipleBarcodes = true,
                    ExpectBarcodeTypes = BarcodeEncoding.All
                };
                // Read barcodes from the uploaded file
                var results = BarcodeReader.Read(stream.ToArray(), options);
                if (results.Any())
                {
                    return Ok(new ScanResult
                    {
                        Success = true,
                        BarcodeValues = results.Select(r => r.Value).ToList(),
                        BarcodeFormat = results.First().BarcodeType.ToString()
                    });
                }
                return Ok(new ScanResult
                {
                    Success = false,
                    ErrorMessage = "No barcodes found"
                });
            }
            catch (Exception ex)
            {
                return StatusCode(500, new ScanResult
                {
                    Success = false,
                    ErrorMessage = $"Processing error: {ex.Message}"
                });
            }
        }
        [HttpPost("scan-base64")]
        public ActionResult<ScanResult> ScanBase64([FromBody] string base64Image)
        {
            try
            {
                // Convert Base64 string to byte array
                byte[] imageBytes = Convert.FromBase64String(base64Image);
                // Process with IronBarcode
                var results = BarcodeReader.Read(imageBytes);
                return ProcessResults(results);
            }
            catch (Exception ex)
            {
                return BadRequest(new ScanResult
                {
                    Success = false,
                    ErrorMessage = $"Invalid Base64 data: {ex.Message}"
                });
            }
        }
        private ScanResult ProcessResults(BarcodeResults results)
        {
            if (results.Any())
            {
                return new ScanResult
                {
                    Success = true,
                    BarcodeValues = results.Select(r => r.Value).ToList(),
                    BarcodeFormat = results.First().BarcodeType.ToString()
                };
            }
            return new ScanResult
            {
                Success = false,
                ErrorMessage = "No barcodes detected"
            };
        }
    }
}

using Microsoft.AspNetCore.Mvc;
using IronBarCode;
using System.Drawing;
namespace BarcodeScannerAPI.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class ScannerController : ControllerBase
    {
        // Model for API responses
        public class ScanResult
        {
            public bool Success { get; set; }
            public List<string> BarcodeValues { get; set; } = new List<string>();
            public string BarcodeFormat { get; set; }
            public string ErrorMessage { get; set; }
        }
        [HttpPost("scan-file")]
        public async Task<ActionResult<ScanResult>> ScanFile(IFormFile file)
        {
            if (file == null || file.Length == 0)
                return BadRequest(new ScanResult
                {
                    Success = false,
                    ErrorMessage = "No file uploaded"
                });
            try
            {
                using var stream = new MemoryStream();
                await file.CopyToAsync(stream);
                // Configure scanner options for better accuracy
                var options = new BarcodeReaderOptions
                {
                    Speed = ReadingSpeed.Balanced,
                    ExpectMultipleBarcodes = true,
                    ExpectBarcodeTypes = BarcodeEncoding.All
                };
                // Read barcodes from the uploaded file
                var results = BarcodeReader.Read(stream.ToArray(), options);
                if (results.Any())
                {
                    return Ok(new ScanResult
                    {
                        Success = true,
                        BarcodeValues = results.Select(r => r.Value).ToList(),
                        BarcodeFormat = results.First().BarcodeType.ToString()
                    });
                }
                return Ok(new ScanResult
                {
                    Success = false,
                    ErrorMessage = "No barcodes found"
                });
            }
            catch (Exception ex)
            {
                return StatusCode(500, new ScanResult
                {
                    Success = false,
                    ErrorMessage = $"Processing error: {ex.Message}"
                });
            }
        }
        [HttpPost("scan-base64")]
        public ActionResult<ScanResult> ScanBase64([FromBody] string base64Image)
        {
            try
            {
                // Convert Base64 string to byte array
                byte[] imageBytes = Convert.FromBase64String(base64Image);
                // Process with IronBarcode
                var results = BarcodeReader.Read(imageBytes);
                return ProcessResults(results);
            }
            catch (Exception ex)
            {
                return BadRequest(new ScanResult
                {
                    Success = false,
                    ErrorMessage = $"Invalid Base64 data: {ex.Message}"
                });
            }
        }
        private ScanResult ProcessResults(BarcodeResults results)
        {
            if (results.Any())
            {
                return new ScanResult
                {
                    Success = true,
                    BarcodeValues = results.Select(r => r.Value).ToList(),
                    BarcodeFormat = results.First().BarcodeType.ToString()
                };
            }
            return new ScanResult
            {
                Success = false,
                ErrorMessage = "No barcodes detected"
            };
        }
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Ce contrôleur fournit deux points de terminaison : un pour les téléchargements de fichiers et un autre pour les images encodées en Base64. Le point de terminaison ScanFile accepte les données de formulaire en plusieurs parties, ce qui le rend parfait pour les applications web où les utilisateurs téléchargent directement des images. Le traitement des flux garantit une utilisation efficace de la mémoire, tandis que la configuration BarcodeReaderOptions équilibre vitesse et précision.

Le point de terminaison ScanBase64 gère les scénarios où les images sont transmises en tant que chaînes Base64, standard dans les applications mobiles et les communications API-à-API. Il est capable de lire des codes-barres 1D et 2D (matrice) à partir d'images ou de flux téléchargés.

Quelles différentes sources d'entrée le scanner peut-il gérer ?

La flexibilité d'IronBarcode brille lors du traitement de divers formats d'entrée. Au-delà des images standard, l'API de scanner gère les PDF, les flux de téléchargement, et plusieurs formats graphiques :

// Scanning PDFs with multiple pages
[HttpPost("scan-pdf")]
public async Task<ActionResult<ScanResult>> ScanPdf(IFormFile pdfFile
{
    using var stream = new MemoryStream();
    await pdfFile.CopyToAsync(stream);
    // ReadPdf method handles multi-page documents
    var results = BarcodeReader.ReadPdf(stream.ToArray());
    return ProcessResults(results);
}
// Processing from URL
[HttpPost("scan-url")]
public async Task<ActionResult<ScanResult>> ScanFromUrl([FromBody] string imageUrl)
{
    using var client = new HttpClient();
    var imageBytes = await client.GetByteArrayAsync(imageUrl);
    var results = BarcodeReader.Read(imageBytes);
    return ProcessResults(results);
}

// Scanning PDFs with multiple pages
[HttpPost("scan-pdf")]
public async Task<ActionResult<ScanResult>> ScanPdf(IFormFile pdfFile
{
    using var stream = new MemoryStream();
    await pdfFile.CopyToAsync(stream);
    // ReadPdf method handles multi-page documents
    var results = BarcodeReader.ReadPdf(stream.ToArray());
    return ProcessResults(results);
}
// Processing from URL
[HttpPost("scan-url")]
public async Task<ActionResult<ScanResult>> ScanFromUrl([FromBody] string imageUrl)
{
    using var client = new HttpClient();
    var imageBytes = await client.GetByteArrayAsync(imageUrl);
    var results = BarcodeReader.Read(imageBytes);
    return ProcessResults(results);
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

La méthode ReadPdf scanne automatiquement toutes les pages d'un document PDF, extrayant des codes-barres d'étiquettes d'expédition, de factures, ou de rapports multi-pages. Pour le scan basé sur URL, l'API récupère des images distantes et les traite sans nécessiter de stockage local, idéal pour une intégration avec des services de stockage cloud ou le traitement d'images de systèmes externes.

Maintenant, vous pourrez voir la UI Swagger mise à jour avec nos nouveaux points de terminaison :

Pour tester nos nouvelles méthodes, j'ai utilisé notre exemple de PDF qui contient deux codes-barres d'exemple.

Le premier est un code-barres basique avec une URL, et le second est le code-barres encodé de chaîne basique de notre dernier exemple. Voici le résultat de l'exécution de notre PDF par l'intermédiaire du point de terminaison :

Comme vous pouvez le voir, il a correctement détecté les deux codes-barres et extrait les données des codes-barres scannés.

Optimisation du Scanner de Codes-Barres pour la Performance et la Précision

Le réglage fin du scanner pour des cas d'utilisation spécifiques améliore considérablement la vitesse et la précision :

var optimizedOptions = new BarcodeReaderOptions
{
    // Speed settings: Faster, Balanced, Detailed, ExtremeDetail
    Speed = ReadingSpeed.Detailed,
    // Specify expected barcode types to reduce processing time
    ExpectBarcodeTypes = BarcodeEncoding.QRCode | BarcodeEncoding.Code128,
    // Enable parallel processing for batch operations
    Multithreaded = true,
    MaxParallelThreads = 4,
    // Define scanning area to focus on specific regions
    CropArea = new Rectangle(100, 100, 400, 200), // Optional: define specific scanning area
    // Apply image corrections for damaged barcodes
    ImageFilters = new ImageFilterCollection() { 
        new SharpenFilter(),
        new ContrastFilter() 
    }
};

var optimizedOptions = new BarcodeReaderOptions
{
    // Speed settings: Faster, Balanced, Detailed, ExtremeDetail
    Speed = ReadingSpeed.Detailed,
    // Specify expected barcode types to reduce processing time
    ExpectBarcodeTypes = BarcodeEncoding.QRCode | BarcodeEncoding.Code128,
    // Enable parallel processing for batch operations
    Multithreaded = true,
    MaxParallelThreads = 4,
    // Define scanning area to focus on specific regions
    CropArea = new Rectangle(100, 100, 400, 200), // Optional: define specific scanning area
    // Apply image corrections for damaged barcodes
    ImageFilters = new ImageFilterCollection() { 
        new SharpenFilter(),
        new ContrastFilter() 
    }
};

IRON VB CONVERTER ERROR developers@ironsoftware.com

Note : La propriété CropArea permet au scanner de se concentrer sur une région spécifique de matrice ou de tableau dans l'image. Cependant, certains objets ou emplacements de codes-barres peuvent se trouver en dehors de la zone définie, ce qui entraîne un échec du scanner. Si cela se produit, supprimez simplement ou commentez la propriété CropArea. IronBarcode identifiera alors et décodera toutes les données de codes-barres dans l'image pleine par défaut, garantissant que le scanner est capable de gérer n'importe quel scénario d'exécution Windows ou Microsoft.

L'utilisation d'options optimisées pour des types de scanners connus réduit le temps de traitement. Les filtres d'image intégrés améliorent la lisibilité des codes-barres scannés pour les entrées de basse qualité. Les développeurs peuvent configurer le SDK de scanner, énumérer les scanners disponibles et intégrer des composants d'interface utilisateur ou des dispositifs de capture vidéo.

Résumé

Construire une API de scanner C# avec IronBarcode transforme le traitement complexe des codes-barres en points de terminaison REST simples. La bibliothèque gère tout, des codes-barres numériques parfaits aux captures réelles difficiles, offrant une précision de niveau entreprise sans dépendance matérielle.

Avec le support de multiples formats d'entrée, la correction d'image avancée, et des paramètres de performance optimisés, les développeurs peuvent déployer des solutions de scanning prêtes pour la production en quelques minutes. Get started with a free trial to implement your scanner API today, or explore the complete documentation complète pour des fonctionnalités avancées telles que le traitement par lots et la détection alimentée par l'apprentissage automatique.