Chaque développeur qui a utilisé Aspose.BarCode a écrit une version de cette ligne : new BarCodeReader(path, DecodeType.Code128). Cela fonctionne parfaitement lorsque vous connaissez le format de l'image. Lorsque vous ne le faites pas — quand un document provient d'un système externe, d'un fournisseur qui a changé le format de ses étiquettes ou d'un téléchargement utilisateur — vous devinez soit une liste de types de décodage, soit vous vous tournez vers DecodeType.AllSupportedTypes, qui est généralement plus lent selon les propres conseils d'Aspose. L'exigence de spécification de format n'est pas un obstacle insurmontable, mais elle représente une friction quotidienne qui s'accumule à chaque opération de lecture dans votre base de code.
L'histoire du PDF, c'est l'histoire du budget. Si vous traitez des codes-barres à partir de documents PDF, Aspose.BarCode ne peut pas le faire seul. Vous avez besoin d'Aspose.PDF for .NET pour d'abord rendre les pages en images. Aspose.PDF est un produit d'abonnement séparé en plus de ce que vous payez déjà pour Aspose.BarCode. Deux abonnements pour un flux de travail que la plupart des développeurs considèrent comme une seule tâche.
IronBarcode détecte automatiquement le format des codes-barres, lit nativement les fichiers PDF dans un seul package et propose une licence perpétuelle à partir de 749 $. Ce comparatif examine les deux bibliothèques en détail afin de vous permettre de faire un choix éclairé.
Aspose développe depuis des années des bibliothèques de traitement de documents pour .NET, Java et d'autres plateformes. Aspose.BarCode est l'un des nombreux produits de la famille, aux côtés d'Aspose.Words, Aspose.Cells, Aspose.PDF, Aspose.Slides et d'une douzaine d'autres. Pour les équipes qui paient déjà Aspose.Total (l'offre groupée regroupant tous les produits Aspose), Aspose.BarCode est inclus sans surcoût. En revanche, pour celles qui n'ont besoin que d'une bibliothèque de codes-barres, le modèle d'abonnement est plus difficile à justifier.
Aspose.BarCode prend en charge plus de 80 symbologies de code-barres, l'une des listes de formats les plus complètes dans toute bibliothèque commerciale de code-barres .NET. Cette diversité est le principal atout de la bibliothèque. La surface de l'API est par conséquent importante, et sa verbosité augmente avec les fonctionnalités. Générer un code à barres Code 128 de base nécessite d'instancier un BarcodeGenerator, de régler XDimension, BarHeight, et d'autres paramètres, puis d'appeler Save avec un argument de format explicite. La lecture nécessite de spécifier quels types de décodage rechercher, puis d'itérer les résultats renvoyés par ReadBarCodes(). Les deux opérations fonctionnent correctement, elles sont simplement plus verbeuses qu'elles ne devraient l'être.
Principales caractéristiques architecturales d'Aspose.BarCode :
DecodeType explicitement. Le recours DecodeType.AllSupportedTypes est généralement plus lent qu'une liste ciblée parce que le décodeur passe en revue tous les symboles connus séquentiellement.BarCodeReader et BarcodeGenerator sont des objets instanciés qui implémentent IDisposable. Ils doivent être enveloppés dans des blocs using pour libérer les ressources natives.generator.Parameters.Barcode.* — une hiérarchie d'objets multi-niveaux qui nécessite une mémorisation..lic accessible à un chemin connu, ce qui ajoute une étape de déploiement pour les environnements Dockeret Kubernetes.L'API de lecture d'Aspose.BarCode repose sur l'hypothèse que l'appelant connaît le format du code-barres :
using Aspose.BarCode.BarCodeRecognition;
var reader = new BarCodeReader("barcode.png", DecodeType.Code128);
foreach (var result in reader.ReadBarCodes())
Console.WriteLine($"{result.CodeTypeName}: {result.CodeText}");Imports Aspose.BarCode.BarCodeRecognition
Dim reader As New BarCodeReader("barcode.png", DecodeType.Code128)
For Each result In reader.ReadBarCodes()
Console.WriteLine($"{result.CodeTypeName}: {result.CodeText}")
NextLorsque le format est connu, ce modèle convient parfaitement. Le problème, c'est que même en connaissant le format, un système d'achat traitant les factures fournisseurs ne peut garantir que chaque fournisseur utilise le même type de code-barres. Un système de gestion de documents qui accepte les téléchargements des utilisateurs ne peut pas prédire le format utilisé par un scanner. Dans ces cas, DecodeType.AllSupportedTypes est le recours, et il est généralement plus lent qu'une liste de types de décodage ciblée.
Le décodeur doit également être mis au rebut :
using var reader = new BarCodeReader("barcode.png", DecodeType.Code128);netNe pas utiliser using est une fuite de ressources. Le BarcodeGenerator implémente également IDisposable, bien que les conséquences de ne pas le libérer soient moins graves. Dans les deux cas, vous gérez la durée de vie des objets, ce qu'une API de fabrique statique gérerait automatiquement.
IronBarcode utilise des méthodes de fabrique statiques pour la lecture et l'écriture. Il n'y a aucune instance à construire, configurer ou supprimer. L'API de lecture est indépendante du format par défaut, et le même appel fonctionne que le fichier source soit un PNG, un JPEG, un TIFF ou un PDF.
IronBarcode est développé et maintenu par Iron Software, une entreprise axée sur les outils de développement .NET. La bibliothèque est conçue selon le principe que la lecture des codes-barres ne doit pas nécessiter de connaissance préalable du format du code-barres ; le moteur de détection de la bibliothèque détermine le format à partir du contenu de l'image. Pour la génération, une chaîne de méthodes fluide remplace la hiérarchie de paramètres à plusieurs niveaux courante dans d'autres bibliothèques.
Caractéristiques principales d' IronBarcode:
BarcodeReader.Read() identifie la symbologie du code-barres à partir du contenu de l'image sans exiger que l'appelant spécifie un équivalent DecodeType.BarcodeReader.Read("doc.pdf") lit directement à partir des fichiers PDF sans package supplémentaire ni étape de rendu. Les résultats incluent result.PageNumber.BarcodeWriter.CreateBarcode() renvoie un objet enchaînable. La personnalisation utilise l'enchaînement de méthodes plutôt qu'une hiérarchie de propriétés.IronBarCode.License.LicenseKey, compatible avec les variables d'environnement et les gestionnaires de secrets CI/CD.| Fonction | Aspose.BarCode | Code-barres IronBarcode |
|---|---|---|
| Détection de format | Manuelle — doit spécifier DecodeType ou utiliser AllSupportedTypes lent | Automatique pour tous les formats pris en charge |
| Nombre de symboles | 80+ | 50 ans et plus |
| Prise en charge des fichiers PDF | Aucune prise en charge native — nécessite une licence Aspose.PDF distincte | Native — BarcodeReader.Read("doc.pdf") intégré au package |
| Modèle de tarification | Abonnement uniquement - niveaux annuels à partir de $999/an | Perpétuel à partir de 749 $ (paiement unique) |
| Licence perpétuelle | Non disponible | Oui, tous les niveaux |
| Style API | Configuration détaillée basée sur les instances | Méthodes de fabrique statiques, API fluide |
| Exigence jetable | Oui — BarCodeReader et BarcodeGenerator | Non — méthodes statiques sans état |
| Sécurité des threads | Instances distinctes requises par thread | API statique - voir la documentation d'IronBarcode pour les conseils sur les threads |
| Fonction | Aspose.BarCode | Code-barres IronBarcode |
|---|---|---|
| Génération | ||
| style API | new BarcodeGenerator(EncodeTypes.X, "data") | BarcodeWriter.CreateBarcode("data", BarcodeEncoding.X) |
| Modèle de personnalisation | hiérarchie de propriété generator.Parameters.Barcode.* | Chaîne de méthode fluide (.ResizeTo(), .ChangeBarCodeColor()) |
| Code QR avec logo | Superposition manuelle GDI+ après génération | .AddBrandLogo("logo.png") intégré |
| Sortie en octets | generator.GenerateBarCodeImage() | .ToPngBinaryData() |
| Codes-barres colorés | generator.Parameters.Barcode.BarColor | .ChangeBarCodeColor(Color.X) |
| En lisant | ||
| Spécification du format | Requis (DecodeType) | Non requis — automatique |
| Solution de repli en cas de format inconnu | DecodeType.AllSupportedTypes (lent) | Même appel – aucun mode de repli nécessaire |
| Optimisation des performances | Ensemble de paramètres QualitySettings | ReadingSpeed enum — trois niveaux |
| Lecteur jetable | Oui — using var reader = new BarCodeReader(...) | Non — appel statique, aucun objet à supprimer |
| Accès aux résultats | Itérer reader.ReadBarCodes() | Valeur de retour de BarcodeReader.Read() |
| propriété de valeur du code-barres | result.CodeText | result.Value |
| Nom du format propriété | result.CodeTypeName | result.Format.ToString() |
| Prise en charge des fichiers PDF | ||
| Lecture native de PDF | Non | Oui |
| Requis pour le PDF | Aspose.PDF (abonnement séparé) | Aucun forfait supplémentaire |
| Numéro de page dans les résultats | N/A | result.PageNumber |
| Licence | ||
| Modèle de licence | Abonnement uniquement, renouvelable annuellement | Achat perpétuel et unique |
| Développeur unique | 999 $/an | 749 $ (une seule fois) |
| 10 développeurs | 4 995 $/an (Licence de site) | 2 999 $ (paiement unique) (Professional) |
| Déploiements illimités (10 développeurs) | $13,986/an (OEM sur site) | 5 999 $ en une seule fois (illimité) |
| Prise en charge des fichiers PDF incluse | Non — abonnement Aspose.PDF séparé | Oui |
| Plateforme et déploiement | ||
| Activation de la licence | chemin de fichier .lic | Clé de chaîne — variable d'environnement |
| Déploiement de Docker | Doit copier le fichier .lic dans l'image ou le monter | Variable d'environnement — aucun fichier requis |
| .NET Framework | Oui | Oui (4.6.2+) |
| .NET Core / .NET 5+ | Oui | Oui (.NET Core 3.1+, .NET 5/6/7/8) |
| Fenêtres | Oui | Oui (x64/x86) |
| Linux | Oui | Oui (x64) |
| macOS | Oui | Oui (x64/ARM) |
| Docker | Oui | Oui |
| Azure / AWS Lambda | Oui | Oui |
C'est au niveau de l'API de génération que la différence de verbosité entre les deux bibliothèques est la plus visible dans le code courant.
Aspose.BarCode utilise une classe BarcodeGenerator avec une hiérarchie Parameters pour la configuration. Un appel de génération minimal nécessite trois étapes : l'instanciation, l'appel de sauvegarde et la spécification du format. L'utilisation réelle nécessite généralement de naviguer dans generator.Parameters.Barcode.*:
using Aspose.BarCode.Generation;
using System.Drawing;
var generator = new BarcodeGenerator(EncodeTypes.Code128, "ITEM-12345");
// Common customizations require navigating a deep parameter hierarchy
generator.Parameters.Barcode.XDimension.Pixels = 2;
generator.Parameters.Barcode.BarHeight.Pixels = 100;
generator.Parameters.Barcode.CodeTextParameters.Location = CodeLocation.Below;
generator.Parameters.Barcode.CodeTextParameters.Font.FamilyName = "Arial";
generator.Parameters.Barcode.Padding.Left.Pixels = 10;
generator.Parameters.Barcode.Padding.Right.Pixels = 10;
generator.Parameters.BackColor = Color.White;
generator.Parameters.Resolution = 300;
generator.Save("barcode.png", BarCodeImageFormat.Png);Imports Aspose.BarCode.Generation
Imports System.Drawing
Dim generator As New BarcodeGenerator(EncodeTypes.Code128, "ITEM-12345")
' Common customizations require navigating a deep parameter hierarchy
generator.Parameters.Barcode.XDimension.Pixels = 2
generator.Parameters.Barcode.BarHeight.Pixels = 100
generator.Parameters.Barcode.CodeTextParameters.Location = CodeLocation.Below
generator.Parameters.Barcode.CodeTextParameters.Font.FamilyName = "Arial"
generator.Parameters.Barcode.Padding.Left.Pixels = 10
generator.Parameters.Barcode.Padding.Right.Pixels = 10
generator.Parameters.BackColor = Color.White
generator.Parameters.Resolution = 300
generator.Save("barcode.png", BarCodeImageFormat.Png)Chaque personnalisation navigue dans generator.Parameters.Barcode.*, qui est une hiérarchie d'objets multi-niveaux. Ce n'est pas complexe une fois qu'on l'a mémorisé — mais cela nécessite de le mémoriser.
IronBarcode remplace la hiérarchie des paramètres par une chaîne de méthodes fluide. Les paramètres par défaut donnent des résultats corrects dans la plupart des cas d'utilisation, et la personnalisation s'effectue directement dans le code :
using IronBarCode;
// Default settings work for most cases
BarcodeWriter.CreateBarcode("ITEM-12345", BarcodeEncoding.Code128)
.SaveAsPng("barcode.png");
// Customization through a fluent chain
BarcodeWriter.CreateBarcode("ITEM-12345", BarcodeEncoding.Code128)
.ResizeTo(400, 100)
.SaveAsPng("barcode.png");
// Get as bytes instead of saving to disk
byte[] pngData = BarcodeWriter.CreateBarcode("ITEM-12345", BarcodeEncoding.Code128)
.ToPngBinaryData();Imports IronBarCode
' Default settings work for most cases
BarcodeWriter.CreateBarcode("ITEM-12345", BarcodeEncoding.Code128) _
.SaveAsPng("barcode.png")
' Customization through a fluent chain
BarcodeWriter.CreateBarcode("ITEM-12345", BarcodeEncoding.Code128) _
.ResizeTo(400, 100) _
.SaveAsPng("barcode.png")
' Get as bytes instead of saving to disk
Dim pngData As Byte() = BarcodeWriter.CreateBarcode("ITEM-12345", BarcodeEncoding.Code128) _
.ToPngBinaryData()Pour les codes QR, l'API de génération de QR codes d'IronBarcode inclut la prise en charge des logos de marque sans composition manuelle d'image :
using IronBarCode;
using IronSoftware.Drawing;
// With brand logo — built in, no manual image overlay needed
QRCodeWriter.CreateQrCode("https://example.com", 500)
.AddBrandLogo("logo.png")
.SaveAsPng("qr-branded.png");
// With high error correction (recommended when using a logo)
QRCodeWriter.CreateQrCode(
"https://example.com",
500,
QRCodeWriter.QrErrorCorrectionLevel.Highest)
.AddBrandLogo("logo.png")
.SaveAsPng("qr-branded-high-ecc.png");
// Colored QR code
QRCodeWriter.CreateQrCode("https://example.com", 300)
.ChangeBarCodeColor(Color.DarkBlue)
.SaveAsPng("qr-colored.png");Imports IronBarCode
Imports IronSoftware.Drawing
' With brand logo — built in, no manual image overlay needed
QRCodeWriter.CreateQrCode("https://example.com", 500) _
.AddBrandLogo("logo.png") _
.SaveAsPng("qr-branded.png")
' With high error correction (recommended when using a logo)
QRCodeWriter.CreateQrCode( _
"https://example.com", _
500, _
QRCodeWriter.QrErrorCorrectionLevel.Highest) _
.AddBrandLogo("logo.png") _
.SaveAsPng("qr-branded-high-ecc.png")
' Colored QR code
QRCodeWriter.CreateQrCode("https://example.com", 300) _
.ChangeBarCodeColor(Color.DarkBlue) _
.SaveAsPng("qr-colored.png")Aspose.BarCode ne propose pas d'assistant de logo de marque en un seul appel pour les QR codes; L'approche documentée consiste à générer l'image du code-barres, puis à y superposer le logo (par exemple avec System.Drawing.Graphics). Le AddBrandLogo d'IronBarcode gère le composite en un seul appel et règle automatiquement la correction d'erreur de manière appropriée.
Pour de nombreuses équipes, c'est cette comparaison qui compte le plus. La lecture des codes-barres dans les documents PDF est une opération courante : factures entrantes, étiquettes d'expédition enregistrées au format PDF, archives de documents numérisés.
Aspose.BarCode ne prend pas en charge nativement le format PDF. Pour lire un code-barres à partir d'un PDF avec Aspose, vous avez besoin d'Aspose.PDF pour charger le PDF et convertir les pages en images, et d'Aspose.BarCode pour scanner ces images. Ce sont deux produits par abonnement. Les deux nécessitent une activation de licence. Vous payez deux abonnements annuels pour ce que la plupart des développeurs considèrent comme une seule capacité.
// Requires both Aspose.PDF (separate license) and Aspose.BarCode
using Aspose.Pdf;
using Aspose.Pdf.Devices;
using Aspose.BarCode.BarCodeRecognition;
using System.IO;
public List<string> ReadBarcodesFromPdf(string pdfPath)
{
var barcodeValues = new List<string>();
// Step 1: Load and render the PDF using Aspose.PDF
var pdfDocument = new Aspose.Pdf.Document(pdfPath);
var resolution = new Resolution(300);
var device = new PngDevice(resolution);
for (int pageNum = 1; pageNum <= pdfDocument.Pages.Count; pageNum++)
{
using var pageStream = new MemoryStream();
device.Process(pdfDocument.Pages[pageNum], pageStream);
pageStream.Seek(0, SeekOrigin.Begin);
// Step 2: Scan the rendered image for barcodes using Aspose.BarCode
using var reader = new BarCodeReader(pageStream, DecodeType.AllSupportedTypes);
foreach (var result in reader.ReadBarCodes())
{
barcodeValues.Add(result.CodeText);
}
}
return barcodeValues;
}Imports Aspose.Pdf
Imports Aspose.Pdf.Devices
Imports Aspose.BarCode.BarCodeRecognition
Imports System.IO
Public Function ReadBarcodesFromPdf(pdfPath As String) As List(Of String)
Dim barcodeValues As New List(Of String)()
' Step 1: Load and render the PDF using Aspose.PDF
Dim pdfDocument As New Aspose.Pdf.Document(pdfPath)
Dim resolution As New Resolution(300)
Dim device As New PngDevice(resolution)
For pageNum As Integer = 1 To pdfDocument.Pages.Count
Using pageStream As New MemoryStream()
device.Process(pdfDocument.Pages(pageNum), pageStream)
pageStream.Seek(0, SeekOrigin.Begin)
' Step 2: Scan the rendered image for barcodes using Aspose.BarCode
Using reader As New BarCodeReader(pageStream, DecodeType.AllSupportedTypes)
For Each result In reader.ReadBarCodes()
barcodeValues.Add(result.CodeText)
Next
End Using
End Using
Next
Return barcodeValues
End FunctionCela implique deux configurations de licence, deux instructions using de deux espaces de noms, un pipeline de rendu, la gestion de flux en mémoire, et une boucle imbriquée. Il utilise également DecodeType.AllSupportedTypes car au moment de l'extraction de l'image, vous ne savez généralement pas quel format utilise le code-barres.
IronBarcode gère en interne l'analyse des fichiers PDF, le rendu des pages et la détection des codes-barres. Vous appelez Read avec un chemin se terminant par .pdf, et cela renvoie les résultats de code-barres qui incluent result.PageNumber pour que vous sachiez de quelle page chacun provient. Pas de deuxième paquet, pas de deuxième licence, pas de code de rendu.
using IronBarCode;
public List<string> ReadBarcodesFromPdf(string pdfPath)
{
var results = BarcodeReader.Read(pdfPath);
return results.Select(r => r.Value).ToList();
}Imports IronBarCode
Public Function ReadBarcodesFromPdf(pdfPath As String) As List(Of String)
Dim results = BarcodeReader.Read(pdfPath)
Return results.Select(Function(r) r.Value).ToList()
End Function// With page number context
var results = BarcodeReader.Read("invoice-batch.pdf");
foreach (var barcode in results)
{
Console.WriteLine($"Page {barcode.PageNumber}: [{barcode.Format}] {barcode.Value}");
}Imports System
' With page number context
Dim results = BarcodeReader.Read("invoice-batch.pdf")
For Each barcode In results
Console.WriteLine($"Page {barcode.PageNumber}: [{barcode.Format}] {barcode.Value}")
NextLa documentation de lecture des fichiers PDF IronBarcode couvre le traitement par lots multipages et les options de filtrage par plage de pages.
Lorsque vous ne savez pas quel format de code-barres contient une image, les deux bibliothèques gèrent la situation différemment.
DecodeType.AllSupportedTypes est la solution d'Aspose pour les scénarios de format inconnu. La documentation d'Aspose reconnaît elle-même que cette méthode est plus lente que la spécification d'une liste ciblée, car le décodeur parcourt séquentiellement chaque symbologie connue. Pour le traitement à grand volume — un entrepôt scannant des milliers d'étiquettes par minute —, cette différence de performance n'est pas négligeable.
using Aspose.BarCode.BarCodeRecognition;
using var reader = new BarCodeReader("unknown-format.png");
reader.SetBarCodeReadType(DecodeType.AllSupportedTypes);
foreach (var result in reader.ReadBarCodes())
{
Console.WriteLine($"{result.CodeTypeName}: {result.CodeText}");
}Imports Aspose.BarCode.BarCodeRecognition
Using reader As New BarCodeReader("unknown-format.png")
reader.SetBarCodeReadType(DecodeType.AllSupportedTypes)
For Each result In reader.ReadBarCodes()
Console.WriteLine($"{result.CodeTypeName}: {result.CodeText}")
Next
End UsingIl n'existe pas de " mode lent " et de " mode rapide " basés sur la connaissance du format. La détection d'IronBarcode utilise le même algorithme, que l'image contienne un Code 128 ou un DataMatrix. Si vous souhaitez ajuster les compromis entre performance et précision, l'option ReadingSpeed le fait sans nécessiter de connaissance de format:
using IronBarCode;
// The same call regardless of format — always auto-detects
var results = BarcodeReader.Read("unknown-format.png");
foreach (var result in results)
{
Console.WriteLine($"{result.Format}: {result.Value}");
}Imports IronBarCode
' The same call regardless of format — always auto-detects
Dim results = BarcodeReader.Read("unknown-format.png")
For Each result In results
Console.WriteLine($"{result.Format}: {result.Value}")
Nextusing IronBarCode;
var options = new BarcodeReaderOptions
{
Speed = ReadingSpeed.Balanced,
ExpectMultipleBarcodes = true,
MaxParallelThreads = 4
};
var results = BarcodeReader.Read("document.png", options);Imports IronBarCode
Dim options As New BarcodeReaderOptions With {
.Speed = ReadingSpeed.Balanced,
.ExpectMultipleBarcodes = True,
.MaxParallelThreads = 4
}
Dim results = BarcodeReader.Read("document.png", options)ReadingSpeed.Faster privilégie le débit. ReadingSpeed.Detailed privilégie la précision sur les images endommagées ou à faible contraste. Aucun des deux ne nécessite de connaître le format à l'avance. Consultez les options de lecture IronBarcode pour connaître l'ensemble des paramètres de réglage.
| Aspose.BarCode | Code-barres IronBarcode |
|---|---|
new BarcodeGenerator(EncodeTypes.Code128, "data") | BarcodeWriter.CreateBarcode("data", BarcodeEncoding.Code128) |
generator.Save("file.png", BarCodeImageFormat.Png) | .SaveAsPng("file.png") |
new BarCodeReader(path, DecodeType.Code128) | BarcodeReader.Read(path) |
DecodeType.AllSupportedTypes (analyse lente et exhaustive) | Automatique — toujours rapide, même appel pour tous les formats |
reader.ReadBarCodes() | (part of BarcodeReader.Read — returns results directly) |
Itération reader.ReadBarCodes() | Valeur de retour de BarcodeReader.Read |
result.CodeText | result.Value |
result.CodeTypeName | result.Format.ToString() |
result.Confidence | result.Confidence |
Aspose.BarCode + Aspose.PDF for PDF reading | BarcodeReader.Read("doc.pdf") — un package |
license.SetLicense("Aspose.BarCode.lic") | IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY" |
new Aspose.BarCode.Metered() + .SetMeteredKey() | (not needed — single key covers all environments) |
generator.GenerateBarCodeImage() | .ToPngBinaryData() ou .SaveAsPng() |
QREncodeMode.Auto + QRErrorLevel.LevelH + superposition manuelle de logo | QRCodeWriter.CreateQrCode().AddBrandLogo() |
Plusieurs scénarios incitent fréquemment les équipes de développement à évaluer Code-barres IronBarcode comme alternative à Aspose.BarCode.
Le renouvellement annuel des abonnements est le moment où les équipes réexaminent le plus souvent les décisions relatives à la bibliothèque. Si Aspose.BarCode est le seul produit Aspose dans la pile, payer $999/an par développeur (ou $4,995/an au niveau Site) pour une fonctionnalité de code-barres entraîne une comparaison. La conversation se déroule généralement ainsi : " Nous payons cela chaque année, indéfiniment. " " Combien coûte Code-barres IronBarcode une fois installé ? " Au niveau Professional (2 999 $ pour 10 développeurs), Code-barres IronBarcode est rentabilisé dès la première année grâce à la licence Site.
Pour les équipes utilisant Aspose.Total - où Aspose.BarCode est intégré avec de nombreux autres produits Aspose - le calcul est différent. Le coût marginal d'Aspose.BarCode au sein de ce pack tend vers zéro. Ces équipes ont moins de raisons de changer.
De nombreux projets commencent par la lecture de codes-barres à partir d'images, puis ajoutent la prise en charge des fichiers PDF ultérieurement, lorsqu'un acteur clé se rend compte que les documents entrants sont des PDF et non des fichiers image. À ce stade, une équipe Aspose.BarCode doit prendre une décision : ajouter Aspose.PDF (un autre abonnement), trouver un moteur de rendu PDF tiers ou réévaluer la bibliothèque de codes-barres.
Ajouter Aspose.PDF résout l'exigence immédiate mais implique un second abonnement annuel. Trouver un moteur de rendu tiers ajoute une dépendance et un effort d'intégration. Il en résulte souvent une réévaluation de la bibliothèque de codes-barres — et la découverte Code-barres IronBarcode lit nativement les PDF moyennant un paiement unique.
Les applications destinées aux clients qui acceptent le téléchargement de documents ne peuvent pas contrôler le format du code-barres utilisé par un document téléchargé. Si l'application a été conçue en supposant des entrées Code 128 et qu'un client télécharge une étiquette DataMatrix, un DecodeType.Code128 codé en dur retournera silencieusement aucun résultat. Passer à DecodeType.AllSupportedTypes corrige la justesse mais introduit un coût de performance.
Les équipes qui ont rencontré ce problème — ajoutant de plus en plus de valeurs DecodeType à leur configuration de lecteur à mesure que de nouveaux formats apparaissent en production — finissent souvent par maintenir une liste qui nécessite une mise à jour chaque fois qu'une nouvelle source de format est ajoutée. La détection automatique d'IronBarcode rend cette liste inutile.
Le système de licences basé sur des fichiers d'Aspose.BarCode ajoute une étape de déploiement : le fichier de licence doit être accessible lors de l'exécution à partir d'un chemin que l'application peut lire. Dans un flux de travail GitOps, le fichier de licence se retrouve soit dans le contrôle de version (un risque pour la sécurité), soit doit être injecté via un volume secret monté. L'approche d'IronBarcode basée sur les clés s'intègre parfaitement aux secrets Kubernetes et aux variables secrètes CI/CD, sans aucun fichier à gérer dans l'image du conteneur.
Les équipes qui passent d'Aspose.BarCode à Code-barres IronBarcode doivent effectuer un petit nombre d'ajustements techniques prévisibles.
L'erreur de compilation la plus courante après l'échange des packages est le renommage de result.CodeText en result.Value. Une recherche dans l'ensemble du code source permet de le faire rapidement :
grep -r "\.CodeText" --include="*.cs" .
grep -r "\.CodeTypeName" --include="*.cs" .result.CodeText devient result.Value. result.CodeTypeName devient result.Format.ToString(). La propriété result.Format est une valeur d'énumération BarcodeEncoding, ce qui permet également des comparaisons typées si nécessaire.
Chaque référence DecodeType.* dans la base de code peut être supprimée:
grep -r "DecodeType\." --include="*.cs" .Si un DecodeType spécifique a été listé pour améliorer les performances sur un format connu, ReadingSpeed.Faster dans BarcodeReaderOptions offre un avantage similaire sans nécessiter de connaissance du format.
Aspose.BarCode utilise un fichier .lic chargé via license.SetLicense(). Code-barres IronBarcode utilise une clé de type chaîne de caractères :
IronBarCode.License.LicenseKey =
Environment.GetEnvironmentVariable("IRONBARCODE_LICENSE")
?? throw new InvalidOperationException("IronBarcode license key not configured");Imports IronBarCode
Imports System
License.LicenseKey = If(Environment.GetEnvironmentVariable("IRONBARCODE_LICENSE"), Throw New InvalidOperationException("IronBarcode license key not configured"))Supprimer le fichier .lic du dépôt et des artefacts de construction. Dans Docker, supprimer la ligne COPY Aspose.BarCode.lic et la remplacer par une entrée ENV IRONBARCODE_LICENSE.
EncodeTypes.QR correspond à BarcodeEncoding.QRCode — la différence de nommage est là où les équipes rencontrent le plus souvent la première erreur de compilation après la migration du code de génération. La plupart des autres mappages sont des équivalents directs avec un nommage cohérent.
Au-delà des principaux points de comparaison, Code-barres IronBarcode offre des fonctionnalités qui peuvent s'avérer pertinentes selon le contexte de l'application :
ExpectMultipleBarcodes = true renvoie tous les codes-barres trouvés dans une seule image, avec les coordonnées de position pour chacun.IronBarcode prend en charge .NET Framework4.6.2+, .NET Core 3.1+, et .NET 5, 6, 7, et 8. La bibliothèque reçoit des mises à jour régulières alignées avec le calendrier de publication des versions .NET de Microsoft. Aspose.BarCode prend en charge une gamme de versions .NET comparable, donc aucune des bibliothèques ne présente un avantage de compatibilité sur les versions actuelles. La différence significative pour la préparation à l'avenir réside dans la licence : une licence Code-barres IronBarcode perpétuelle achetée aujourd'hui couvre les futures versions de .NET sans frais supplémentaires, tandis que les abonnements Aspose.BarCode nécessitent un renouvellement continu pour accéder aux versions mises à jour.
Aspose.BarCode et Code-barres IronBarcode représentent deux philosophies différentes en matière de conception de bibliothèques de codes-barres. Aspose.BarCode est construit sur une API explicite, basée sur des instances, où l'appelant spécifie le format, gère la durée de vie des objets et configure chaque opération via une hiérarchie de propriétés. Code-barres IronBarcode repose sur une API statique et indépendante du format, où la bibliothèque gère en interne la détection, le cycle de vie des objets et le rendu PDF. Aucune de ces approches n'est intrinsèquement correcte ; le bon choix dépend des besoins de l'application.
Aspose.BarCode est le choix le plus judicieux pour les équipes opérant déjà au sein de l'écosystème Aspose. Lorsque Aspose.Total est déjà sous licence, Aspose.BarCode n'ajoute aucun coût marginal, et sa liste de plus de 80 symbologies est l'une des plus larges disponibles dans toute bibliothèque commerciale de code-barres .NET. Pour les applications nécessitant des formats inhabituels (MaxiCode, DotCode ou symbologies postales spécifiques ne figurant pas dans la liste de plus de 50 d'IronBarcode), Aspose.BarCode peut être la seule option viable. Sa maturité et la diversité de ses formats sont de véritables atouts.
Pour les équipes qui évaluent Aspose.BarCode comme un achat indépendant, le calcul de la valeur est plus difficile à effectuer. L'exigence de spécification du format ajoute des difficultés à chaque opération de lecture. L'absence de prise en charge native du format PDF double le coût de l'abonnement pour une fonctionnalité Code-barres IronBarcode inclut dans son offre de base. Et le modèle d'abonnement signifie que le coût s'accumule chaque année — 4 995 $ par an pour une équipe de 10 développeurs atteignent 24 975 $ sur cinq ans, contre 2 999 $ pour un achat unique Code-barres IronBarcode Professional . La détection automatique, la lecture native des fichiers PDF et la licence perpétuelle d'IronBarcode résolvent ces trois problèmes en un seul produit.
La décision finale repose sur l'adéquation à l'écosystème et les exigences en matière de symbolisme. Les équipes profondément intégrées aux produits Aspose, ou celles qui ont besoin de formats ne figurant pas dans la liste prise en charge par IronBarcode, doivent utiliser Aspose.BarCode. Les équipes qui souhaitent une licence perpétuelle autonome, la lecture native des PDF et une API qui ne nécessite pas de connaissance du format à chaque lecture trouveront en Code-barres IronBarcode le choix le plus pratique.
Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.
IronBarcode fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin de lire, écrire, et styliser des Codes-barres, rapidement.
