COMPARAISON

Choisir une bibliothèque de génération de documents pour .NET 8

Spire.Office etIron Suitesont tous deux des bundles perpétuels par développeur avec un an de mises à jour, donc une décision d'achat en face-à-face se résume souvent à deux questions : quelle licence couvre réellement votre forme de déploiement, et à quel prix publié ? Les bundles Spire.Office comprennent douze bibliothèques E-iceblue aux noms de niveaux publics (Développeur Petite Entreprise, Développeur OEM, Site Petite Entreprise, Site OEM), mais les chiffres exacts en USD se trouvent derrière le contact avec les ventes, et SaaS, Docker, et tout déploiement public sont confinés au niveau OEM.Iron Suiteregroupe dix produitsIron Softwareen cinq niveaux tarifaires publics à partir de $2,998, libre de droits pour les sièges licenciés, avec un supplément de redistribution pour SaaS et OEM plutôt qu'un niveau supérieur verrouillé.

Cette comparaison commence avec ce sur quoi une décision d'achat axée sur l'approvisionnement se suspend réellement : comment chaque suite est tarifée, comment sa licence gère le déploiement SaaS et Docker, et ce qui est réellement inclus. Les détails des capacités et du code suivent ci-dessous pour les ingénieurs qui vont le mettre en œuvre.

Comparaison en un coup d'œil

Dimension Spire.Office for .NET Iron Suite
Positionnement tarifaire Noms de niveaux publics (Développeur/Site, Petite Entreprise/OEM); chiffres exacts en USD non crawlables Lite $2,998 / Plus $4,498 / Professional $8,998 / Unlimited $17,998 (Enterprise custom). Les 10 produits pour le prix de 2, économisez 75 %
Modèle de licence Perpétuel par développeur avec 1 an de mises à jour gratuites ; les niveaux restreignent SaaS/Docker à OEM ; " Free Spire " niveau avec plafonds par document Perpétuel par développeur; libre de droits pour les sièges licenciés; SaaS/OEM via module complémentaire de redistribution
Composants dans le bundle 12 bibliothèques (Doc, XLS, Feuille de calcul, Présentation, PDF, Exportation de données, Visionneuse Office, Visionneuse PDF, Visionneuse de documents, Barcode, OCR, Email) 10 products (IronPDF, IronWord, IronXL, IronPPT, IronOCR, IronBarcode, IronQR, IronPrint, IronZIP, IronWebScraper)
Couverture de format/capacité DOCX/XLSX/PPTX/PDF + Email + Code-barres + OCR + visionneuses incluses PDF, Office, OCR, Code-barres/QR, ZIP, Impression, Web Scraping
Multi-plateforme / cloud Windows, Linux, macOS, Docker (Docker/SaaS seulement au niveau OEM) Windows, Linux, macOS, Docker, Azure, AWS Lambda
Support d'exécution .NET .NET Framework 4.0/4.8, .NET 6, .NET 9, .NET 10 .NET Framework 4.6.2+, .NET Core, .NET 6/7/8/9/10
Marché cible Développeurs .NET PME et marché intermédiaire ; budget-conscious teams Développeurs indépendants, PME, équipes .NET de taille moyenne, ISV
Fournisseur E-iceblue Co., Ltd. Iron Software

Les prix des niveaux Spire.Office ne sont pas publiquement listés (les pages d'achat renvoient 403 à l'extraction) ; Free Spire existe en tant que niveau gratuit plafonné par document.Iron SuiteLite coûte $2,998 par développeur, avec l'ensemble complet de dix produits et des prix publics en USD pour chaque niveau payant. La décision penche sur le fait de savoir si la forte fidélité de conversion de DOCX/XLSX/PPTX de Spire pèse plus que le mouvement de contact avec les ventes contre le modèle perpétuel à prix publié d'Iron Suite.

Tarification et licences

Spire.Office offre des licences perpétuelles par développeur avec un an de mises à jour gratuites. La structure de niveau publique est bien connue (Un développeur Petite Entreprise, Un développeur OEM, Un site Petite Entreprise, Un site OEM) et le niveau OEM est requis pour tout déploiement vers SaaS, sites web publics, Docker ou applications cloud. Les chiffres exacts en USD pour les niveaux actuels de Spire.Office ne sont pas crawlables à partir des pages d'achat de e-iceblue ; les prix sont mieux obtenus directement auprès du fournisseur ou via des canaux de revendeur. Une tranche " Free Spire " existe avec des plafonds de fonctionnalités par document.

Iron Suite est vendu comme une licence perpétuelle unique par développeur à cinq niveaux de tarification (Lite, Plus, Professional, Unlimited, et Enterprise) à partir de $2,998, avec le positionnement marketing de "tous les 10 produits pour le prix de 2, économisez 75 %." La licence de base est libre de droits pour les sièges, emplacements ou projets licenciés, et pour le SaaS, l'OEM ou la redistribution distribuée au-delà de la licence de base, un supplément de redistribution est utilisé au lieu de verrouiller le SaaS dans un niveau OEM plus coûteux.

Les acheteurs à l'aise avec un mouvement de contact-ventes pour la tarification et un chemin OEM-géré pour le déploiement SaaS/Docker vont vers Spire.Office. Les acheteurs qui veulent des chiffres USD sur chaque niveau public et un Add-On de Redistribution unique pour l'extension SaaS/OEM vont vers Iron Suite.

Qu'est-ce que Spire.Office for .NET

Spire.Office for .NET est le bundle master d'E-iceblue Co., Ltd., un fournisseur de composants basé en Chine avec une forte fidélité de conversion DOC/XLSX/PDF. La suite agrège douze bibliothèques Spire dans une seule licence, et les mêmes moteurs sont également livrés en tant que packages autonomes (Spire.Doc, Spire.XLS, Spire.PDF, etc.). Spire.Office est positionnée pour les équipes .NET des PME et mid-market cherchant une alternative à Aspose à un point de prix sensiblement inférieur, avec une tranche " Free Spire " qui permet aux développeurs de livrer de petits projets sans coût de licence (sous réserve de plafonds de fonctionnalités par document). Le méta-paquet NuGet 11.4.0, sorti le 30 avril 2026, cible .NET Framework 4.0/4.8 et le moderne .NET 6/9/10.

Composants et capacités clés regroupés :

  • Spire.Doc : création, conversion et édition de Word DOCX/DOC
  • Spire.XLS : moteur Excel XLSX avec recalcul de formule et exportation PDF
  • Spire.PDF : création, édition, et manipulation de PDF
  • Spire.Presentation : soutien pour les fichiers PPTX de PowerPoint
  • Spire.Barcode + Spire.OCR : pile de reconnaissance intégrée au bundle
  • Spire.Email + Spire.DataExport + Spire.OfficeViewer/PDFViewer/DocViewer: adjacent tooling rounding out the suite

Qu'est-ce qu'Iron Suite

Iron Suite est le bundle de dix produits .NET d'Iron Software où la pile Office (IronWord pour DOCX, IronXL pour XLSX avec recalcul de formule, IronPPT pour PPTX) se situe aux côtés d'IronPDF pour la génération et la manipulation de PDF, la pile de reconnaissance (IronOCR, IronBarcode, IronQR) pour le travail OCR et code-barres, et trois bibliothèques utilitaires (IronPrint, IronZIP, IronWebScraper) pour l'impression, les archives et l'extraction. Vendu comme une licence perpétuelle unique par développeur à cinq niveaux de tarification (Lite, Plus, Professional, Unlimited, Enterprise) à partir de $2,998. Libre de droits pour les sièges sous licence. Les redistributions SaaS et OEM utilisent un module complémentaire de redistribution distinct.

Les dix composants, regroupés par pertinence pour un workflow programmatique Office et PDF :

  • Pile Office (ancre) : IronWord (DOCX avec graphiques d'objets de paragraphe et d'exécution de texte qui se mappent directement au OOXML, avec styles personnalisés, polices, en-têtes, pieds de page, tableaux, et extraction de contenu) ; IronXL (XLSX avec recalcul de formule, création de graphiques dans les catégories zone, barre, colonne, lignes, secteur et dispersion, tableaux croisés dynamiques, mise en forme conditionnelle, validation des données) ; IronPPT (création, édition, conversion et extraction de contenu PPTX).
  • Génération de PDF (IronPDF) : rendu HTML-en-PDF et URL-en-PDF avec Chromium intégré, fusion et fractionnement natifs via PdfDocument.Merge, signature PKCS#12 plus HSM plus TSA, PDF/A-1 à PDF/A-4, PDF/UA-1 et PDF/UA-2, chiffrement, remplissage et aplatissement d'AcroForm, gestion des polices, rasterisation, compression et linéarisation.
  • Reconnaissance : IronOCR (Tesseract 5, 125+ langues, écriture manuscrite à ~90 % anglais) ; IronBarcode (30+ symbologies); IronQR (alimenté par ML avec lot ReadPdfs).
  • Utilitaire : IronPrint (impression silencieuse et avec dialogue) ; IronZIP (ZIP/TAR/GZIP/BZIP2 with AES); IronWebScraper (grattage structuré en processus).

Comparaison de capacités

Traitement de texte

La conversion DOCX en PDF est une charge de travail phare de Spire, et l'API a été affinée au fil des années pour une fidélité accrue. IronWord vise une charge de travail quotidienne similaire mais avec une API moderne orientée objet-graphe.

// Spire.Doc converts and edits Word documents without Office installed.
// NuGet: Install-Package Spire.Office
using Spire.Doc;

class Program
{
    static void Main()
    {
        Document doc = new Document();
        doc.LoadFromFile("contract.docx");
        doc.SaveToFile("contract.pdf", FileFormat.PDF);
        doc.Close();
    }
}
// Spire.Doc converts and edits Word documents without Office installed.
// NuGet: Install-Package Spire.Office
using Spire.Doc;

class Program
{
    static void Main()
    {
        Document doc = new Document();
        doc.LoadFromFile("contract.docx");
        doc.SaveToFile("contract.pdf", FileFormat.PDF);
        doc.Close();
    }
}
Imports Spire.Doc

Class Program
    Shared Sub Main()
        Dim doc As New Document()
        doc.LoadFromFile("contract.docx")
        doc.SaveToFile("contract.pdf", FileFormat.PDF)
        doc.Close()
    End Sub
End Class
$vbLabelText   $csharpLabel
// NuGet: Install-Package IronWord
using IronWord;
using IronWord.Models;

class Program
{
    static void Main()
    {
        var doc = new WordDocument();
        var heading = new Paragraph();
        heading.AddChild(new TextRun("Quarterly Report — Q1 2026") { FontSize = 18, Bold = true });
        doc.AddParagraph(heading);

        var body = new Paragraph();
        body.AddChild(new TextRun("Revenue grew 14% quarter-over-quarter."));
        doc.AddParagraph(body);

        doc.SaveAs("report.docx");
    }
}
// NuGet: Install-Package IronWord
using IronWord;
using IronWord.Models;

class Program
{
    static void Main()
    {
        var doc = new WordDocument();
        var heading = new Paragraph();
        heading.AddChild(new TextRun("Quarterly Report — Q1 2026") { FontSize = 18, Bold = true });
        doc.AddParagraph(heading);

        var body = new Paragraph();
        body.AddChild(new TextRun("Revenue grew 14% quarter-over-quarter."));
        doc.AddParagraph(body);

        doc.SaveAs("report.docx");
    }
}
Imports IronWord
Imports IronWord.Models

Class Program
    Shared Sub Main()
        Dim doc As New WordDocument()
        Dim heading As New Paragraph()
        heading.AddChild(New TextRun("Quarterly Report — Q1 2026") With {.FontSize = 18, .Bold = True})
        doc.AddParagraph(heading)

        Dim body As New Paragraph()
        body.AddChild(New TextRun("Revenue grew 14% quarter-over-quarter."))
        doc.AddParagraph(body)

        doc.SaveAs("report.docx")
    End Sub
End Class
$vbLabelText   $csharpLabel

La convention SaveToFile de Spire.Doc est cohérente dans tous les produits Spire (Spire.XLS, Spire.PDF, Spire.Presentation utilisent tous le même modèle), ce qui rend la suite prévisible mais stylistiquement datée. Le graphique d'objet paragraphe/exécution de texte d'IronWord correspond directement à la structure OOXML et se lit comme du C# moderne. L'aller-retour pur de DOCX en PDF avec une forte fidélité sur les cas limites de l'ancien format est une des zones dans laquelle Spire a investi — pour la génération de DOCX axée sur le code, IronWord nécessite moins de formalités.

Traitement Excel

Les deux suites couvrent la charge de travail Excel quotidienne (créer ou charger des fichiers XLSX, écrire des données, recalculer des formules, exporter en PDF) et disposent toutes deux d'un moteur de calcul puissant.

// Spire.XLS handles XLSX read/write, formula recalculation, and PDF export.
using Spire.Xls;

class Program
{
    static void Main()
    {
        Workbook book = new Workbook();
        book.LoadFromFile("financials.xlsx");
        book.CalculateAllValue();
        book.ConverterSetting.SheetFitToPage = true;
        book.SaveToFile("financials.pdf", FileFormat.PDF);
    }
}
// Spire.XLS handles XLSX read/write, formula recalculation, and PDF export.
using Spire.Xls;

class Program
{
    static void Main()
    {
        Workbook book = new Workbook();
        book.LoadFromFile("financials.xlsx");
        book.CalculateAllValue();
        book.ConverterSetting.SheetFitToPage = true;
        book.SaveToFile("financials.pdf", FileFormat.PDF);
    }
}
Imports Spire.Xls

Class Program
    Shared Sub Main()
        Dim book As New Workbook()
        book.LoadFromFile("financials.xlsx")
        book.CalculateAllValue()
        book.ConverterSetting.SheetFitToPage = True
        book.SaveToFile("financials.pdf", FileFormat.PDF)
    End Sub
End Class
$vbLabelText   $csharpLabel
// NuGet: Install-Package IronXL.Excel
using IronXL;

class Program
{
    static void Main()
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet sheet = workbook.CreateWorkSheet("Sales");

        sheet["A1"].Value = "Product";
        sheet["B1"].Value = "Units";
        sheet["A2"].Value = "Widget A";
        sheet["B2"].Value = 1024;
        sheet["A3"].Value = "Widget B";
        sheet["B3"].Value = 768;
        sheet["B4"].Formula = "=SUM(B2:B3)";

        workbook.EvaluateAll();
        workbook.SaveAs("sales.xlsx");
    }
}
// NuGet: Install-Package IronXL.Excel
using IronXL;

class Program
{
    static void Main()
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet sheet = workbook.CreateWorkSheet("Sales");

        sheet["A1"].Value = "Product";
        sheet["B1"].Value = "Units";
        sheet["A2"].Value = "Widget A";
        sheet["B2"].Value = 1024;
        sheet["A3"].Value = "Widget B";
        sheet["B3"].Value = 768;
        sheet["B4"].Formula = "=SUM(B2:B3)";

        workbook.EvaluateAll();
        workbook.SaveAs("sales.xlsx");
    }
}
Imports IronXL

Module Program
    Sub Main()
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim sheet As WorkSheet = workbook.CreateWorkSheet("Sales")

        sheet("A1").Value = "Product"
        sheet("B1").Value = "Units"
        sheet("A2").Value = "Widget A"
        sheet("B2").Value = 1024
        sheet("A3").Value = "Widget B"
        sheet("B3").Value = 768
        sheet("B4").Formula = "=SUM(B2:B3)"

        workbook.EvaluateAll()
        workbook.SaveAs("sales.xlsx")
    End Sub
End Module
$vbLabelText   $csharpLabel

Les book.CalculateAllValue() + SheetFitToPage de Spire.XLS lui donnent un flux fort du classeur existant → PDF poli. L'accès aux cellules de style indexeur de IronXL (sheet["A1"].Value = …, sheet["B4"].Formula = …, workbook.EvaluateAll()) se rapproche plus du .NET de l'ère LINQ quotidien et est ce que la plupart des développeurs privilégient pour générer un fichier XLSX depuis le début. Les deux moteurs gèrent la surface des formules communes — la fidélité de la conversion de classeur existant complexe (caprices de l'ancien format XLS, gestion des objets graphiques) est une des zones dans laquelle Spire a continué à investir.

Génération de PDF

Le PDF est là où le style de l'API diverge le plus. Spire.PDF construit des documents primitivement par primitives sur une toile de page, en superposant texte, images et formes via PdfPageBase.Canvas. IronPDF rend le même contenu à partir de HTML en utilisant un véritable moteur Chrome.

// Spire.PDF builds PDFs primitive-by-primitive on a page canvas.
using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;

class Program
{
    static void Main()
    {
        PdfDocument pdf = new PdfDocument();
        PdfPageBase page = pdf.Pages.Add();

        PdfTrueTypeFont titleFont = new PdfTrueTypeFont(new Font("Arial", 20f, FontStyle.Bold), true);
        page.Canvas.DrawString("Statement of Account", titleFont, PdfBrushes.Black, 50, 50);

        PdfTrueTypeFont body = new PdfTrueTypeFont(new Font("Arial", 11f), true);
        page.Canvas.DrawString("Generated 2026-05-26", body, PdfBrushes.DarkSlateGray, 50, 90);

        pdf.SaveToFile("statement.pdf");
        pdf.Close();
    }
}
// Spire.PDF builds PDFs primitive-by-primitive on a page canvas.
using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;

class Program
{
    static void Main()
    {
        PdfDocument pdf = new PdfDocument();
        PdfPageBase page = pdf.Pages.Add();

        PdfTrueTypeFont titleFont = new PdfTrueTypeFont(new Font("Arial", 20f, FontStyle.Bold), true);
        page.Canvas.DrawString("Statement of Account", titleFont, PdfBrushes.Black, 50, 50);

        PdfTrueTypeFont body = new PdfTrueTypeFont(new Font("Arial", 11f), true);
        page.Canvas.DrawString("Generated 2026-05-26", body, PdfBrushes.DarkSlateGray, 50, 90);

        pdf.SaveToFile("statement.pdf");
        pdf.Close();
    }
}
Imports Spire.Pdf
Imports Spire.Pdf.Graphics
Imports System.Drawing

Class Program
    Shared Sub Main()
        Dim pdf As New PdfDocument()
        Dim page As PdfPageBase = pdf.Pages.Add()

        Dim titleFont As New PdfTrueTypeFont(New Font("Arial", 20.0F, FontStyle.Bold), True)
        page.Canvas.DrawString("Statement of Account", titleFont, PdfBrushes.Black, 50, 50)

        Dim body As New PdfTrueTypeFont(New Font("Arial", 11.0F), True)
        page.Canvas.DrawString("Generated 2026-05-26", body, PdfBrushes.DarkSlateGray, 50, 90)

        pdf.SaveToFile("statement.pdf")
        pdf.Close()
    End Sub
End Class
$vbLabelText   $csharpLabel
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = @"<h1>Invoice 2026-0428</h1><p>Customer: Acme Corp</p><p>Total due: $1,240.00</p>";
        using var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("invoice.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = @"<h1>Invoice 2026-0428</h1><p>Customer: Acme Corp</p><p>Total due: $1,240.00</p>";
        using var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("invoice.pdf");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html As String = "<h1>Invoice 2026-0428</h1><p>Customer: Acme Corp</p><p>Total due: $1,240.00</p>"
        Using pdf = renderer.RenderHtmlAsPdf(html)
            pdf.SaveAs("invoice.pdf")
        End Using
    End Sub
End Class
$vbLabelText   $csharpLabel

Spire.PDF est le bon choix lorsque vous avez besoin d'un placement pixel-précis des primitives sur une page existante (formulaires, estampillage, rédaction). IronPDF est le bon choix lorsque le PDF provient de données d'application web : le même HTML/CSS qui se rend dans le navigateur devient le PDF, y compris le CSS moderne, les polices web, SVG, et le contenu rendu par JavaScript.

Traitement PowerPoint

La conversion de PowerPoint en PDF est un point fort de Spire à l'intérieur de la suite.Iron Suiteinclut IronPPT pour la génération et la manipulation de PowerPoint, bien que la référenceIron Suitepositionne IronPPT davantage comme un produit axé sur la création plutôt qu'un moteur de conversion à haute fidélité.

// Spire.Presentation reads/writes PPTX and exports to PDF or image without PowerPoint installed.
using Spire.Presentation;

class Program
{
    static void Main()
    {
        Presentation pres = new Presentation();
        pres.LoadFromFile("kickoff-deck.pptx");
        pres.SaveToFile("kickoff-deck.pdf", FileFormat.PDF);
        pres.Dispose();
    }
}
// Spire.Presentation reads/writes PPTX and exports to PDF or image without PowerPoint installed.
using Spire.Presentation;

class Program
{
    static void Main()
    {
        Presentation pres = new Presentation();
        pres.LoadFromFile("kickoff-deck.pptx");
        pres.SaveToFile("kickoff-deck.pdf", FileFormat.PDF);
        pres.Dispose();
    }
}
Imports Spire.Presentation

Class Program
    Shared Sub Main()
        Dim pres As New Presentation()
        pres.LoadFromFile("kickoff-deck.pptx")
        pres.SaveToFile("kickoff-deck.pdf", FileFormat.PDF)
        pres.Dispose()
    End Sub
End Class
$vbLabelText   $csharpLabel
// NuGet: Install-Package IronPPT
// Docs: https://ironsoftware.com/csharp/ppt/docs/
using IronPPT;
using IronPPT.Models;

class Program
{
    static void Main()
    {
        // PresentationDocument is the entry point for PPTX creation in IronPPT.
        // No Microsoft PowerPoint or Office Interop required.
        PresentationDocument document = new PresentationDocument();

        Slide titleSlide = new Slide();
        titleSlide.AddText("Quarterly Update");
        document.AddSlide(titleSlide);

        Slide bodySlide = new Slide();
        bodySlide.AddText("Generated from .NET, no PowerPoint dependency.");
        document.AddSlide(bodySlide);

        document.Save("update.pptx");
    }
}
// NuGet: Install-Package IronPPT
// Docs: https://ironsoftware.com/csharp/ppt/docs/
using IronPPT;
using IronPPT.Models;

class Program
{
    static void Main()
    {
        // PresentationDocument is the entry point for PPTX creation in IronPPT.
        // No Microsoft PowerPoint or Office Interop required.
        PresentationDocument document = new PresentationDocument();

        Slide titleSlide = new Slide();
        titleSlide.AddText("Quarterly Update");
        document.AddSlide(titleSlide);

        Slide bodySlide = new Slide();
        bodySlide.AddText("Generated from .NET, no PowerPoint dependency.");
        document.AddSlide(bodySlide);

        document.Save("update.pptx");
    }
}
Imports IronPPT
Imports IronPPT.Models

Module Program
    Sub Main()
        ' PresentationDocument is the entry point for PPTX creation in IronPPT.
        ' No Microsoft PowerPoint or Office Interop required.
        Dim document As New PresentationDocument()

        Dim titleSlide As New Slide()
        titleSlide.AddText("Quarterly Update")
        document.AddSlide(titleSlide)

        Dim bodySlide As New Slide()
        bodySlide.AddText("Generated from .NET, no PowerPoint dependency.")
        document.AddSlide(bodySlide)

        document.Save("update.pptx")
    End Sub
End Module
$vbLabelText   $csharpLabel

Le modèle de chargement/enregistrement de Spire.Presentation correspond au reste de la famille Spire et couvre la conversion en PDF et en image avec un investissement continu dans la fidélité au modèle de diapositives, au thème, et au SmartArt. IronPPT couvre la création de PowerPoint et la surface de manipulation courante (diapositives, texte, images, formes de base) — la conversion à haute fidélité de présentations tierces existantes avec la préservation des thèmes et des animations profondes est un domaine dans lequel le moteur de Spire a progressé.

Génération et lecture de code-barres

Les deux suites proposent la génération et la lecture de codes-barres. Iron répartit la charge de travail entre IronBarcode (1D/2D) et IronQR (spécifique QR), offrant aux équipes un chemin dédié pour les flux de travail axés sur QR. L'extrait ci-dessous de Spire démontre la génération ; l'extrait d'IronBarcode démontre le chemin de lecture.

// Spire.Barcode generates and decodes 1D/2D symbologies; bundled into Spire.Office.
using Spire.Barcode;

class Program
{
    static void Main()
    {
        BarcodeSettings settings = new BarcodeSettings
        {
            Type = BarCodeType.QRCode,
            Data = "https://example.com/inv/2026-44213",
            Data2D = "https://example.com/inv/2026-44213",
            X = 1.5f
        };

        BarCodeGenerator generator = new BarCodeGenerator(settings);
        System.Drawing.Image image = generator.GenerateImage();
        image.Save("invoice-qr.png");
    }
}
// Spire.Barcode generates and decodes 1D/2D symbologies; bundled into Spire.Office.
using Spire.Barcode;

class Program
{
    static void Main()
    {
        BarcodeSettings settings = new BarcodeSettings
        {
            Type = BarCodeType.QRCode,
            Data = "https://example.com/inv/2026-44213",
            Data2D = "https://example.com/inv/2026-44213",
            X = 1.5f
        };

        BarCodeGenerator generator = new BarCodeGenerator(settings);
        System.Drawing.Image image = generator.GenerateImage();
        image.Save("invoice-qr.png");
    }
}
Imports Spire.Barcode
Imports System.Drawing

Class Program
    Shared Sub Main()
        Dim settings As New BarcodeSettings With {
            .Type = BarCodeType.QRCode,
            .Data = "https://example.com/inv/2026-44213",
            .Data2D = "https://example.com/inv/2026-44213",
            .X = 1.5F
        }

        Dim generator As New BarCodeGenerator(settings)
        Dim image As Image = generator.GenerateImage()
        image.Save("invoice-qr.png")
    End Sub
End Class
$vbLabelText   $csharpLabel
// NuGet: Install-Package IronBarcode
using IronBarCode;

class Program
{
    static void Main()
    {
        var results = BarcodeReader.Read("shipment-label.png");
        foreach (var barcode in results)
        {
            Console.WriteLine($"Value: {barcode.Value}");
            Console.WriteLine($"Format: {barcode.BarcodeType}");
        }
    }
}
// NuGet: Install-Package IronBarcode
using IronBarCode;

class Program
{
    static void Main()
    {
        var results = BarcodeReader.Read("shipment-label.png");
        foreach (var barcode in results)
        {
            Console.WriteLine($"Value: {barcode.Value}");
            Console.WriteLine($"Format: {barcode.BarcodeType}");
        }
    }
}
Imports IronBarCode

Class Program
    Shared Sub Main()
        Dim results = BarcodeReader.Read("shipment-label.png")
        For Each barcode In results
            Console.WriteLine($"Value: {barcode.Value}")
            Console.WriteLine($"Format: {barcode.BarcodeType}")
        Next
    End Sub
End Class
$vbLabelText   $csharpLabel

Spire.Barcode regroupe 1D/2D et QR en un seul générateur basé sur les paramètres, qui est concis mais nécessite de lire la documentation des paramètres pour découvrir toutes les options disponibles. IronBarcode + IronQR fournissent des points d'entrée dédiés (BarcodeReader.Read, BarcodeWriter, plus un lecteur/écrivain spécifique QR dans IronQR) qui s'autocomplètent plus proprement dans l'IDE.

Pourquoi choisirIron Suitepour l'automatisation de documents .NET axée sur le code

ChoisissezIron Suitelorsque le SaaS, Docker, et le déploiement à visibilité publique doivent être couverts par la licence de base plutôt que d'être verrouillés derrière un niveau OEM. Les APIs de Iron se lisent comme un .NET moderne orienté code, les dix produits partagent un style cohérent sur l'ensemble, et la tarification est publique et perpétuelle à cinq niveaux de tarification à partir de $2,998. Bords structurels qui importent pour l'automatisation des documents quotidiens de .NET :

  • Tarification perpétuelle transparente avec des chiffres en USD à chaque niveau
  • SaaS, Docker, et déploiement à visibilité publique ne sont pas verrouillés au niveau OEM: la licence de base couvre les sièges sous licence, et un seul add-on de redistribution couvre les scénarios de redistribution
  • Déploiement libre de droits pour les sièges sous licence, pas de frais d'exécution, pas de comptage par document
  • Surface API .NET orientée code pour les 10 produits, sans modèles d'héritage SaveToFile à apprendre
  • Création et reconnaissance (PDF/Word/Excel/PPT + OCR/Barcode/QR) dans une seule suite
  • Génération de PDF axée sur HTML avec fidélité complète au navigateur

CommentIron Suiteest différent de Spire.Office

  • Tarification publique en USD à chaque niveau. Les pages d'achat de Spire sont verrouillées contre le scraping et la tarification nécessite de contacter le service commercial ; Iron publie un chiffre pour chaque niveau.
  • SaaS / Docker / déploiement à visibilité publique sont dans le territoire de la licence de base chez Iron (avec l'add-on de distribution comme SKU distinct propre). Spire restreint ces formes de déploiement au niveau OEM, une marche de prix plus nette pour toute application déployée sur le web.
  • Cohérence API à travers les produits. Les dix produits d'Iron partagent une nomenclature et une structure idiomatiques de .NET ; Les APIs de Spire sont utiles mais variables à travers les composants (Spire.DataExport vs Spire.Spreadsheet vs Spire.Doc chacun se sent légèrement différent).
  • Reconnaissance + scraping + ZIP + impression + QR. IronWebScraper, IronZIP, et IronPrint se trouvent du côté Iron sans équivalent Spire ; IronQR est une bibliothèque QR dédiée distincte d'IronBarcode.
  • Génération de PDF axée sur HTML avec une véritable fidélité au navigateur par rapport à l'API de toile de page primitive de Spire.PDF.
  • Modèle d'enregistrement de licence unique par rapport au configureur de licences par espace de noms et aux formes de déploiement verrouillées OEM de Spire.

Conclusion

Spire.Office est une alternative Aspose ancienne et compétente, abordable, dont les cartes les plus fortes sont la fidélité de conversion DOCX/XLSX/PPTX en PDF et un tremplin "Free Spire" généreux.Iron Suiteest une suite structurellement plus simple dont les cartes les plus fortes sont la clarté des licences, la tarification perpétuelle transparente, une surface API axée sur le code de .NET idiomatique sur tous les dix produits, et un ensemble création-plus-reconnaissance qui ne verrouille pas le SaaS ou Docker derrière un niveau OEM. Les équipes dont le besoin principal est la fidélité de conversion pour les documents Office existants trouveront le moteur de Spire excellent. Les équipes dont le besoin principal est une licence perpétuelle unique couvrant PDF, Office, OCR, Barcode/QR, et les outils adjacents, sans contacter le service commercial pour un prix, trouverontIron Suitela solution la plus propre. Découvrez Iron Suite, y compris le niveau d'entrée $2,998, sur ironsoftware.com/csharp/suite.

Veuillez noterSpire.Office est une marque déposée de son propriétaire respectif. Ce site n'est pas affilié à, approuvé par, ou sponsorisé par Spire.Office. 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.