VERGLEICH

Text Control vs. IronPDF: Leitfaden für einen technischen Vergleich

Veröffentlicht:

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

IronPDFverstehen

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 undIronPDFweisen im Laufe der Zeit erhebliche Kostenunterschiede auf:

Aspekt TX Text Control IronPDF
Basislizenz $3.398+ pro Entwickler $749 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 749 $ 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 undIronPDFin 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 undIronPDFliegt in ihren API-Designphilosophien und Initialisierungsmustern.

TextControl-Ansatz

TextControl erfordert eine explizite Kontextverwaltung durch die ServerTextControl-Klasse. Jede Operation muss innerhalb eines benutzenden 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);
            }
        }
    }
}
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
$vbLabelText   $csharpLabel

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");
        }
    }
}
Imports IronPdf

Namespace IronPdfExample
    Class Program
        Shared Sub Main(ByVal 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
$vbLabelText   $csharpLabel

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

API-Mapping-Referenz

Teams, die einen Wechsel von TextControl zuIronPDFerwä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(Pfad, StreamType.AdobePDF) pdf.SaveAs(Pfad)
SaveSettings.PDFAConformance RenderingOptions.PdfAFormat
DocumentServer.MailMerge HTML-Vorlagen + Razor
DocumentTarget.HeadersAndFootters 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);
            }
        }
    }
}
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
$vbLabelText   $csharpLabel

IronPDFImplementierung

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");
        }
    }
}
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
$vbLabelText   $csharpLabel

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);
            }
        }
    }
}
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>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 Class
End Namespace
$vbLabelText   $csharpLabel

IronPDFImplementierung

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");
        }
    }
}
Imports IronPdf
Imports IronPdf.Rendering

Namespace IronPdfExample
    Class Program
        Shared Sub Main(args As String())
            Dim renderer As 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 Class
End Namespace
$vbLabelText   $csharpLabel

Für komplexere Kopfzeilendesigns unterstütztIronPDFauch 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
}
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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")
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

IronPDFImplementierung

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")
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

IronPDFImplementierung

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")
$vbLabelText   $csharpLabel

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 vonIronPDFwerden 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 durchIronPDFgewä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.IronPDFarbeitet 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.IronPDFersetzt 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");
Imports IronPdf

Dim data = New With {.CustomerName = "John Doe", .InvoiceNumber = "12345", .Total = "$1,500.00"}

Dim 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>"

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("invoice.pdf")
$vbLabelText   $csharpLabel

Für komplexere Templating-Szenarien lässt sichIronPDFmit 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.IronPDFwird 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 bietetIronPDFauch Funktionen zur Dokumentenmanipulation, die seinen Nutzen erweitern:

Abschluss

TX Text Control undIronPDFdienen 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 vonIronPDFausmacht. Für Teams, die TextControl derzeit hauptsächlich für die PDF-Erzeugung nutzen, kann die Evaluierung vonIronPDFMö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.