Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. Migrationsleitfäden
  4. migration von textcontrol zu IronPDF
MIGRATIONSLEITFäDEN

Wie man von TextControl zu IronPDF in C# migriert

Curtis Chau
Curtis Chau
Aktualisiert:

TX Text Control hat sich als umfassende Dokumenteditor-Komponente im .NET-Ökosystem etabliert und bietet robuste DOCX-Bearbeitungsfunktionen mit eingebetteten UI-Controls. Für Entwicklungsteams, deren primäre Anforderung die PDF-Erzeugung und nicht die vollständige Bearbeitung von Dokumenten ist, stellt die Architektur von TextControl jedoch einen erheblichen Aufwand in Bezug auf Lizenzkosten, Komplexität und Laufzeitabhängigkeiten dar.

Dieser Leitfaden bietet einen vollständigen Migrationspfad von TextControl zu IronPDF, mit Schritt-für-Schritt-Anleitungen, Code-Vergleichen und praktischen Beispielen für professionelle .NET-Entwickler, die diesen Übergang evaluieren.

Warum von TextControl migrieren

Die Entscheidung, von TextControl zu migrieren, konzentriert sich in der Regel auf die Anpassung Ihrer Werkzeuge an Ihre tatsächlichen Anforderungen. TX Text Controlist im Wesentlichen ein Dokumenten-Editor, der die PDF-Erstellung als sekundäre Funktion behandelt. Zu den wichtigsten Gründen, warum Entwicklerteams eine Migration in Betracht ziehen, gehören:

Teure Lizenzierung: TextControl wird mit einer kommerziellen Lizenz betrieben, die mindestens 3.398 US-Dollar pro Jahr und Entwickler kostet. Ein vierköpfiges Team muss mit Kosten in Höhe von 6.749 US-Dollar pro Jahr rechnen, wobei zusätzliche Kosten für Laufzeitlizenzen für die Serverbereitstellung anfallen. Die jährlichen Verlängerungskosten liegen bei 40 %, was zwingend erforderlich ist, um Zugang zu Updates zu erhalten.

PDF als nachträglicher Gedanke: Die Kernarchitektur ist die Textverarbeitung, nicht die PDF-Datei. Die PDF-Generierung ist zwar verfügbar, aber sie ist eher ein zusätzliches Feature als das Hauptaugenmerk, was zu einer nicht ganz optimalen Ausgabequalität führt.

Hardware-Bugs: Der Intel Iris Xe Grafikfehler betrifft die Dokumentenwiedergabe in neueren Intel-Prozessoren (11. Generation) und erfordert einen Registry-Workaround zur Behebung.

Überflüssige Abhängigkeiten: TextControl enthält UI-Komponenten zur Dokumentenbearbeitung, die Sie möglicherweise nicht benötigen, wenn Ihr Fokus ausschließlich auf der PDF-Erstellung liegt.

Architektur der Textverarbeitung: Nicht optimiert für die HTML-zu-PDF-Workflows, die moderne Webanwendungen erfordern.

Komplexe API: Das Kontextmanagement- und Auswahlmodell von ServerTextControl führt zu unnötiger Komplexität bei einfachen PDF-Generierungsaufgaben.

Kostenvergleich

Aspekt TX Text Control IronPDF
Basislizenz $3,398+ Erheblich niedriger
Jährliche Erneuerung 40% obligatorisch Optionale Unterstützung
Pro Entwickler Ja Ja
UI-Komponenten Gebündelt (aufgebläht) PDF-fokussiert
3-Jahres-Gesamtkosten $5,750+ Viel niedriger

IronPDF vs. TextControl: Funktionsvergleich

Das Verständnis der architektonischen Unterschiede hilft technischen Entscheidungsträgern, die Investition in die Migration zu bewerten:

Feature TX Text Control IronPDF
Primäres Ziel DOCX-Bearbeitung PDF-Erstellung
Lizenzkosten 3.398 $/Jahr pro Entwickler $749 einmalig pro Entwickler
PDF-Qualität Grundlegende, ergänzende Funktion Hohe, zentrale Funktionalität
Hardware-Kompatibilität Bekannte Probleme mit Intel Iris Stabil auf allen Geräten
Integration mit UI Benötigte UI-Komponenten Keine überladenen UI-Komponenten
HTML/CSS-Rendering Fehlerhaft mit HTML Modernes HTML5/CSS3
HTML zu PDF Ja (sekundär) Ja (primär)
CSS-Unterstützung Beschränkt Vollständig CSS3
JavaScript Beschränkt Vollständiger ES2024
URL zu PDF Komplexe Einrichtung Native
Kopf-/Fußzeilen Komplexe API Einfaches HTML
Serienbriefe Proprietär HTML-Vorlagen
PDF/A Ja Ja
Passwortschutz Ja Ja
Digitale Signaturen Ja Ja
PDFs zusammenführen Beschränkt Ja
PDFs teilen Beschränkt Ja
Kontext-Management Erforderlich Nicht erforderlich
Plattformübergreifend Windows-orientiert Ja

Schnellstart: TextControl-zu-IronPDF-Migration

Mit diesen grundlegenden Schritten kann die Migration sofort beginnen.

Schritt 1: Ersetzen von NuGet-Paketen

Entfernen Sie alle TextControl-Pakete:

# Remove TX Text Control
dotnet remove package TXTextControl.TextControl
dotnet remove package TXTextControl.DocumentServer
# Remove TX Text Control
dotnet remove package TXTextControl.TextControl
dotnet remove package TXTextControl.DocumentServer
SHELL

IronPDF installieren:

# Install IronPDF
dotnet add package IronPdf
# Install IronPDF
dotnet add package IronPdf
SHELL

Schritt 2: Namespaces aktualisieren

Ersetzen Sie die TextControl-Namensräume durch den IronPDF-Namensraum:

// Before (TextControl)
using TXTextControl;
using TXTextControl.DocumentServer;

// After (IronPDF)
using IronPdf;
// Before (TextControl)
using TXTextControl;
using TXTextControl.DocumentServer;

// After (IronPDF)
using IronPdf;
Imports TXTextControl
Imports TXTextControl.DocumentServer

' After (IronPDF)
Imports IronPdf
$vbLabelText   $csharpLabel

Schritt 3: Lizenz initialisieren

Hinzufügen der Lizenzinitialisierung beim Start der Anwendung:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Beispiele für die Code-Migration

Konvertierung von HTML in PDF

Der häufigste Anwendungsfall verdeutlicht den architektonischen Unterschied zwischen diesen .NET-PDF-Bibliotheken.

TextControl-Ansatz:

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

IronPDF-Ansatz:

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

Die TextControl-Version erfordert das Erstellen einer ServerTextControl-Instanz, den Aufruf von Create() zum Initialisieren des Kontexts, das Laden von HTML mit StreamType.HTMLFormat und das Speichern mit StreamType.AdobePDF. Der Block using ist für die ordnungsgemäße Ressourcenfreigabe zwingend erforderlich.

IronPDF macht das Kontextmanagement vollständig überflüssig. Der ChromePdfRenderer benötigt keine Initialisierungszeremonie – erstellen Sie ihn, rendern Sie das HTML und speichern Sie ihn. Diese architektonische Vereinfachung reduziert die kognitive Belastung und mögliche Fehler in der Ressourcenverwaltung.

Für fortgeschrittene HTML-zu-PDF-Szenarien siehe den HTML-zu-PDF-Konvertierungsleitfaden.

Mehrere PDFs zusammenführen

Die PDF-Zusammenführung zeigt einen weiteren bedeutenden Komplexitätsunterschied zwischen diesen Bibliotheken.

TextControl-Ansatz:

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

IronPDF-Ansatz:

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

TextControl erfordert das Einlesen von Dateien in Byte-Arrays, die Verwaltung des ServerTextControl Kontexts und die Verwendung von LoadAppendMode.Append zum Zusammenführen von Dokumenten. Die Methode PdfDocument.Merge() von IronPDF erledigt alles mit einem einzigen, expliziten Aufruf.

Für fortgeschrittene Zusammenführungsszenarien, einschließlich selektiver Seitenextraktion, siehe den Leitfaden zum Zusammenführen und Teilen von PDFs.

Kopf- und Fußzeilen einfügen

Kopf- und Fußzeilen mit dynamischen Seitenzahlen verdeutlichen den Unterschied in der API-Komplexität.

TextControl-Ansatz:

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

IronPDF-Ansatz:

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

TextControl erfordert das Erstellen von HeaderFooter-Objekten mit spezifischen HeaderFooterType-Enumerationen, den Zugriff auf Dokumentabschnitte über textControl.Sections[0] und das Hinzufügen zur HeadersAndFooters-Sammlung.IronPDF bietet direkte AddTextHeader- und AddTextFooter-Methoden mit einfacher Platzhaltersyntax.

Für HTML-basierte Header mit voller Styling-Kontrolle unterstützt IronPDF auch HtmlHeaderFooter:

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

Weitere Informationen über Kopf- und Fußzeilenoptionen finden Sie in der Kopf- und Fußzeilen-Dokumentation.

TextControl API zu IronPDFMapping Referenz

Dieses Mapping beschleunigt die Migration, indem es direkte API-Entsprechungen aufzeigt:

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

Gängige Migrationsprobleme und Lösungen

Ausgabe 1: ServerTextControl-Kontext

TextControl benötigt für jede Operation den Block Create() und den Block using.

Lösung:IronPDF verfügt über keine Kontextverwaltung:

// Just create and use
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
// Just create and use
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
' Just create and use
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

Ausgabe 2: StreamType-Konvertierungen

TextControl lädt verschiedene Formate und konvertiert sie über StreamType Enumerationen in PDF.

Lösung:IronPDF rendert HTML direkt ohne Zwischenformatkonvertierung:

// No format conversion needed
var pdf = renderer.RenderHtmlAsPdf(html);
// No format conversion needed
var pdf = renderer.RenderHtmlAsPdf(html);
Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

Ausgabe 3: DOCX-Vorlagen

TextControl verwendet DOCX-Dateien für Vorlagen mit Seriendruck.

Lösung: Konvertierung in HTML-Vorlagen mit C# String-Interpolation oder Razor:

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");
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");
Option Strict On



Dim data = New With {Key .CustomerName = "John Doe", Key .InvoiceNumber = "12345", Key .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 = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("invoice.pdf")
$vbLabelText   $csharpLabel

Ausgabe 4: Intel Iris Xe Grafikfehler

TextControl hat Rendering-Probleme mit Intel-Prozessoren der 11. Generation dokumentiert, die Workarounds für die Registrierung erfordern.

Lösung:IronPDF verwendet Chromium-Rendering - es sind keine Fehler bei der Hardwarebeschleunigung oder Änderungen der Registrierung erforderlich.

TextControl-Migrations-Checkliste

Vor der Migration anfallende Aufgaben

Überprüfen Sie Ihre Codebasis, um alle TextControl-Verwendungen zu identifizieren:

grep -r "using TXTextControl" --include="*.cs" .
grep -r "ServerTextControl\|Load\|Save" --include="*.cs" .
grep -r "using TXTextControl" --include="*.cs" .
grep -r "ServerTextControl\|Load\|Save" --include="*.cs" .
SHELL

Dokument-Serienbriefvorlagen für die Konvertierung in HTML. Beachten Sie die Anforderungen an Kopf- und Fußzeilen für die Implementierung mit HtmlHeaderFooter. Identifizieren Sie alle DOCX-Bearbeitungsfunktionen, die möglicherweise alternative Lösungen erfordern.

Aufgaben der Code-Aktualisierung

  1. TX Text ControlNuGet-Pakete entfernen
  2. IronPDF NuGet-Paket installieren
  3. Entfernen der Kontextverwaltung ServerTextControl (keine Create()-Aufrufe mehr)
  4. Konvertiere StreamType.HTMLFormat-Ladungen in RenderHtmlAsPdf
  5. Konvertierung von Serienbriefen in HTML-Vorlagen mit String-Interpolation oder Razor
  6. Aktualisieren Sie die Kopf- und Fußzeilen, sodass sie HtmlHeaderFooter oder AddTextFooter verwenden.
  7. Seiteneinstellungen vereinfachen mit RenderingOptions
  8. Lizenzinitialisierung beim Start hinzufügen

Post-Migrationstests

Überprüfen Sie diese Aspekte nach der Migration:

  • Testen Sie, ob alle Dokumentvorlagen korrekt wiedergegeben werden
  • Überprüfung der PDF/A-Konformität (falls erforderlich)
  • Passwortschutzfunktionalität testen
  • Sicherstellen, dass Kopf- und Fußzeilen auf allen Seiten erscheinen
  • Prüfung auf Intel-Hardware der 11. Generation - mit IronPDF sind keine Umgehungen der Registrierung mehr erforderlich

Die wichtigsten Vorteile der Migration zu IronPDF

Der Wechsel von TextControl zu IronPDF bietet mehrere Vorteile für Teams, die sich auf die PDF-Erstellung konzentrieren:

PDF-First-Architektur:IronPDF ist speziell auf die PDF-Generierung zugeschnitten und bietet robuste Funktionen zur Dokumentenerstellung und -wiedergabe durch die Nutzung moderner HTML5- und CSS3-Standards.

Kosteneffizienz: Durch die einmalige Preisgestaltung von IronPDF ist es auf lange Sicht deutlich günstiger, insbesondere im Vergleich zum abonnementbasierten Service von TextControl mit obligatorischen jährlichen Verlängerungsgebühren von 40 %.

Bewährte Stabilität: Dokumentierte Zuverlässigkeit auf unterschiedlicher Hardware, wodurch Probleme wie sie bei TextControl mit Intel-Grafik auftreten, vermieden werden.

Kein Kontextmanagement: Eliminieren Sie die Erstellungszeremonie und die Muster der Ressourcenentsorgung für ServerTextControl. Das zustandslose Rendering von IronPDF vereinfacht den Code und reduziert potenzielle Speicherlecks.

Moderne Rendering-Engine: Da die Verbreitung von .NET 10 und C# 14 bis 2026 zunimmt, gewährleistet das auf Chromium basierende Rendering von IronPDF die Kompatibilität mit aktuellen und zukünftigen Webstandards.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an