VERGLEICH

Auswahl einer Dokumentenerstellungsbibliothek für .NET 8

Spire.Office undIron Suitesind beide unbefristete Entwickler-Bundles mit einem Jahr Updates, sodass eine nebeneinanderliegende Beschaffungsentscheidung oft auf zwei Fragen beruht: Welche Lizenz deckt Ihre Bereitstellungsform tatsächlich ab und zu welchem veröffentlichten Preis? Spire.Office bündelt zwölf E-iceblue-Bibliotheken bei öffentlichen Stufennamen (Entwickler KMU, Entwickler OEM, Standort KMU, Standort OEM), aber exakte USD-Zahlen sitzen hinter dem Verkaufskontakt, und SaaS, Docker und jede öffentlich zugängliche Bereitstellung sind auf die OEM-Stufe beschränkt.Iron Suitebündelt zehn Iron Software-Produkte in fünf öffentlich bepreisten Stufen ab $2,998, gebührenfrei für lizenzierte Plätze, mit einem Weiterverbreitungs-Add-On für SaaS und OEM anstelle einer höheren gesperrten Stufe.

Dieser Vergleich beginnt mit dem, worauf eine beschaffungsorientierte Entscheidung tatsächlich basiert: Wie jede Suite bepreist ist, wie ihre Lizenz SaaS- und Docker-Bereitstellungen handhabt und was tatsächlich in der Box ist. Die Fähigkeitsdetails und der Code folgen unten für die Ingenieure, die es ausliefern.

Vergleich auf einen Blick

Dimension Spire.Office for .NET Iron Suite
Preispolitische Positionierung Öffentliche Stufennamen (Entwickler/Standort, KMU/OEM); exakte USD-Zahlen nicht crawlbar Lite $2,998 / Plus $4,498 / Professional $8,998 / Unlimited $17,998 (Enterprise custom). Alle 10 Produkte zum Preis von 2, 75% sparen
Lizenzmodell Unbefristete Per-Entwickler-Lizenz mit 1 Jahr kostenlose Updates; Stufen schränken SaaS/Docker auf OEM ein; "Kostenloses Spire"-Stufe mit Dokument-Caps Unbefristete pro Entwickler; gebührenfrei für lizenzierte Sitze; SaaS/OEM über Weiterverbreitungs-Add-On
Komponenten im Paket 12 Bibliotheken (Doc, XLS, Tabellenkalkulation, Präsentation, PDF, DataExport, OfficeViewer, PDFViewer, DocViewer, Barcode, OCR, E-Mail) 10 products (IronPDF, IronWord, IronXL, IronPPT, IronOCR, IronBarcode, IronQR, IronPrint, IronZIP, IronWebScraper)
Format- / Fähigkeitsabdeckung DOCX/XLSX/PPTX/PDF + E-Mail + Barcode + OCR + gebündelte Betrachter PDF, Office, OCR, Barcode/QR, ZIP, Print, Web Scraping
Plattformübergreifend / Cloud Windows, Linux, macOS, Docker (Docker/SaaS nur in der OEM-Stufe) Windows, Linux, macOS, Docker, Azure, AWS Lambda
.NET-Laufzeitunterstützung .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
Zielmarkt SMB und mittelständische .NET-Entwickler; budget-conscious teams Unabhängige Entwickler, kleine und mittlere Unternehmen, mittlere Märkte .NET-Teams, ISVs
Anbieter E-iceblue Co., Ltd. Iron Software

Spire.Office-Stufenpreise werden nicht öffentlich gelistet (Buy/Seiten retouren 403 zum Scraping); Kostenloses Spire existiert als pro-Dokument-begrenzte freie Stufe.Iron SuiteLite kostet $2,998 pro Entwickler, mit dem vollständigen Zehn-Produkt-Bundle und öffentlicher USD-Bepreisung in jeder bezahlten Stufe. Die Entscheidung neigt sich darauf, ob Spires starke DOCX/XLSX/PPTX-Konvertierungstreue den Kauf-gegen-Verkauf Beweg gegen Iron Suites veröffentlichten Preis unbefristetes Modell überwiegt.

Preis- und Lizenzierungsbedingungen

Spire.Office bietet unbefristete Entwickler-Lizenzierung mit einem Jahr kostenloser Updates. Die öffentliche Stufenstruktur ist bekannt (Ein Entwickler KMU, Ein Entwickler OEM, Eine Seite KMU, Eine Seite OEM) und die OEM-Stufe ist für jede Bereitstellung zu SaaS, öffentlich zugänglichen Websites, Docker oder Cloud-basierten Anwendungen erforderlich. Exakte USD-Zahlen für die aktuellen Spire.Office-Ebenen sind auf den Buy/Seiten von e-iceblue nicht crawlbar; Preise werden am besten direkt vom Anbieter oder über Wiederverkäuferkanäle bezogen. Eine "Kostenloses Spire"-Stufe existiert mit pro-Dokument funktionsbegrenzungen.

Iron Suite wird als eine einzelne unbefristete per-Entwickler-Lizenz in fünf Stufen (Lite, Plus, Professional, Unlimited und Enterprise) ab $2,998 verkauft, mit der Marketingpositionierung "alle 10 Produkte zum Preis von 2, sparen Sie 75%". Die Basislizenz ist gebührenfrei für die lizenzierten Plätze, Standorte oder Projekte, und für SaaS, OEM oder verteilte Weiterverbreitung über die Basislizenz hinaus wird ein einzelnes, separat bepreistes Redistribution Add-On verwendet, anstatt SaaS in eine teurere OEM-Stufe zu sperren.

Käufer, die sich mit einem Kaufvertriebskontakt für Preisgestaltung und einen OEM-gated Weg für SaaS/Docker-Bereitstellung wohlfühlen, gehen zu Spire.Office. Käufer, die USD-Nummern auf jeder öffentlichen Stufe und ein einziges Weiterverbreitungs-Add-On für SaaS/OEM-Erweiterungen haben möchten, gehen zu Iron Suite.

What is Spire.Office for .NET

Spire.Office for .NET ist das Master-Bundle von E-iceblue Co., Ltd., einem in China ansässigen Komponenten-Anbieter mit starker DOC/XLSX/PDF-Konvertierungstreue. Das Paket aggregiert zwölf Spire-Bibliotheken in einer einzigen Lizenz und dieselben Engines werden auch als eigenständige Pakete geliefert (Spire.Doc, Spire.XLS, Spire.PDF, etc.). Spire.Office ist für KMU und mittelständische .NET-Teams positioniert, die nach einer preisgünstigeren Alternative zu Aspose suchen, mit einer "Kostenloses Spire"-Stufe, die Entwicklern ermöglicht, kleine Projekte ohne Lizenzkosten zu versenden (vorbehaltlich pro-Dokument-Funktionslimits). Das 11.4.0 NuGet-Metapaket, veröffentlicht am 30. April 2026, zielt auf .NET Framework 4.0/4.8 und modernes .NET 6/9/10.

Schlüsselkomponenten und Fähigkeiten im Bundle:

  • Spire.Doc: Erstellung, Konvertierung und Bearbeitung von Word DOCX/DOC
  • Spire.XLS: Excel XLSX-Engine mit Formelumrechnung und PDF-Export
  • Spire.PDF: PDF-Erstellung, -Bearbeitung und -Manipulation
  • Spire.Presentation: Unterstützung von PowerPoint PPTX
  • Spire.Barcode + Spire.OCR: Erkennungsstapel innerhalb des Bundles
  • Spire.Email + Spire.DataExport + Spire.OfficeViewer/PDFViewer/DocViewer: angrenzende Werkzeuge, die die Suite abrunden

Was ist Iron Suite

Iron Suite ist das zehnproduktige .NET-Bundle von Iron Software, wo der Office-Stack (IronWord für DOCX, IronXL für XLSX mit Formelumrechnung, IronPPT für PPTX) neben IronPDF zur PDF-Erzeugung und -Manipulation sitzt, der Erkennungsstapel (IronOCR, IronBarcode, IronQR) für OCR- und Barcode-Arbeiten, und drei Dienstprogramm-Bibliotheken (IronPrint, IronZIP, IronWebScraper) für Drucken, Archive und Schrappen. Verkauft als eine einzelne unbefristete per-Entwickler-Lizenz in fünf Stufen (Lite, Plus, Professional, Unlimited, Enterprise) ab $2,998. Gebührenfrei für die lizenzierten Plätze. SaaS und OEM-Verteilung verwenden ein separates Redistribution Add-On.

Die zehn Komponenten, gruppiert nach Relevanz für einen programmgesteuerten Office- und PDF-Workflow:

  • Office-Stack (Anker): IronWord (DOCX mit Absatz- und Textlauf-Objektgrafiken, die direkt auf OOXML abbilden, mit benutzerdefinierten Stilen, Schriftarten, Kopf- und Fußzeilen, Tabellen und Inhaltsextraktion); IronXL (XLSX mit Formelumrechnung, Diagrammerstellung über Bereich, Säule, Linien, Kreis und Streuung, Pivot-Tabellen, bedingtes Formatieren, Datenvalidierung); IronPPT (PPTX-Erstellung, -Bearbeitung, -Konvertierung und Inhaltsextraktion).
  • PDF-Erzeugung (IronPDF): HTML-zu-PDF- und URL-zu-PDF-Rendering mit gebündeltem Chromium, native Zusammenführung und Teilung über PdfDocument.Merge, PKCS#12 plus HSM plus TSA-Signatur, PDF/A-1 bis PDF/A-4, PDF/UA-1 und PDF/UA-2, Verschlüsselung, AcroForm-Ausfüllung und Flattening, Schriftartenverwaltung, Rasterung, Kompression und Linearisation.
  • Erkennung: IronOCR (Tesseract 5, 125+ Sprachen, Handschrift bei ~90% Englisch); IronBarcode (über 30 Symbologien); IronQR (ML-gestützt mit Batch-ReadPdfs).
  • Utilities: IronPrint (stilles und Dialog-Drucken); IronZIP (ZIP/TAR/GZIP/BZIP2 with AES); IronWebScraper (In-Process-Strukturiertes-Scraping).

Vergleich der Fähigkeiten

Textverarbeitung

DOCX-zu-PDF-Konvertierung ist eine Vorzeige-Arbeitslast von Spire, und die API wurde über viele Jahre für Treue verfeinert. IronWord zielt auf eine ähnliche Alltagsarbeitslast ab, aber mit einer modernen Objektgraf-API.

// 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

Spire.Doc's SaveToFile Konvention ist konsistent über jedes Spire Produkt (Spire.XLS, Spire.PDF, Spire.Presentation verwenden alle dasselbe Muster), was die Suite vorhersehbar, aber stilistisch veraltet macht. IronWord's Absatz-/Textlauf-Objektgrafik bildet sich direkt auf die OOXML-Struktur ab und liest sich wie modernes C#. Reine DOCX-zu-PDF-Rundreise mit starker Treue bei Randfällen von Legacy-Formaten ist ein Bereich, in den Spire investiert hat - für Code-First-DOCX-Generierung erfordert IronWord weniger Zeremonie.

Excel-Verarbeitung

Beide Suiten decken die alltägliche Excel-Arbeitslast ab (XLSX erstellen oder laden, Daten schreiben, Formeln neu berechnen, nach PDF exportieren) und verfügen beide über eine starke Berechnungs-Engine.

// 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

Spire.XLS's book.CalculateAllValue() + SheetFitToPage geben ihm einen starken bestehendes-Arbeitsbuch → poliertes PDF-Fluss. IronXL's Indexer-Stil-Zellzugriff (sheet["A1"].Value = …, sheet["B4"].Formula = …, workbook.EvaluateAll()) fühlt sich mehr nach alltäglichem LINQ-Ära .NET an und ist das, wonach die meisten Entwickler greifen, wenn sie XLSX von Grund auf neu erstellen. Beide Engines handhaben die generelle Formeloberfläche - komplexe Konvertierungstreue bestehender Arbeitsmappen (Legacy XLS Besonderheiten, Diagrammobjekt-Handhabung) ist ein weiterer Bereich, in den Spire weiterhin investiert hat.

PDF-Erzeugung

PDF ist, wo sich der API-Stil am meisten unterscheidet. Spire.PDF baut Dokumente primitiv-zu-primitiv auf einer Seitenleinwand auf, indem es Text, Bilder und Formen über PdfPageBase.Canvas schichtet. IronPDF rendert denselben Inhalt aus HTML mit einem echten Chrome-Engine.

// 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 ist die richtige Wahl, wenn Sie eine pixelgenaue Platzierung von Primitiven auf einer bestehenden Seite benötigen (Formulare, Stempeln, Schwärzung). IronPDF ist die richtige Wahl, wenn das PDF aus Web-App-Daten stammt: dasselbe HTML/CSS, das im Browser gerendert wird, wird zum PDF, einschließlich moderner CSS, Webschriften, SVG und JavaScript-gerendertem Inhalt.

PowerPoint-Verarbeitung

Die PowerPoint-Konvertierung zu PDF ist eine Stärke von Spire innerhalb des Bundles.Iron Suiteumfasst IronPPT für PowerPoint-Erzeugung und -Manipulation, obwohl die Iron Suite-Referenz etwa IronPPT als erstellungsfokussiertes Produkt anstatt als Tiefentreue-Konvertierungsmotor positioniert.

// 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

Spire.Presentation's Lade-/Speichermuster gleicht dem Rest der Spire-Familie und umfasst Konvertierung nach PDF und Bild mit kontinuierlicher Investition in Master-Folie, Thema und SmartArt-Treue. IronPPT deckt PowerPoint-Erzeugung und die allgemeine Manipulationsoberfläche ab (Folie, Text, Bilder, Grundformen) - Hochtreue Umwandlung bestehender Drittanbieter-Decks mit tiefem Thema und Animationserhaltung ist ein weiterer Bereich, in den Spire's Engine gewachsen ist.

Barcode-Erzeugung und -Lesen

Beide Suiten liefern Barcodeleserzeugung und -lesung. Iron teilt den Arbeitsaufwand zwischen IronBarcode (1D/2D) und IronQR (QR-spezifisch), was Teams einen speziellen Weg für QR-intensive Arbeitsabläufe gibt. Der Spire-Snippet unten demonstriert Erzeugung; der IronBarcode-Snippet demonstriert den Leseweg.

// 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 bündelt 1D/2D und QR in einen einstellungsgesteuerten Generator, der prägnant ist, aber das Lesen der Einstellungsdokumente erfordert, um alle verfügbaren Optionen zu entdecken. IronBarcode + IronQR bieten dedizierte Einstiegsstellen (BarcodeReader.Read, BarcodeWriter, plus einen QR-spezifischen Leser/Schreiber in IronQR), die sich sauberer im IDE auto-vervollständigen.

Warum Sie sich für dieIron Suitefür Code-First .NET-Dokumentenautomatisierung entscheiden sollten

Wählen Sie die Iron Suite, wenn SaaS, Docker und öffentlich zugängliche Bereitstellung unter die Basislizenz fallen sollen, anstatt hinter einer OEM-Stufe abgeschottet zu werden. Iron's APIs lesen sich als modernes, Code-First .NET, die zehn Produkte teilen einen konsistenten Stil im Bundle, und die Bepreisung ist öffentlich und unbefristet in fünf Stufen ab $2,998. Strukturelle Kanten, die für alltägliche .NET-Dokumentautomatisierung wichtig sind:

  • Transparente unbefristete Preisgestaltung mit USD-Zahlen auf jeder Ebene
  • SaaS, Docker und öffentlich zugängliche Bereitstellung sind nicht auf die OEM-Stufe beschränkt: Die Basislizenz deckt lizenzierte Plätze ab, und ein einzelnes Weiterverbreitungs-Add-On deckt Weiterverbreitungsszenarien ab
  • Gebührenfreie Bereitstellung für lizenzierte Plätze, keine Laufzeitgebühren, keine Verechnung pro Dokument
  • Code-First .NET API-Oberfläche über alle 10 Produkte, keine SaveToFile Alt-Muster zu lernen
  • Erzeugung und Erkennung (PDF/Word/Excel/PPT + OCR/Barcode/QR) in einem Bundle
  • HTML-first PDF-Erzeugung mit vollständiger Browser-Treue

Wie unterscheidet sichIron Suitevon Spire.Office

  • Öffentliche USD-Preisgestaltung auf jeder Stufe. Spires Buy/Seiten sind gegen Scraping gesperrt und Preisgestaltung erfordert Kontaktaufnahme mit dem Vertrieb; Iron veröffentlicht eine Zahl auf jeder Stufe.
  • SaaS / Docker / öffentlich zugängliche Bereitstellung ist das Basislizenzgebiet bei Iron (mit dem Weiterverbreitungs-Add-On als separater sauberer SKU). Spire schränkt diese Bereitstellungstypen auf die OEM-Stufe ein, ein schärferer Preisschritt für jede webbasierte App.
  • API-Konsistenz über Produkte hinweg. Irons 10 Produkte teilen idiomatische .NET-Benennungen und -Struktur; Spires APIs sind nützlich, aber variabel über die Komponenten hinweg (Spire.DataExport vs Spire.Spreadsheet vs Spire.Doc fühlen sich jeweils leicht unterschiedlich an).
  • Erkennung + Scraping + ZIP + Print + QR. IronWebScraper, IronZIP und IronPrint stehen auf der Iron-Seite ohne Spire-Äquivalent; IronQR ist eine spezielle QR-Bibliothek, die von IronBarcode getrennt ist.
  • HTML-First-PDF-Generierung mit wirklicher Browser-Treue vs Spire.PDFs Prim-für-Prim-Seitenleinwand-API.
  • Einzelnes Lizenzschlüssel-Registrierungsmodell vs Spires lizenzsetzer pro-Namespace und OEM-gated Bereitstellungsformen.

Abschluss

Spire.Office ist eine langjährige, fähige, budgetfreundliche Aspose-Alternative, deren stärkste Karten DOCX/XLSX/PPTX-zu-PDF-Konvertierungstreue und eine großzügige "Kostenloses Spire"-Einstiegsrampe sind. DieIron Suiteist ein strukturell einfacheres Bundle, dessen stärkste Karten Lizenzklarheit, transparente unbefristete Preisgestaltung, eine idiomatische Code-First .NET-API-Oberfläche über alle zehn Produkte hinweg sowie ein Erzeugungs-Plus-Erkennungs-Bundle, das SaaS oder Docker nicht hinter einem OEM-Level sperrt. Teams, deren Hauptbedarf Konvertierungstreue für bestehende Office-Dokumente ist, finden Spire's Engine ausgezeichnet. Teams, deren Hauptbedarf eine einzige unbefristete Lizenz ist, die PDF, Office, OCR, Barcode/QR und benachbarte Werkzeuge umfasst, ohne sich für einen Preis an den Verkauf zu wenden, findenIron Suitepassender. Entdecken Sie Iron Suite, einschließlich der $2,998 Einstiegsstufe, unter ironsoftware.com/csharp/suite.

Hinweis:Spire.Office ist ein eingetragenes Warenzeichen seines jeweiligen Eigentümers. Diese Seite ist nicht mit Spire.Office verbunden, befürwortet oder gesponsert. Alle Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Eigentümer. Vergleiche dienen nur zu Informationszwecken und spiegeln öffentlich zugängliche Informationen zum Zeitpunkt des Schreibens wider.