Iron Suite for .NET

10 .NET-Bibliotheken. Eine komplette Dokumenten-Suite.

Entdecken Sie Iron Suite

IRONPDF

IRONWORD

IRONXL

IRONPPT

IRONOCR

IRONBARCODE

IRONQR

IRONPRINT

IRONZIP

IRONWEBSCRAPER

VERGLEICH

PrinceXML gegenüber IronPDF: Leitfaden für einen technischen Vergleich

Curtis Chau

Updated: 28. Juni 2026

Wenn .NET-Entwickler PDF-Generierungsbibliotheken evaluieren, tauchen in Unternehmensdiskussionen häufig zwei Lösungen auf: TX Text Controlund IronPDF. Obwohl beide PDF-Ausgaben erzeugen können, vertreten sie grundlegend unterschiedliche Architekturphilosophien. In diesem technischen Vergleich werden beide Bibliotheken untersucht, um Architekten und Entwicklern zu helfen, fundierte Entscheidungen für ihre .NET-Anwendungen zu treffen.

Verständnis von TX Text Control

TX Text Control ist eine umfassende Dokument-Editor-Komponente mit Schwerpunkt auf DOCX-Bearbeitungsfunktionen und eingebetteten UI-Steuerelementen. Die PDF-Erzeugung ist eine sekundäre Funktion innerhalb der breiteren Architektur der Dokumentenverarbeitung. Die Plattform bietet umfangreiche Funktionen für die Bearbeitung von Dokumenten und eignet sich daher für Anwendungen, die eine umfangreiche Textbearbeitungsoberfläche erfordern.

Diese umfassende Natur bringt jedoch Überlegungen mit sich, die die Entwicklungsteams sorgfältig abwägen sollten:

Kostenintensive Lizenzierung: TX Text Controlwird mit einer kommerziellen Lizenz betrieben, die bei $3.398+ pro Entwickler beginnt und für die eine jährliche Verlängerung von 40 % erforderlich ist, um den Zugang zu Updates zu erhalten
PDF als sekundäre Funktion: Die Kernarchitektur gibt der Textverarbeitung Vorrang vor der PDF-Erzeugung und behandelt die PDF-Ausgabe als Zusatzfunktion
Bekannte Hardware-Probleme: Dokumentierte Intel Iris Xe-Grafik-Rendering-Fehler, die Intel-Prozessoren der 11. Generation betreffen, erfordern Workarounds für die Registrierung
Überflüssige Abhängigkeiten: Enthält UI-Komponenten für die Dokumentenbearbeitung, die für PDF-basierte Workflows unnötig sein können
Komplexe API: Erfordert ServerTextControl Kontextmanagement und Auswahlmodellmuster

IronPDF verstehen

IronPDF verfolgt einen grundlegend anderen Ansatz, indem es sich in erster Linie auf die PDF-Erzeugung konzentriert, ohne UI-Komponenten oder DOCX-Bearbeitungswerkzeuge einzubinden. Die Bibliothek zeichnet sich durch ein schlankes, maßgeschneidertes Design aus, das speziell für die PDF-Erzeugung und -Manipulation optimiert ist, was sie zu einem äußerst effizienten Werkzeug für die PDF-First-Architektur macht.

Zu den wichtigsten Merkmalen von IronPDF gehören:

PDF-First-Architektur: Von Grund auf für die PDF-Erzeugung konzipiert, bietet es robuste Funktionen für die Erstellung und das Rendering von Dokumenten
Chromium Rendering Engine: Nutzt moderne HTML5- und CSS3-Standards mit vollständiger Unterstützung für die Ausführung von JavaScript
Kosteneffizienz: Ein einmaliges Lizenzierungsmodell macht laufende Abonnementkosten überflüssig
Bewährte Stabilität: Dokumentierte Zuverlässigkeit bei verschiedenen Hardwarekonfigurationen, Vermeidung plattformspezifischer Rendering-Probleme
Einfache Integration: Keine Kontextverwaltung oder komplexe Initialisierungsmuster erforderlich

Preisvergleich

Die Lizenzierungsstrukturen von TextControl und IronPDF weisen im Laufe der Zeit erhebliche Kostenunterschiede auf:

Aspekt	TX Text Control	IronPDF
Basislizenz	$3.398+ pro Entwickler	`$liteLicense` einmalig pro Entwickler
Jährliche Erneuerung	40% obligatorisch	Optionale Unterstützung
4-köpfiges Team (Jahr 1)	~$6,749	~$2,996
3-Jahres-Gesamtkosten	$5.750+ pro Entwickler	`$liteLicense` pro Entwickler
UI-Komponenten	Gebündelt (potenzielle Aufblähung)	Nur auf PDF fokussiert
Server-Laufzeit	Zusätzliche Lizenzierung	Enthalten

Funktionsvergleich

Die folgende Tabelle zeigt die technischen Unterschiede zwischen TextControl und IronPDF in den wichtigsten Bereichen:

Feature	TX Text Control	IronPDF
Primärer Schwerpunkt	DOCX-Bearbeitung	PDF-Erstellung
PDF-Qualität	Grundlegende, ergänzende Funktion	Hohe, zentrale Funktionalität
HTML zu PDF	Ja (sekundär)	Ja (primär)
CSS-Unterstützung	Beschränkt	Vollständig CSS3
JavaScript-Ausführung	Beschränkt	Vollständiger ES2024
URL zu PDF	Komplexe Einrichtung erforderlich	Native Unterstützung
Kopf-/Fußzeilen	Komplexe API	Einfache HTML-basierte
Mail Merge	Proprietäres System	HTML-Vorlagen
PDF/A-Konformität	Ja	Ja
Passwortschutz	Ja	Ja
Digitale Signaturen	Ja	Ja
PDFs zusammenführen	Beschränkt	Unterstützt
PDFs aufteilen	Beschränkt	Unterstützt
Wasserzeichen	Komplexe Implementierung	Einfaches HTML/CSS
Hardware-Kompatibilität	Bekannte Intel Iris-Probleme	Stabil auf allen Geräten
Kontextverwaltung	Erforderlich	Nicht erforderlich
Plattformübergreifend	Windows-orientiert	Ja

Unterschiede in der API-Architektur

Ein entscheidender Unterschied zwischen TextControl und IronPDF liegt in ihren API-Designphilosophien und Initialisierungsmustern.

TextControl-Ansatz

TextControl erfordert ein explizites Kontextmanagement durch die ServerTextControl Klasse. Jeder Vorgang muss innerhalb eines using Blocks nach dem Aufruf von Create() erfolgen:

// NuGet: Install-Package TXTextControl.Server
using TXTextControl;
using System.IO;

namespace TextControlExample
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ServerTextControl textControl = new ServerTextControl())
            {
                textControl.Create();
                
                string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
                
                textControl.Load(html, StreamType.HTMLFormat);
                textControl.Save("output.pdf", StreamType.AdobePDF);
            }
        }
    }
}

// NuGet: Install-Package TXTextControl.Server
using TXTextControl;
using System.IO;

namespace TextControlExample
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ServerTextControl textControl = new ServerTextControl())
            {
                textControl.Create();
                
                string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
                
                textControl.Load(html, StreamType.HTMLFormat);
                textControl.Save("output.pdf", StreamType.AdobePDF);
            }
        }
    }
}

' NuGet: Install-Package TXTextControl.Server
Imports TXTextControl
Imports System.IO

Namespace TextControlExample
    Class Program
        Shared Sub Main(ByVal args() As String)
            Using textControl As New ServerTextControl()
                textControl.Create()

                Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"

                textControl.Load(html, StreamType.HTMLFormat)
                textControl.Save("output.pdf", StreamType.AdobePDF)
            End Using
        End Sub
    End Class
End Namespace

' NuGet: Install-Package TXTextControl.Server
Imports TXTextControl
Imports System.IO

Namespace TextControlExample
    Class Program
        Shared Sub Main(ByVal args() As String)
            Using textControl As New ServerTextControl()
                textControl.Create()

                Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"

                textControl.Load(html, StreamType.HTMLFormat)
                textControl.Save("output.pdf", StreamType.AdobePDF)
            End Using
        End Sub
    End Class
End Namespace

Dieses Muster erfordert ein Verständnis der TextControl-spezifischen Klassen, Stream-Typen und des Kontext-Lebenszyklus.

IronPDF-Ansatz

IronPDF macht das Kontextmanagement vollständig überflüssig. Die Klasse ChromePdfRenderer bietet eine zustandslose API, die Entwickler sofort nutzen können:

// NuGet: Install-Package IronPdf
using IronPdf;

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var renderer = new ChromePdfRenderer();
            
            string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
            
            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs("output.pdf");
        }
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var renderer = new ChromePdfRenderer();
            
            string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
            
            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs("output.pdf");
        }
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf

Namespace IronPdfExample
    Class Program
        Shared Sub Main(args As String())
            Dim renderer = New ChromePdfRenderer()

            Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"

            Dim pdf = renderer.RenderHtmlAsPdf(html)
            pdf.SaveAs("output.pdf")
        End Sub
    End Class
End Namespace

' NuGet: Install-Package IronPdf
Imports IronPdf

Namespace IronPdfExample
    Class Program
        Shared Sub Main(args As String())
            Dim renderer = New ChromePdfRenderer()

            Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"

            Dim pdf = renderer.RenderHtmlAsPdf(html)
            pdf.SaveAs("output.pdf")
        End Sub
    End Class
End Namespace

Eine umfassende Anleitung zur HTML-Konvertierung finden Sie im HTML to PDF tutorial.

API-Mapping-Referenz

Teams, die einen Wechsel von TextControl zu IronPDF erwägen, werden dieses Mapping hilfreich finden, um Konzeptäquivalenzen zu verstehen:

TX Text Control	IronPDF
`ServerTextControl.Create()`	`new ChromePdfRenderer()`
`tx.Load(html, StreamType.HTMLFormat)`	`renderer.RenderHtmlAsPdf(html)`
`tx.Load(url, StreamType.HTMLFormat)`	`renderer.RenderUrlAsPdf(url)`
`tx.Save(path, StreamType.AdobePDF)`	`pdf.SaveAs(path)`
`SaveSettings.PDFAConformance`	`RenderingOptions.PdfAFormat`
`DocumentServer.MailMerge`	HTML-Vorlagen + Razor
`DocumentTarget.HeadersAndFooters`	`HtmlHeaderFooter`
`LoadSettings`	`RenderingOptions`
`StreamType.AdobePDF`	Standard-Ausgabe

PDF-Dokumente zusammenführen

Die Zusammenführung von Dokumenten ist eine allgemeine Anforderung, bei der sich die Komplexität der Implementierung zwischen den beiden Bibliotheken unterscheidet.

TextControl-Implementierung

TextControl erfordert ein sequentielles Laden von Dokumenten mit expliziten Flags für den Append-Modus:

// NuGet: Install-Package TXTextControl.Server
using TXTextControl;
using System.IO;

namespace TextControlExample
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ServerTextControl textControl = new ServerTextControl())
            {
                textControl.Create();
                
                byte[] pdf1 = File.ReadAllBytes("document1.pdf");
                textControl.Load(pdf1, StreamType.AdobePDF);
                
                byte[] pdf2 = File.ReadAllBytes("document2.pdf");
                textControl.Load(pdf2, StreamType.AdobePDF, LoadAppendMode.Append);
                
                textControl.Save("merged.pdf", StreamType.AdobePDF);
            }
        }
    }
}

// NuGet: Install-Package TXTextControl.Server
using TXTextControl;
using System.IO;

namespace TextControlExample
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ServerTextControl textControl = new ServerTextControl())
            {
                textControl.Create();
                
                byte[] pdf1 = File.ReadAllBytes("document1.pdf");
                textControl.Load(pdf1, StreamType.AdobePDF);
                
                byte[] pdf2 = File.ReadAllBytes("document2.pdf");
                textControl.Load(pdf2, StreamType.AdobePDF, LoadAppendMode.Append);
                
                textControl.Save("merged.pdf", StreamType.AdobePDF);
            }
        }
    }
}

' NuGet: Install-Package TXTextControl.Server
Imports TXTextControl
Imports System.IO

Namespace TextControlExample
    Class Program
        Shared Sub Main(ByVal args As String())
            Using textControl As New ServerTextControl()
                textControl.Create()

                Dim pdf1 As Byte() = File.ReadAllBytes("document1.pdf")
                textControl.Load(pdf1, StreamType.AdobePDF)

                Dim pdf2 As Byte() = File.ReadAllBytes("document2.pdf")
                textControl.Load(pdf2, StreamType.AdobePDF, LoadAppendMode.Append)

                textControl.Save("merged.pdf", StreamType.AdobePDF)
            End Using
        End Sub
    End Class
End Namespace

' NuGet: Install-Package TXTextControl.Server
Imports TXTextControl
Imports System.IO

Namespace TextControlExample
    Class Program
        Shared Sub Main(ByVal args As String())
            Using textControl As New ServerTextControl()
                textControl.Create()

                Dim pdf1 As Byte() = File.ReadAllBytes("document1.pdf")
                textControl.Load(pdf1, StreamType.AdobePDF)

                Dim pdf2 As Byte() = File.ReadAllBytes("document2.pdf")
                textControl.Load(pdf2, StreamType.AdobePDF, LoadAppendMode.Append)

                textControl.Save("merged.pdf", StreamType.AdobePDF)
            End Using
        End Sub
    End Class
End Namespace

IronPDF Implementierung

IronPDF bietet eine spezielle statische Methode für die Zusammenführung, die mehrere Dokumente akzeptiert:

// NuGet: Install-Package IronPdf
using IronPdf;

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var pdf1 = PdfDocument.FromFile("document1.pdf");
            var pdf2 = PdfDocument.FromFile("document2.pdf");
            
            var merged = PdfDocument.Merge(pdf1, pdf2);
            merged.SaveAs("merged.pdf");
        }
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var pdf1 = PdfDocument.FromFile("document1.pdf");
            var pdf2 = PdfDocument.FromFile("document2.pdf");
            
            var merged = PdfDocument.Merge(pdf1, pdf2);
            merged.SaveAs("merged.pdf");
        }
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf

Namespace IronPdfExample
    Class Program
        Shared Sub Main(ByVal args As String())
            Dim pdf1 = PdfDocument.FromFile("document1.pdf")
            Dim pdf2 = PdfDocument.FromFile("document2.pdf")

            Dim merged = PdfDocument.Merge(pdf1, pdf2)
            merged.SaveAs("merged.pdf")
        End Sub
    End Class
End Namespace

' NuGet: Install-Package IronPdf
Imports IronPdf

Namespace IronPdfExample
    Class Program
        Shared Sub Main(ByVal args As String())
            Dim pdf1 = PdfDocument.FromFile("document1.pdf")
            Dim pdf2 = PdfDocument.FromFile("document2.pdf")

            Dim merged = PdfDocument.Merge(pdf1, pdf2)
            merged.SaveAs("merged.pdf")
        End Sub
    End Class
End Namespace

Die Methode PdfDocument.Merge akzeptiert eine beliebige Anzahl von Dokumenten und gibt ein neues kombiniertes PDF zurück, ohne dass eine Kontextverwaltung oder eine manuelle Handhabung von Byte-Arrays erforderlich ist.

Kopfzeilen, Fußzeilen und Seitennummerierung

Das Hinzufügen von Kopf- und Fußzeilen mit dynamischen Seitenzahlen verdeutlicht erhebliche Unterschiede in der API-Komplexität.

TextControl-Implementierung

TextControl erfordert eine abschnittsbasierte Kopf-/Fußzeilenmanipulation mit expliziten Typdeklarationen:

// NuGet: Install-Package TXTextControl.Server
using TXTextControl;
using System.IO;

namespace TextControlExample
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ServerTextControl textControl = new ServerTextControl())
            {
                textControl.Create();
                
                string html = "<html><body><h1>Document Content</h1><p>Main body text.</p></body></html>";
                textControl.Load(html, StreamType.HTMLFormat);
                
                HeaderFooter header = new HeaderFooter(HeaderFooterType.Header);
                header.Text = "Document Header";
                textControl.Sections[0].HeadersAndFooters.Add(header);
                
                HeaderFooter footer = new HeaderFooter(HeaderFooterType.Footer);
                footer.Text = "Page {page} of {numpages}";
                textControl.Sections[0].HeadersAndFooters.Add(footer);
                
                textControl.Save("output.pdf", StreamType.AdobePDF);
            }
        }
    }
}

// NuGet: Install-Package TXTextControl.Server
using TXTextControl;
using System.IO;

namespace TextControlExample
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ServerTextControl textControl = new ServerTextControl())
            {
                textControl.Create();
                
                string html = "<html><body><h1>Document Content</h1><p>Main body text.</p></body></html>";
                textControl.Load(html, StreamType.HTMLFormat);
                
                HeaderFooter header = new HeaderFooter(HeaderFooterType.Header);
                header.Text = "Document Header";
                textControl.Sections[0].HeadersAndFooters.Add(header);
                
                HeaderFooter footer = new HeaderFooter(HeaderFooterType.Footer);
                footer.Text = "Page {page} of {numpages}";
                textControl.Sections[0].HeadersAndFooters.Add(footer);
                
                textControl.Save("output.pdf", StreamType.AdobePDF);
            }
        }
    }
}

' NuGet: Install-Package TXTextControl.Server
Imports TXTextControl
Imports System.IO

Namespace TextControlExample
    Module Program
        Sub Main(args As String())
            Using textControl As New ServerTextControl()
                textControl.Create()

                Dim html As String = "<html><body><h1>Document Content</h1><p>Main body text.</p></body></html>"
                textControl.Load(html, StreamType.HTMLFormat)

                Dim header As New HeaderFooter(HeaderFooterType.Header)
                header.Text = "Document Header"
                textControl.Sections(0).HeadersAndFooters.Add(header)

                Dim footer As New HeaderFooter(HeaderFooterType.Footer)
                footer.Text = "Page {page} of {numpages}"
                textControl.Sections(0).HeadersAndFooters.Add(footer)

                textControl.Save("output.pdf", StreamType.AdobePDF)
            End Using
        End Sub
    End Module
End Namespace

' NuGet: Install-Package TXTextControl.Server
Imports TXTextControl
Imports System.IO

Namespace TextControlExample
    Module Program
        Sub Main(args As String())
            Using textControl As New ServerTextControl()
                textControl.Create()

                Dim html As String = "<html><body><h1>Document Content</h1><p>Main body text.</p></body></html>"
                textControl.Load(html, StreamType.HTMLFormat)

                Dim header As New HeaderFooter(HeaderFooterType.Header)
                header.Text = "Document Header"
                textControl.Sections(0).HeadersAndFooters.Add(header)

                Dim footer As New HeaderFooter(HeaderFooterType.Footer)
                footer.Text = "Page {page} of {numpages}"
                textControl.Sections(0).HeadersAndFooters.Add(footer)

                textControl.Save("output.pdf", StreamType.AdobePDF)
            End Using
        End Sub
    End Module
End Namespace

IronPDF Implementierung

IronPDF bietet optimierte Methoden zum Hinzufügen von textbasierten Kopf- und Fußzeilen:

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var renderer = new ChromePdfRenderer();
            
            string html = "<html><body><h1>Document Content</h1><p>Main body text.</p></body></html>";
            
            var pdf = renderer.RenderHtmlAsPdf(html);
            
            pdf.AddTextHeader("Document Header");
            pdf.AddTextFooter("Page {page} of {total-pages}");
            
            pdf.SaveAs("output.pdf");
        }
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var renderer = new ChromePdfRenderer();
            
            string html = "<html><body><h1>Document Content</h1><p>Main body text.</p></body></html>";
            
            var pdf = renderer.RenderHtmlAsPdf(html);
            
            pdf.AddTextHeader("Document Header");
            pdf.AddTextFooter("Page {page} of {total-pages}");
            
            pdf.SaveAs("output.pdf");
        }
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Rendering

Namespace IronPdfExample
    Module Program
        Sub Main(args As String())
            Dim renderer = New ChromePdfRenderer()

            Dim html As String = "<html><body><h1>Document Content</h1><p>Main body text.</p></body></html>"

            Dim pdf = renderer.RenderHtmlAsPdf(html)

            pdf.AddTextHeader("Document Header")
            pdf.AddTextFooter("Page {page} of {total-pages}")

            pdf.SaveAs("output.pdf")
        End Sub
    End Module
End Namespace

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Rendering

Namespace IronPdfExample
    Module Program
        Sub Main(args As String())
            Dim renderer = New ChromePdfRenderer()

            Dim html As String = "<html><body><h1>Document Content</h1><p>Main body text.</p></body></html>"

            Dim pdf = renderer.RenderHtmlAsPdf(html)

            pdf.AddTextHeader("Document Header")
            pdf.AddTextFooter("Page {page} of {total-pages}")

            pdf.SaveAs("output.pdf")
        End Sub
    End Module
End Namespace

Für komplexere Kopfzeilendesigns unterstützt IronPDF auch die HtmlHeaderFooter-Klasse, die eine vollständige HTML- und CSS-Gestaltung zulässt:

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='width: 100%; text-align: center; font-size: 12pt;'>
            Company Report
        </div>",
    MaxHeight = 30
};

renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='width: 100%; text-align: right; font-size: 10pt;'>
            Page {page} of {total-pages}
        </div>",
    MaxHeight = 25
};

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='width: 100%; text-align: center; font-size: 12pt;'>
            Company Report
        </div>",
    MaxHeight = 30
};

renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='width: 100%; text-align: right; font-size: 10pt;'>
            Page {page} of {total-pages}
        </div>",
    MaxHeight = 25
};

renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .HtmlFragment = "
        <div style='width: 100%; text-align: center; font-size: 12pt;'>
            Company Report
        </div>",
    .MaxHeight = 30
}

renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .HtmlFragment = "
        <div style='width: 100%; text-align: right; font-size: 10pt;'>
            Page {page} of {total-pages}
        </div>",
    .MaxHeight = 25
}

renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .HtmlFragment = "
        <div style='width: 100%; text-align: center; font-size: 12pt;'>
            Company Report
        </div>",
    .MaxHeight = 30
}

renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .HtmlFragment = "
        <div style='width: 100%; text-align: right; font-size: 10pt;'>
            Page {page} of {total-pages}
        </div>",
    .MaxHeight = 25
}

URL zu PDF Konvertierung

Bei der Konvertierung von Live-Webseiten in PDF werden architektonische Unterschiede im Umgang mit Webinhalten in den einzelnen Bibliotheken deutlich.

TextControl-Ansatz

TextControl erfordert das manuelle Laden von URLs über seinen HTML-Format-Handler, der nur begrenzte CSS- und JavaScript-Unterstützung bietet:

using (ServerTextControl tx = new ServerTextControl())
{
    tx.Create();

    LoadSettings loadSettings = new LoadSettings();
    loadSettings.ApplicationFieldFormat = ApplicationFieldFormat.MSWord;
    tx.Load("https://example.com/invoice", StreamType.HTMLFormat, loadSettings);

    SaveSettings saveSettings = new SaveSettings();
    saveSettings.PDFAConformance = PDFAConformance.PDFa1b;
    tx.Save("output.pdf", StreamType.AdobePDF, saveSettings);
}

using (ServerTextControl tx = new ServerTextControl())
{
    tx.Create();

    LoadSettings loadSettings = new LoadSettings();
    loadSettings.ApplicationFieldFormat = ApplicationFieldFormat.MSWord;
    tx.Load("https://example.com/invoice", StreamType.HTMLFormat, loadSettings);

    SaveSettings saveSettings = new SaveSettings();
    saveSettings.PDFAConformance = PDFAConformance.PDFa1b;
    tx.Save("output.pdf", StreamType.AdobePDF, saveSettings);
}

Imports ServerTextControlNamespace

Using tx As New ServerTextControl()
    tx.Create()

    Dim loadSettings As New LoadSettings()
    loadSettings.ApplicationFieldFormat = ApplicationFieldFormat.MSWord
    tx.Load("https://example.com/invoice", StreamType.HTMLFormat, loadSettings)

    Dim saveSettings As New SaveSettings()
    saveSettings.PDFAConformance = PDFAConformance.PDFa1b
    tx.Save("output.pdf", StreamType.AdobePDF, saveSettings)
End Using

Imports ServerTextControlNamespace

Using tx As New ServerTextControl()
    tx.Create()

    Dim loadSettings As New LoadSettings()
    loadSettings.ApplicationFieldFormat = ApplicationFieldFormat.MSWord
    tx.Load("https://example.com/invoice", StreamType.HTMLFormat, loadSettings)

    Dim saveSettings As New SaveSettings()
    saveSettings.PDFAConformance = PDFAConformance.PDFa1b
    tx.Save("output.pdf", StreamType.AdobePDF, saveSettings)
End Using

IronPDF-Ansatz

IronPDF bietet natives URL-Rendering durch seine Chromium-Engine, die JavaScript ausführt und alle Stile anwendet:

var renderer = new ChromePdfRenderer();

// PDF/A compliance - simple property
renderer.RenderingOptions.PdfAFormat = PdfAVersions.PdfA1B;

var pdf = renderer.RenderUrlAsPdf("https://example.com/invoice");
pdf.SaveAs("output.pdf");

var renderer = new ChromePdfRenderer();

// PDF/A compliance - simple property
renderer.RenderingOptions.PdfAFormat = PdfAVersions.PdfA1B;

var pdf = renderer.RenderUrlAsPdf("https://example.com/invoice");
pdf.SaveAs("output.pdf");

Dim renderer = New ChromePdfRenderer()

' PDF/A compliance - simple property
renderer.RenderingOptions.PdfAFormat = PdfAVersions.PdfA1B

Dim pdf = renderer.RenderUrlAsPdf("https://example.com/invoice")
pdf.SaveAs("output.pdf")

Dim renderer = New ChromePdfRenderer()

' PDF/A compliance - simple property
renderer.RenderingOptions.PdfAFormat = PdfAVersions.PdfA1B

Dim pdf = renderer.RenderUrlAsPdf("https://example.com/invoice")
pdf.SaveAs("output.pdf")

Die RenderUrlAsPdf-Methode erfasst die komplette gerenderte Seite einschließlich dynamisch generierter Inhalte und ist damit ideal für moderne Webanwendungen, die mit Frameworks wie React, Angular oder Vue.js erstellt wurden.

Seiteneinstellungen und Konfiguration

Die Konfiguration von Seitenabmessungen, Rändern und Ausrichtung zeigt verschiedene Ansätze für Dokumenteinstellungen.

TextControl-Implementierung

TextControl verwendet abschnittsbasierte Seiteneinstellungen mit Messungen in TWIPS:

using (ServerTextControl tx = new ServerTextControl())
{
    tx.Create();
    tx.Load(html, StreamType.HTMLFormat);

    // Complex page settings through sections
    foreach (Section section in tx.Sections)
    {
        section.Format.PageSize = PageSize.A4;
        section.Format.PageMargins = new PageMargins(
            1440, 1440, 1440, 1440); // TWIPS
        section.Format.Landscape = true;
    }

    tx.Save("output.pdf", StreamType.AdobePDF);
}

using (ServerTextControl tx = new ServerTextControl())
{
    tx.Create();
    tx.Load(html, StreamType.HTMLFormat);

    // Complex page settings through sections
    foreach (Section section in tx.Sections)
    {
        section.Format.PageSize = PageSize.A4;
        section.Format.PageMargins = new PageMargins(
            1440, 1440, 1440, 1440); // TWIPS
        section.Format.Landscape = true;
    }

    tx.Save("output.pdf", StreamType.AdobePDF);
}

Imports TXTextControl

Using tx As New ServerTextControl()
    tx.Create()
    tx.Load(html, StreamType.HTMLFormat)

    ' Complex page settings through sections
    For Each section As Section In tx.Sections
        section.Format.PageSize = PageSize.A4
        section.Format.PageMargins = New PageMargins(1440, 1440, 1440, 1440) ' TWIPS
        section.Format.Landscape = True
    Next

    tx.Save("output.pdf", StreamType.AdobePDF)
End Using

Imports TXTextControl

Using tx As New ServerTextControl()
    tx.Create()
    tx.Load(html, StreamType.HTMLFormat)

    ' Complex page settings through sections
    For Each section As Section In tx.Sections
        section.Format.PageSize = PageSize.A4
        section.Format.PageMargins = New PageMargins(1440, 1440, 1440, 1440) ' TWIPS
        section.Format.Landscape = True
    Next

    tx.Save("output.pdf", StreamType.AdobePDF)
End Using

IronPDF Implementierung

IronPDF zentralisiert die Seiteneinstellungen in den RenderingOptions mit intuitiven millimeterbasierten Messungen:

var renderer = new ChromePdfRenderer();

renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
renderer.RenderingOptions.MarginTop = 25;    // mm
renderer.RenderingOptions.MarginBottom = 25;
renderer.RenderingOptions.MarginLeft = 25;
renderer.RenderingOptions.MarginRight = 25;

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

var renderer = new ChromePdfRenderer();

renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
renderer.RenderingOptions.MarginTop = 25;    // mm
renderer.RenderingOptions.MarginBottom = 25;
renderer.RenderingOptions.MarginLeft = 25;
renderer.RenderingOptions.MarginRight = 25;

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

Dim renderer = New ChromePdfRenderer()

renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
renderer.RenderingOptions.MarginTop = 25 ' mm
renderer.RenderingOptions.MarginBottom = 25
renderer.RenderingOptions.MarginLeft = 25
renderer.RenderingOptions.MarginRight = 25

Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

Dim renderer = New ChromePdfRenderer()

renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
renderer.RenderingOptions.MarginTop = 25 ' mm
renderer.RenderingOptions.MarginBottom = 25
renderer.RenderingOptions.MarginLeft = 25
renderer.RenderingOptions.MarginRight = 25

Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

Passwortschutz und Sicherheit

Beide Bibliotheken unterstützen PDF-Sicherheitsfunktionen, jedoch mit unterschiedlichen API-Mustern.

TextControl-Implementierung

using (ServerTextControl tx = new ServerTextControl())
{
    tx.Create();
    tx.Load(html, StreamType.HTMLFormat);

    SaveSettings saveSettings = new SaveSettings();
    saveSettings.UserPassword = "user123";
    saveSettings.MasterPassword = "owner456";

    tx.Save("protected.pdf", StreamType.AdobePDF, saveSettings);
}

using (ServerTextControl tx = new ServerTextControl())
{
    tx.Create();
    tx.Load(html, StreamType.HTMLFormat);

    SaveSettings saveSettings = new SaveSettings();
    saveSettings.UserPassword = "user123";
    saveSettings.MasterPassword = "owner456";

    tx.Save("protected.pdf", StreamType.AdobePDF, saveSettings);
}

Imports ServerTextControlNamespace

Using tx As New ServerTextControl()
    tx.Create()
    tx.Load(html, StreamType.HTMLFormat)

    Dim saveSettings As New SaveSettings()
    saveSettings.UserPassword = "user123"
    saveSettings.MasterPassword = "owner456"

    tx.Save("protected.pdf", StreamType.AdobePDF, saveSettings)
End Using

Imports ServerTextControlNamespace

Using tx As New ServerTextControl()
    tx.Create()
    tx.Load(html, StreamType.HTMLFormat)

    Dim saveSettings As New SaveSettings()
    saveSettings.UserPassword = "user123"
    saveSettings.MasterPassword = "owner456"

    tx.Save("protected.pdf", StreamType.AdobePDF, saveSettings)
End Using

IronPDF Implementierung

IronPDF bietet eine granulare Sicherheitskontrolle über die SecuritySettings-Eigenschaft:

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);

pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.OwnerPassword = "owner456";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;

pdf.SaveAs("protected.pdf");

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);

pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.OwnerPassword = "owner456";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;

pdf.SaveAs("protected.pdf");

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)

pdf.SecuritySettings.UserPassword = "user123"
pdf.SecuritySettings.OwnerPassword = "owner456"
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights

pdf.SaveAs("protected.pdf")

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)

pdf.SecuritySettings.UserPassword = "user123"
pdf.SecuritySettings.OwnerPassword = "owner456"
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights

pdf.SaveAs("protected.pdf")

Wenn Teams Alternativen zu TextControl in Betracht ziehen

Verschiedene Szenarien veranlassen Entwicklungsteams häufig dazu, Alternativen zu TextControl zu evaluieren:

Kostenoptimierung

Mit TextControl-Lizenzen ab $3.398+ pro Entwickler und obligatorischen jährlichen Verlängerungen von 40 % erreichen die Gesamtbetriebskosten für drei Jahre $5.750+ pro Entwickler. Teams, die sich in erster Linie auf die PDF-Erstellung konzentrieren, finden es oft schwierig, diesen Preis zu rechtfertigen, wenn es Alternativen zu deutlich niedrigeren Kosten gibt.

Belange der Hardware-Kompatibilität

Der dokumentierte Fehler in der Intel Iris Xe-Grafik, der Intel-Prozessoren der 11. Generation betrifft, erfordert eine Umgehung der Registrierung für den Einsatz von TextControl. Durch das Chromium-basierte Rendering von IronPDF werden diese hardwarespezifischen Rendering-Probleme vollständig beseitigt.

PDF-First-Anforderungen

Wenn die PDF-Erzeugung der primäre Anwendungsfall ist und nicht die Bearbeitung von Dokumenten, führt die Textverarbeitungsarchitektur von TextControl zu unnötiger Komplexität. Anwendungen, die keine DOCX-Bearbeitungsfunktionen oder eingebettete UI-Steuerelemente benötigen, profitieren von IronPDFs fokussiertem, PDF-zentriertem Design.

Moderne Webtechnologie-Integration

Die begrenzte CSS- und JavaScript-Unterstützung von TextControl stellt eine Herausforderung für Anwendungen dar, die moderne Frontend-Frameworks verwenden. Die vollständige Unterstützung von HTML5, CSS3 und ES2024 JavaScript durch IronPDF gewährleistet die korrekte Darstellung moderner Webinhalte.

Vereinfachte Bereitstellung

Das ServerTextControl-Kontextmanagement von TextControl und die Abhängigkeiten von UI-Komponenten erhöhen die Komplexität der Bereitstellung.IronPDF arbeitet als eigenständiges NuGet-Paket ohne externe Abhängigkeiten oder komplexe Initialisierungsmuster.

Vorlage und Seriendruck-Alternativen

TextControls proprietäres Seriendrucksystem verwendet DOCX-Vorlagen mit Seriendruckfeldern.IronPDF ersetzt dies durch Standard-HTML-Vorlagen:

// Use standard C# string interpolation
var data = new { CustomerName = "John Doe", InvoiceNumber = "12345", Total = "$1,500.00" };

var html = $@"
<html>
<head>
    <style>
        body {{font-family: Arial; padding: 40px;}}
        h1 {{color: #333;}}
        .total {{font-size: 24px; color: green;}}
    </style>
</head>
<body>
    <h1>Invoice #{data.InvoiceNumber}</h1>
    <p>Customer: {data.CustomerName}</p>
    <p class='total'>Total: {data.Total}</p>
</body>
</html>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("invoice.pdf");

// Use standard C# string interpolation
var data = new { CustomerName = "John Doe", InvoiceNumber = "12345", Total = "$1,500.00" };

var html = $@"
<html>
<head>
    <style>
        body {{font-family: Arial; padding: 40px;}}
        h1 {{color: #333;}}
        .total {{font-size: 24px; color: green;}}
    </style>
</head>
<body>
    <h1>Invoice #{data.InvoiceNumber}</h1>
    <p>Customer: {data.CustomerName}</p>
    <p class='total'>Total: {data.Total}</p>
</body>
</html>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("invoice.pdf");

Für komplexere Templating-Szenarien lässt sich IronPDF mit Razor-Engines und anderen Templating-Frameworks integrieren. Detaillierte Implementierungsmuster finden Sie im Razor Template Integration Guide.

.NET-Kompatibilität und Zukunftsfähigkeit

Beide Bibliotheken unterstützen aktuelle .NET-Implementierungen.IronPDF wird aktiv weiterentwickelt und regelmäßig aktualisiert, um die Kompatibilität mit .NET 8, .NET 9 und zukünftigen Versionen, einschließlich .NET 10, das für 2026 erwartet wird, zu gewährleisten. Die async/await-Unterstützung in der gesamten API der Bibliothek entspricht den modernen C#-Entwicklungspraktiken, einschließlich der in C# 13 verfügbaren Funktionen und der voraussichtlichen C# 14-Funktionen.

Zusätzliche PDF-Fähigkeiten

Neben der Generierung bietet IronPDF auch Funktionen zur Dokumentenmanipulation, die seinen Nutzen erweitern:

Zusammenführung von PDFs: Kombinieren Sie mehrere Dokumente zu einer einzigen Datei
Aufteilung von Dokumenten: Extrahieren von Seitenbereichen in separate PDFs
Digitale Signaturen: Anwendung kryptografischer Signaturen für die Authentizität von Dokumenten
Wasserzeichen: Hinzufügen von Text- oder Bild-Wasserzeichen über HTML/CSS
PDF/A-Konformität: Generieren von Dokumenten nach Archivierungsstandard
Formularausfüllung: Programmgesteuertes Ausfüllen von PDF-Formularfeldern

Abschluss

TX Text Control und IronPDF dienen unterschiedlichen Hauptzwecken, obwohl beide PDF-Ausgaben erzeugen. TextControl zeichnet sich als umfassender Dokumenten-Editor mit DOCX-Bearbeitung und eingebetteten UI-Steuerelementen aus - ideal für Anwendungen, die neben Dokumentenexportfunktionen auch umfangreiche Textbearbeitungsschnittstellen benötigen.

IronPDF konzentriert sich speziell auf die PDF-Erzeugung aus HTML- und Web-Inhalten und bietet eine optimierte Lösung für Entwickler, die HTML, URLs oder dynamisch erzeugte Inhalte in PDF konvertieren müssen, ohne den Aufwand einer kompletten Infrastruktur für die Dokumentenbearbeitung zu betreiben. Das Chromium-basierte Rendering sorgt für eine pixelgenaue Ausgabe, die der Browserdarstellung entspricht, während das API-Design auf Einfachheit und Integration in Standard-Webentwicklungs-Workflows ausgerichtet ist.

Die Wahl zwischen den Werkzeugen hängt von den Projektanforderungen ab: Eine umfassende Dokumentenbearbeitung mit PDF-Export spricht für TextControl, während die unkomplizierte PDF-Erzeugung aus Webinhalten die Stärken von IronPDF ausmacht. Für Teams, die TextControl derzeit hauptsächlich für die PDF-Erzeugung nutzen, kann die Evaluierung von IronPDF Möglichkeiten für eine erhebliche Kostenreduzierung und eine vereinfachte Bereitstellung ohne Einbußen bei der PDF-Qualität aufzeigen.

Weitere Anleitungen zur Implementierung finden Sie in der IronPDF-Dokumentation und den Tutorials, die spezielle Anwendungsfälle und erweiterte Funktionen behandeln.

Hinweis:: Text Control ist eine eingetragene Marke ihres jeweiligen Eigentümers. Diese Seite ist nicht mit Text Control verbunden, wird nicht von Text Control unterstützt 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.