IRONSOFTWAREHOME
IRONSUITETous les 10 pour le prix de 2
ÉDITION DE DOCUMENTS
IMAGERIE & RECONNAISSANCE
RESSOURCES D'APPROVISIONNEMENT
CONTACTER LES VENTES
PAR ENTREPRISE
REJOIGNEZ NOTRE RÉSEAU D'EXPERTS
VIDÉOS

Passer de Kit de développement logiciel Scandit à IronBarcode

Curtis Chau
Curtis Chau
Updated: 1 août 2026

Scandit SDK est une plateforme de numérisation par caméra conçue pour la détection de codes-barres mobiles en temps réel. Code-barres IronBarcode est une bibliothèque de traitement de codes-barres côté serveur et basée sur des fichiers pour .NET. Ces deux bibliothèques répondent à des cas d'utilisation principaux différents, et la migration de l'une à l'autre n'est pertinente que dans des circonstances spécifiques.

Ce guide décrit le processus de migration pour les équipes utilisant les packages .NET de Scandit pour traiter des fichiers, des PDF ou des flux de documents côté serveur — des scénarios où l'architecture du pipeline de caméra de Scandit crée des frictions plutôt que de la valeur. Si votre besoin principal consiste à pointer une caméra mobile vers des objets physiques et à recevoir un retour d'information en temps réel avec des superpositions de réalité augmentée, Scandit reste l'outil approprié et ce guide ne s'applique pas. Si votre besoin consiste à lire les codes-barres d'images téléchargées, à extraire des données de codes-barres de documents PDF ou à exécuter la détection de codes-barres dans ASP.NET Core, Azure Functions, des conteneurs Docker ou des services de traitement en arrière-plan, ce guide fournit un chemin de migration complet.

Pourquoi migrer depuis le SDK Scandit ?

Surcharge du pipeline de la caméra : Chaque intégration Scandit commence par la même séquence d'initialisation, que la caméra soit présente ou non dans l'environnement de déploiement : construire un DataCaptureContext, configurer BarcodeCaptureSettings, énumérer les symbologies à activer, acquérir une instance de Camera, l'assigner comme source de cadre, passer la caméra à un état actif, et activer la capture de code-barres. Cette initialisation est nécessaire car Scandit traite des images vidéo en direct. Pour le traitement des fichiers côté serveur, cette séquence n'apporte aucun avantage et introduit une complexité liée à l'état qui n'a pas d'équivalent dans l'environnement cible : il n'y a pas de caméra dans un conteneur Docker ni de source d'images dans une fonction Azure.

Pas de prix publics : Scandit ne publie pas ses tarifs. SparkScan, MatrixScan, la numérisation d'identité, les superpositions AR et Parser sont des produits vendus individuellement et nécessitent chacun une demande de renseignements commerciaux distincte. Une proposition budgétaire, une comparaison de fournisseurs ou une analyse coût-avantage ne peut être complétée sans entrer dans un cycle de vente. Code-barres IronBarcode affiche publiquement ses prix — 749 $, 1 499 $ ou 2 999 $ pour un achat perpétuel unique — de sorte que le prix figure sur la page avant même qu'une ligne de code ne soit écrite.

Déclaration obligatoire de symbologie : Scandit exige l'activation explicite de chaque format de code-barres avant le début d'une session de numérisation. En matière de numérisation par caméra en temps réel, il s'agit d'une optimisation des performances : la restriction des symbologies réduit la surcharge de traitement par image. Dans le traitement de documents basés sur des fichiers, où les documents entrants peuvent comporter n'importe quel format de code-barres provenant de n'importe quel fournisseur ou partenaire, la déclaration obligatoire du format devient une contrainte. Énumérer toutes les symbologies possibles annule le gain de performance ; Écrire une logique de devinette de format en plus de la bibliothèque ajoute une surcharge d'ingénierie.

Pas de support PDF : Il n'existe pas d'équivalent direct à BarcodeReader.Read("invoice.pdf") dans l'API Scandit. L'extraction des codes-barres d'un document PDF nécessite le rendu de chaque page en image raster à l'aide d'une bibliothèque distincte, puis le traitement de ces images par une plateforme de simulation de caméra. Cette approche engendre des dépendances supplémentaires, des licences additionnelles et un effort d'ingénierie considérable pour une tâche courante dans les flux de travail de traitement de documents.

Le problème fondamental

Scandit exige que la caméra soit en marche avant de pouvoir commencer tout traitement des codes-barres. Code-barres IronBarcode ne nécessite qu'un chemin d'accès au fichier :

// Scandit SDK: mandatory camera pipeline before first barcode read
var dataCaptureContext = DataCaptureContext.ForLicenseKey("YOUR-SCANDIT-LICENSE");
var settings = BarcodeCaptureSettings.Create();
settings.EnableSymbologies(new HashSet<Symbology>
{
    Symbology.Ean13Upca,
    Symbology.Ean8,
    Symbology.Code128,
    Symbology.QrCode
});
var barcodeCapture = BarcodeCapture.Create(dataCaptureContext, settings);
var camera = Camera.GetDefaultCamera();
await dataCaptureContext.SetFrameSourceAsync(camera);
await camera.SwitchToDesiredStateAsync(FrameSourceState.On);
barcodeCapture.IsEnabled = true;
// Results arrive later via BarcodeScanned event callback
// IronBarcode: direct file reading
// NuGet: dotnet add package IronBarcode
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";
var results = BarcodeReader.Read("barcode.png");
foreach (var result in results)
    Console.WriteLine($"{result.Value} ({result.Format})");

L'ensemble du bloc de pipeline de la caméra — création du contexte, paramètres, activation de la symbologie, acquisition de la caméra, attribution de la source d'image, transition d'état — est remplacé par une attribution de clé de licence et un seul appel de méthode.

Comparaison des fonctionnalités Code-barres IronBarcode et de Scandit SDK

FonctionKit de développement logiciel ScanditCode-barres IronBarcode
Déploiement principalnumérisation par caméra mobileserveur, cloud, traitement de fichiers de bureau
Caméra requiseOuiNon
Lecture de fichiers imageNon conçu pourType d'entrée principal
extraction de codes-barres PDFNon pris en chargePrise en charge native des pages multiples
Entrée de flux / tableau d'octetsNon pris en chargeOui
Détection automatique du formatNon (à préciser)Oui (comportement par défaut)
Résultats liés aux événementsOui (rappel BarcodeScanned)Non (retour synchrone)
ASP.NET Core / côté serveurNon conçu pourEntièrement pris en charge
Azure Functions / sans serveurPas pratiqueEntièrement pris en charge
Docker / LinuxNon pris en chargeEntièrement pris en charge
génération de codes-barresNon pris en chargeInclus dans l'emballage
Détection de plusieurs codes-barresMatrixScan (produit séparé)Inclus dans l'emballage
Modèle de tarificationContactez le service commercial (par produit)Niveaux perpétuels publiés
Frais par analyse / par appareilOuiNon

Démarrage rapide

Étape 1 : Remplacer le package NuGet

Supprimer les paquets Scandit :

dotnet remove package Scandit.BarcodePicker
dotnet remove package Scandit.DataCapture.Core
dotnet remove package Scandit.DataCapture.Barcode
SHELL

Installer IronBarcode:

dotnet add package IronBarcode
SHELL

Étape 2 : Mise à jour des espaces de noms

Remplacez les importations du namespace Scandit par celles du namespace Code-barres IronBarcode :

// Before (Scandit SDK)
using Scandit.DataCapture.Core;
using Scandit.DataCapture.Barcode;
using Scandit.DataCapture.Barcode.Data;

// After (IronBarcode)
using IronBarCode;

Étape 3 : initialisation de la licence

Ajoutez l'initialisation de licence au démarrage de l'application, en remplaçant l'appel DataCaptureContext.ForLicenseKey :

// Before (Scandit SDK)
var dataCaptureContext = DataCaptureContext.ForLicenseKey("YOUR-SCANDIT-LICENSE");

// After (IronBarcode)
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";

Exemples de migration de code

Lecture des codes-barres à partir d'un fichier image

Le traitement d'un fichier image statique est un scénario de base pris en charge par Code-barres IronBarcode et un flux de travail non pris en charge par Scandit. Le SDK Scandit traite les images de la caméra en direct ; La lecture d'un fichier nécessite d'adapter le pipeline de capture pour traiter une image bitmap comme une source d'images, ce qui ne dispose d'aucune implémentation native.

Approche du SDK Scandit :

// Kit de développement logiciel Scandit has no direct file-read API.
// Reading a static image requires constructing a bitmap frame source
// and routing it through the capture pipeline — an unsupported workaround.
// The standard Scandit integration assumes a running camera at all times.
C#

Approche IronBarcode :

// NuGet: dotnet add package IronBarcode
using IronBarCode;

IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";

var results = BarcodeReader.Read("product-label.png");
foreach (var result in results)
{
    Console.WriteLine($"Value: {result.Value}");
    Console.WriteLine($"Format: {result.Format}");
    Console.WriteLine($"Confidence: {result.Confidence}%");
}

La lecture des codes-barres à partir d'images avec Code-barres IronBarcode ne nécessite aucune configuration de pipeline. Les résultats sont disponibles immédiatement après l'exécution de la méthode, sans abonnement aux événements.

Extraction des codes-barres d'un document PDF

L'extraction de codes-barres PDF est un domaine totalement nouveau lors de la migration depuis Scandit, qui ne prend pas en charge les fichiers PDF. Code-barres IronBarcode lit directement les documents PDF et renvoie des résultats indexés par numéro de page.

Approche du SDK Scandit :

// Scandit SDK: no PDF support.
// Implementing PDF barcode extraction with Scandit requires:
// 1. A separate PDF rendering library to convert pages to raster images
// 2. Routing each rendered image through the camera simulation pipeline
// 3. Correlating results back to page numbers manually
// This is not a supported workflow and requires significant custom engineering.

Approche IronBarcode :

// NuGet: dotnet add package IronBarcode
using IronBarCode;

IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";

var results = BarcodeReader.Read("shipping-manifest.pdf");
foreach (var result in results)
{
    Console.WriteLine($"Page {result.PageNumber}: {result.Value} ({result.Format})");
}

Pour obtenir des instructions complètes sur la lecture des codes-barres dans les documents PDF , y compris la sélection de la plage de pages et la gestion de plusieurs codes-barres, la documentation Code-barres IronBarcode couvre l'ensemble des scénarios de traitement PDF. Aucune dépendance supplémentaire à une bibliothèque PDF n'est requise.

Conversion des rappels d'événements en valeurs de retour directes

Scandit transmet les résultats de code-barres via l'événement BarcodeScanned car le balayage de caméra en direct est intrinsèquement asynchrone — les résultats arrivent lorsque la caméra détecte un code-barres dans le cadre actuel. Code-barres IronBarcode renvoie les résultats sous forme de collection typée car la lecture basée sur les fichiers a une limite d'achèvement connue. Il s'agit là de l'un des changements structurels les plus importants de cette migration.

Approche du SDK Scandit :

// Scandit SDK: event-driven result delivery
barcodeCapture.BarcodeScanned += (sender, args) =>
{
    foreach (var barcode in args.Session.NewlyRecognizedBarcodes)
    {
        string value = barcode.Data;
        string symbology = barcode.Symbology.ToString();

        // Processing logic embedded inside event handler
        LogBarcodeResult(value, symbology);
        UpdateInventory(value);
    }
};

// Scan continues indefinitely until camera session is terminated

Approche IronBarcode :

// NuGet: dotnet add package IronBarcode
using IronBarCode;

IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";

var results = BarcodeReader.Read("document.png");
foreach (var result in results)
{
    // Same processing logic, now in standard control flow
    LogBarcodeResult(result.Value, result.Format.ToString());
    UpdateInventory(result.Value);
}

Toute la logique de traitement qui était intégrée aux fonctions de rappel des gestionnaires d'événements est désormais déplacée vers du code séquentiel standard. La gestion des erreurs, la journalisation et les opérations en aval peuvent être structurées à l'aide d'un flux de contrôle ordinaire plutôt que de modèles de gestionnaires d'événements.

Point de terminaison ASP.NET Core pour le téléchargement de fichiers

Un point de terminaison de serveur sans état lisant les codes-barres d'un fichier téléchargé représente le principal cas d'utilisation côté serveur d' IronBarcode. Ce modèle n'est pas pris en charge par l'architecture de pipeline de caméra de Scandit.

Approche du SDK Scandit :

// Scandit SDK: not applicable to ASP.NET Core file upload scenarios.
// The DataCaptureContext requires a camera hardware session.
// There is no mechanism to process an IFormFile through the Scandit pipeline
// without substantial custom camera-simulation infrastructure.

Approche IronBarcode :

// NuGet: dotnet add package IronBarcode
using IronBarCode;

[ApiController]
[Route("api/[controller]")]
public class BarcodeController : ControllerBase
{
    [HttpPost("scan")]
    public IActionResult ScanUploadedDocument(IFormFile file)
    {
        if (file == null || file.Length == 0)
            return BadRequest("No file provided");

        using var stream = file.OpenReadStream();
        var results = BarcodeReader.Read(stream);

        if (!results.Any())
            return NotFound("No barcodes detected");

        return Ok(results.Select(r => new
        {
            r.Value,
            Format = r.Format.ToString(),
            r.PageNumber
        }));
    }
}

La méthode BarcodeReader.Read accepte un Stream directement depuis IFormFile.OpenReadStream(), sans nécessiter de création de fichier temporaire. Les résultats sont renvoyés de manière synchrone au sein du cycle requête-réponse, sans gestion asynchrone de la caméra.

Traitement par lots simultané de plusieurs documents

Les files d'attente de documents à volume élevé nécessitent un traitement parallèle sur plusieurs threads. Parce que l'API de Code-barres IronBarcode est sans état, elle est intrinsèquement sûre pour les threads et se compose directement avec Parallel.ForEach et les motifs de tâches asynchrones.

Approche du SDK Scandit :

// Scandit SDK: no supported batch file processing pattern.
// The FrameSourceState model assumes a continuous camera session,
// not a queue of discrete documents. Batch processing would require
// one camera simulation pipeline per document or serialized processing
// through a shared pipeline — neither is a supported workflow.

Approche IronBarcode :

// NuGet: dotnet add package IronBarcode
using IronBarCode;
using System.Collections.Concurrent;

IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";

var options = new BarcodeReaderOptions
{
    Speed = ReadingSpeed.Balanced,
    ExpectMultipleBarcodes = true,
    MaxParallelThreads = 4
};

var files = Directory.GetFiles("./documents/", "*.pdf");
var allResults = new ConcurrentBag<(string File, BarcodeResult Result)>();

Parallel.ForEach(files, file =>
{
    var results = BarcodeReader.Read(file, options);
    foreach (var result in results)
        allResults.Add((file, result));
});

foreach (var (file, result) in allResults)
    Console.WriteLine($"{Path.GetFileName(file)}: {result.Value} ({result.Format})");

Pour les modèles avancés couvrant la lecture asynchrone et multithread des codes-barres , y compris l'optimisation du débit et la configuration du nombre de threads, la documentation Code-barres IronBarcode fournit des instructions détaillées.

Référence de mappage de l'API du SDK Scandit vers IronBarcode

Kit de développement logiciel ScanditCode-barres IronBarcodeNotes
DataCaptureContext.ForLicenseKey("key")IronBarCode.License.LicenseKey = "key"Une mission ; pas d'objet contextuel
BarcodeCaptureSettings.Create()new BarcodeReaderOptions()Facultatif; non requis pour une lecture de base
settings.EnableSymbologies(Symbology.Code128, ...)(not needed)Code-barres IronBarcode détecte automatiquement tous les formats
Camera.GetDefaultCamera()(not applicable)Concept sans caméra
dataCaptureContext.SetFrameSourceAsync(camera)(not applicable)Aucune source d'image
camera.SwitchToDesiredStateAsync(FrameSourceState.On)(not applicable)Machine à états sans caméra
barcodeCapture.IsEnabled = trueBarcodeReader.Read(path)Un seul appel déclenche la lecture
Gestionnaire d'événement BarcodeScanned +=Standard foreach sur la valeur de retourAucun système d'événements n'est nécessaire.
args.Session.NewlyRecognizedBarcodesValeur de retour de BarcodeReader.Read()Collecte directe
barcode.Dataresult.ValueMême contenu sémantique
barcode.Symbologyresult.FormatÉnumération au format équivalent
using Scandit.DataCapture.Coreusing IronBarCodeespace de noms unique
using Scandit.DataCapture.Barcodeusing IronBarCodeInclus dans le même espace de noms
Produit SparkScanBarcodeReader.Read(path)Aucun produit supplémentaire requis
Produit MatrixScanBarcodeReaderOptions { ExpectMultipleBarcodes = true }Inclus dans le forfait de base

Problèmes de migration courants et solutions

Problème 1 : Le code du pipeline de la caméra n'a pas de traduction directe

Scandit SDK : Le bloc de configuration DataCaptureContext, BarcodeCaptureSettings, Camera, et BarcodeCapture s'étend sur 7 à 10 lignes de code d'initialisation avec des transitions d'état asynchrones.

Solution : Ce bloc est entièrement supprimé. Il n'a pas d'équivalent à Code-barres IronBarcode car l'API d'IronBarcode, basée sur des fichiers, ne nécessite aucune initialisation de session. Remplacez tout le bloc par :

IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";

Problème 2 : Logique du gestionnaire d'événements BarcodeScanned

Scandit SDK : La logique de traitement est intégrée dans les gestionnaires d'événements lambdas ou méthodes BarcodeScanned +=. Ce modèle n'existe pas dans IronBarcode.

Solution : Déplacez le corps du gestionnaire dans le code standard suivant l'appel BarcodeReader.Read :

// Before: event handler
barcodeCapture.BarcodeScanned += (s, args) =>
{
    foreach (var b in args.Session.NewlyRecognizedBarcodes)
        Console.WriteLine(b.Data);
};

// After: direct iteration
foreach (var result in BarcodeReader.Read("document.png"))
    Console.WriteLine(result.Value);

Problème n° 3 : Appels EnableSymbologies dispersés dans le code source

Scandit SDK : Plusieurs endroits dans la base de code peuvent appeler settings.EnableSymbologies(...) avec différents ensembles de symbologies pour différents contextes de balayage.

Solution : Supprimez tous les appels EnableSymbologies. Code-barres IronBarcode détecte automatiquement tous les formats pris en charge par défaut. Si une restriction de format est nécessaire pour la performance dans des scénarios spécifiques, utilisez BarcodeReaderOptions.ExpectBarcodeTypes :

var options = new BarcodeReaderOptions
{
    ExpectBarcodeTypes = BarcodeEncoding.Code128 | BarcodeEncoding.QRCode
};
var results = BarcodeReader.Read("document.png", options);

Problème n° 4 : Absence de lecture de fichiers PDF dans le code source existant

Kit de développement logiciel Scandit : Si le code source existant convertit les pages PDF en images avant de les intégrer au pipeline Scandit, cette infrastructure de rendu personnalisée n'est plus nécessaire.

Solution : Supprimer complètement l'étape de rendu PDF-image. Transmettez directement le chemin du PDF à IronBarcode:

// Before: render PDF pages to images, then pass each image to Scandit pipeline
// (multiple steps, external PDF library dependency)

// After: pass PDF directly to IronBarcode
var results = BarcodeReader.Read("document.pdf");
// Results include PageNumber property for each detected barcode

Problème 5 : Modèles d'initialisation asynchrone de la caméra

Scandit SDK : L'initialisation de la caméra utilise await pour SetFrameSourceAsync et SwitchToDesiredStateAsync. Si le code appelant est structuré autour de ces opérations asynchrones, leur suppression simplifie la chaîne asynchrone.

Solution : Supprimer complètement l'initialisation asynchrone de la caméra. BarcodeReader.Read est synchrone. Si une exécution asynchrone est nécessaire pour la réactivité dans un contexte d'interface utilisateur ou de serveur, enveloppez-la dans Task.Run :

// Async wrapper for non-blocking execution
var results = await Task.Run(() => BarcodeReader.Read("document.png"));

Liste de contrôle de migration du SDK Scandit

Tâches préalables à la migration

Auditez tous les points d'intégration Scandit dans le code source :

grep -r "DataCaptureContext\|BarcodeCaptureSettings\|BarcodeCapture" --include="*.cs" .
grep -r "EnableSymbologies\|BarcodeScanned\|NewlyRecognizedBarcodes" --include="*.cs" .
grep -r "using Scandit" --include="*.cs" .
grep -r "barcode\.Data\|barcode\.Symbology\|FrameSourceState" --include="*.cs" .
SHELL

Documentez tous les contextes de numérisation — identifiez les chemins de code qui gèrent la numérisation par caméra en temps réel (en restant sur Scandit) par rapport au traitement des fichiers ou des documents (en migrant vers IronBarcode). Veuillez noter tous les endroits où les pages PDF sont converties en images avant le traitement Scandit, car cette étape de conversion sera éliminée.

Tâches de mise à jour du code

  1. Supprimez les paquets NuGet Scandit (Scandit.BarcodePicker, Scandit.DataCapture.Core, Scandit.DataCapture.Barcode)
  2. Installez le paquet NuGet IronBarcode
  3. Remplacez les importations using Scandit.DataCapture.* par using IronBarCode
  4. Supprimez entièrement le bloc d'initialisation DataCaptureContext
  5. Supprimez tous les appels Camera.GetDefaultCamera() et SetFrameSourceAsync
  6. Supprimez tous les appels EnableSymbologies
  7. Remplacez barcodeCapture.IsEnabled = true par BarcodeReader.Read(filePath)
  8. Convertissez les gestionnaires d'événements BarcodeScanned += en foreach sur les résultats BarcodeReader.Read()
  9. Remplacez barcode.Data par result.Value
  10. Remplacez barcode.Symbology par result.Format
  11. Supprimer les chaînes de rendu PDF-image, car Code-barres IronBarcode lit désormais directement les PDF.
  12. Ajoutez IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY" au démarrage de l'application

Test de post-migration

Après avoir effectué les mises à jour du code, veuillez vérifier les points suivants :

  • Vérifier que les valeurs des codes-barres renvoyées par Code-barres IronBarcode correspondent aux valeurs précédemment renvoyées par Scandit pour les mêmes documents d'entrée.
  • Vérifiez que tous les formats de code-barres pris en charge dans le jeu de documents sont détectés sans configuration ExpectBarcodeTypes
  • Testez que l'extraction PDF renvoie les valeurs PageNumber correctes pour les documents multi-pages
  • Vérifier que les points de terminaison ASP.NET Core renvoient des résultats dans des délais de réponse acceptables sous la charge prévue.
  • Vérifier que les déploiements Docker ou conteneurisés effectuent correctement la lecture des codes-barres sans matériel de caméra.
  • Vérifiez que le traitement par lots concurrent avec Parallel.ForEach produit des résultats corrects sans conditions de concurrence
  • Vérifiez que l'application démarre et s'initialise correctement avec la clé de licence Code-barres IronBarcode à la place du contexte Scandit

Principaux avantages de la migration vers IronBarcode

Élimination de la surcharge du pipeline de la caméra : La suppression de la séquence d'initialisation DataCaptureContext élimine la gestion de caméra avec état, les transitions d'état asynchrones et les API de caméra spécifiques à la plateforme du code côté serveur. Le code résultant est plus simple, plus court et ne comporte pas de contraintes de plateforme empêchant le déploiement sur Linux, dans des conteneurs Docker ou dans des environnements de calcul sans serveur.

Traitement direct des PDF : l'extraction native des codes-barres PDF supprime la dépendance à une bibliothèque de rendu PDF distincte, les frais d'ingénierie liés au pipeline page-image et les coûts de licence supplémentaires associés à cette dépendance. Les documents PDF multipages sont traités en un seul appel de méthode, les résultats indexés par page étant disponibles immédiatement.

API synchrone sans état : le modèle de valeur de retour directe remplace les modèles de rappel pilotés par les événements par du code séquentiel standard. La gestion des erreurs, la journalisation et le traitement en aval s'intègrent naturellement à l'architecture applicative existante sans nécessiter de gestion des abonnements aux événements ni de coordination de machines à états asynchrones.

Tarification transparente et publiée : les niveaux de licence perpétuelle affichés publiquement à 749 $, 1 499 $ et 2 999 $ permettent aux propositions budgétaires, aux comparaisons de fournisseurs et aux processus d'approvisionnement de se dérouler sans cycle de vente. Le coût de la licence est déterminable avant même d'écrire une seule ligne de code d'intégration.

Prise en charge complète du cloud et des conteneurs : l'API sans état et indépendante du matériel d'IronBarcode s'exécute sans modification dans Azure Functions, AWS Lambda, les conteneurs Docker sous Linux et tout autre environnement de calcul où le runtime .NET est disponible. Aucune simulation de caméra, aucun contournement des dépendances matérielles et aucune configuration spécifique à la plateforme ne sont requis pour le déploiement dans ces environnements.

Détection automatique du format : Supprimer les déclarations EnableSymbologies signifie que les documents entrants portant des formats de code-barres inattendus sont traités correctement sans modifications de code. Lorsque l'ensemble des formats présents dans les documents entrants change (nouveaux fournisseurs, nouveaux formats d'étiquettes, nouveaux types de documents), Code-barres IronBarcode gère automatiquement les nouveaux formats.

Veuillez noter: Scandit est une marque déposée de son propriétaire respectif. Ce site n'est pas affilié ni approuvé par Scandit. Tous les noms de produits, logos et marques sont la propriété de leurs propriétaires respectifs. Les comparaisons sont à titre informatif uniquement et reflètent les informations publiquement disponibles au moment de l'écriture.
Curtis Chau
Curtis Chau
Rédacteur technique

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.

...
Lire la suite

Articles connexes

Key in blue circle

Obtenez votre clé d'essai de 30 jours instantanément.

Your trial license will be sent to your email address

Aucune restriction. 100 % débloqué. Pas de carte bancaire.

bullet_checkedAucune carte de crédit ou création de compte requiseAucune restriction. 100 % débloqué. Pas de carte bancaire.
  • Logo Aetna
  • Logo NASA
  • Logo GE
  • Logo Porsche
  • Logo USDA
  • Logo Qatar
Join Millions of Engineers who’ve tried IronPDF
Réservez votre Démonstration en direct gratuite
Booking Badge

De confiance par des millions d'ingénieurs dans le monde entier

Logos des clients d'Iron Software
Obtenez Votre Consultation sans Engagement
Remplissez le formulaire ci-dessous ou envoyez un email à sales@ironsoftware.com
Vos informations seront toujours gardées confidentielles.
De confiance par des millions d'ingénieurs dans le monde entier
Logos des clients d'Iron Software
Obtenez votre clé d'essai 30 jours gratuitement.
Aucune carte de crédit ou création de compte requise