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

Wie man von TallComponents zu IronPDF in C# migriert

Curtis Chau
Curtis Chau
Aktualisiert:

Mit der Übernahme von TallComponents durch Apryse hat sich die .NET-PDF-Landschaft erheblich verändert. Da TallComponents nicht mehr für neue Lizenzen zur Verfügung steht und bestehende Nutzer auf iText SDK umgeleitet werden, stehen Entwickler, die TallPDF und PDFKit verwenden, vor einer unausweichlichen Entscheidung: Jetzt migrieren oder riskieren, dass die Software bis ins Jahr 2026 und darüber hinaus nicht unterstützt wird und bekannte Rendering-Fehler aufweist.

Dieses Handbuch bietet einen vollständigen Migrationspfad von TallComponents zu IronPDF, einschließlich schrittweiser Anleitungen, API-Zuordnungen und echter Code-Beispiele, um professionellen .NET-Entwicklern einen effizienten Übergang zu ermöglichen.

Warum die Migration von TallComponents jetzt obligatorisch ist

TallComponents war einst ein angesehener Name in der C# PDF-Erstellung. Die Bibliothek bietet XML-basierte Dokumenten-Workflows und programmatische PDF-Manipulation. Mit der Übernahme durch Apryse wurde jedoch der Verkauf neuer Lizenzen eingestellt, was die Kalkulation für Entwicklungsteams grundlegend verändert hat.

Kritische TallComponents-Einschränkungen

Bei der Entscheidung für eine Migration geht es nicht nur um die Unterstützung durch den Hersteller - TallComponents hat erhebliche technische Schulden:

Produkteinstellung: Seit der Übernahme durch Apryse werden keine neuen Lizenzen mehr vergeben. Auf der offiziellen TallComponents-Website wird ausdrücklich darauf hingewiesen, dass der Verkauf neuer Lizenzen eingestellt wurde, und potenzielle Nutzer werden darauf hingewiesen, stattdessen iText SDK zu verwenden.

Keine HTML-zu-PDF-Unterstützung: Im Gegensatz zu modernen PDF-Bibliotheken unterstützt TallComponents keine direkte HTML-zu-PDF-Konvertierung. Entwickler auf Support-Plattformen haben diese Einschränkung bestätigt und auf Lösungen von Drittanbietern wie Pechkin als Alternativen verwiesen.

Dokumentierte Darstellungsfehler: Die Änderungsprotokolle offenbaren umfangreiche Darstellungsprobleme, darunter die Darstellung leerer Seiten, fehlende Grafiken, unzuverlässige JPEG-Bildverarbeitung und fehlerhafte Schriftdarstellung. Diese Fehler wurden vor der Einstellung nie behoben.

Kein Support oder Updates: Ohne aktive Wartung bleiben etwaige Sicherheitslücken oder Kompatibilitätsprobleme mit .NET 10 und C# 14 ungelöst.

IronPDF: Eine moderne TallComponents-Alternative

IronPDF behebt die zentralen Einschränkungen, die TallComponents für moderne Entwicklungsabläufe problematisch gemacht haben:

Feature TallComponents IronPDF
Aktueller Verkaufsstatus Eingestellt für neue Verkäufe Aktiv entwickelt und verkauft
HTML-zu-PDF-Unterstützung Nein Ja (HTML5/CSS3 mit Chromium)
Wiedergabetreue Bekannte Bugs und Probleme Bewährte Verlässlichkeit
Installation Komplex, manuell Einfach mit NuGet
Kundenbetreuung Übergang zum iText SDK Aktive Unterstützung und Gemeinschaft
Künftige Benutzerfreundlichkeit End-of-Life Langfristige Rentabilität

Der Kontrast ist krass: TallComponents bietet einen XML-basierten Ansatz aus einer anderen Ära der .NET-Entwicklung, während IronPDF ein Chromium-basiertes HTML-Rendering bietet, das sich an die Art und Weise anpasst, wie Entwickler heute Anwendungen erstellen.

Schnellstart: TallComponents zu IronPDFMigration

Schritt 1: Ersetzen von NuGet-Paketen

Entfernen Sie alle TallComponents-Pakete aus Ihrem Projekt:

# Remove TallComponentspackages
dotnet remove package TallComponents.PDF.Kit
dotnet remove package TallComponents.PDF.Layout
dotnet remove package TallComponents.PDF.Layout.Drawing
# Remove TallComponentspackages
dotnet remove package TallComponents.PDF.Kit
dotnet remove package TallComponents.PDF.Layout
dotnet remove package TallComponents.PDF.Layout.Drawing
SHELL

IronPDF installieren:

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

Für spezielle Frameworks bietet IronPDF spezielle Erweiterungspakete an:

Blazor -Server:

PM > Install-Package IronPdf.Extensions.Blazor
PM > Install-Package IronPdf.Extensions.Blazor
SHELL

MAUI:

PM > Install-Package IronPdf.Extensions.Maui
PM > Install-Package IronPdf.Extensions.Maui
SHELL

MVC-Framework:

PM > Install-Package IronPdf.Extensions.Mvc.Framework
PM > Install-Package IronPdf.Extensions.Mvc.Framework
SHELL

Schritt 2: Namespaces aktualisieren

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

// Before (TallComponents)
using TallComponents.PDF.Kit;
using TallComponents.PDF.Layout;
using TallComponents.PDF.Layout.Drawing;
using TallComponents.PDF.Layout.Paragraphs;

// After (IronPDF)
using IronPdf;
// Before (TallComponents)
using TallComponents.PDF.Kit;
using TallComponents.PDF.Layout;
using TallComponents.PDF.Layout.Drawing;
using TallComponents.PDF.Layout.Paragraphs;

// After (IronPDF)
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Schritt 3: Initialisieren Sie Ihre Lizenz

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

TallComponents zu IronPDFAPI Mapping Referenz

Das Verständnis, wie TallComponents-Konzepte auf IronPDF abgebildet werden, beschleunigt den Migrationsprozess:

TallComponents IronPDF Notizen
Document ChromePdfRenderer Renderer für die PDF-Generierung erstellen
Section Automatisch Von der HTML-Struktur abgeleitete Abschnitte
TextParagraph HTML-Textelemente Verwenden Sie <p>, <h1>, <div>, usw.
ImageParagraph <img> Tag Standard-HTML-Bilder
TableParagraph HTML <table> Standard-HTML-Tabellen
Font CSS font-family Vollständig unterstützte Webfonts
document.Write() pdf.SaveAs() In Datei speichern
document.Write(stream) pdf.BinaryData oder pdf.Stream Stream-Ausgabe
Page.Canvas HTML/CSS-Rendering Keine manuelle Manipulation der Leinwand erforderlich
XmlDocument.Generate() RenderHtmlAsPdf() HTML ersetzt XML
PdfKit.Merger.Merge() PdfDocument.Merge() Mehrere PDFs zusammenführen
Document.Security pdf.SecuritySettings PDF-Sicherheitskonfiguration
PageLayout RenderingOptions Seiteneinstellungen und Ränder

Beispiele für die Code-Migration

Konvertierung von HTML in PDF

TallComponents verfügt über keine native HTML-zu-PDF-Unterstützung. Die Umgehung besteht in der Erstellung von Textfragmenten, die nicht wirklich HTML wiedergeben:

TallComponents Ansatz:

// NuGet: Install-Package TallComponents.PDF.Kit
using TallComponents.PDF.Kit;
using System.IO;

class Program
{
    static void Main()
    {
        // Create a new document
        using (Document document = new Document())
        {
            string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";

            // Create HTML fragment
            Fragment fragment = Fragment.FromText(html);

            // Add to document
            Section section = document.Sections.Add();
            section.Fragments.Add(fragment);

            // Save to file
            using (FileStream fs = new FileStream("output.pdf", FileMode.Create))
            {
                document.Write(fs);
            }
        }
    }
}
// NuGet: Install-Package TallComponents.PDF.Kit
using TallComponents.PDF.Kit;
using System.IO;

class Program
{
    static void Main()
    {
        // Create a new document
        using (Document document = new Document())
        {
            string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";

            // Create HTML fragment
            Fragment fragment = Fragment.FromText(html);

            // Add to document
            Section section = document.Sections.Add();
            section.Fragments.Add(fragment);

            // Save to file
            using (FileStream fs = new FileStream("output.pdf", FileMode.Create))
            {
                document.Write(fs);
            }
        }
    }
}
Imports TallComponents.PDF.Kit
Imports System.IO

Class Program
    Shared Sub Main()
        ' Create a new document
        Using document As New Document()
            Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>"

            ' Create HTML fragment
            Dim fragment As Fragment = Fragment.FromText(html)

            ' Add to document
            Dim section As Section = document.Sections.Add()
            section.Fragments.Add(fragment)

            ' Save to file
            Using fs As New FileStream("output.pdf", FileMode.Create)
                document.Write(fs)
            End Using
        End Using
    End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF-Ansatz:

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        // Create a PDF from HTML string
        var renderer = new ChromePdfRenderer();
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        // Create a PDF from HTML string
        var renderer = new ChromePdfRenderer();
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";

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

Class Program
    Shared Sub Main()
        ' Create a PDF from HTML string
        Dim renderer As New ChromePdfRenderer()
        Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF's ChromePdfRenderer verwendet eine echte Chromium-Engine und bietet volle HTML5- und CSS3-Unterstützung. Das bedeutet, dass Ihre PDFs genau so wiedergegeben werden, wie sie in einem modernen Browser erscheinen würden. Erfahren Sie mehr im HTML zu PDF Tutorial.

Mehrere PDFs zusammenführen

Die PDF-Zusammenführung zeigt den Unterschied in der Ausführlichkeit zwischen TallComponents und IronPDF.

TallComponents Ansatz:

// NuGet: Install-Package TallComponents.PDF.Kit
using TallComponents.PDF.Kit;
using System.IO;

class Program
{
    static void Main()
    {
        // Create output document
        using (Document outputDoc = new Document())
        {
            // Load first PDF
            using (FileStream fs1 = new FileStream("document1.pdf", FileMode.Open))
            using (Document doc1 = new Document(fs1))
            {
                foreach (Page page in doc1.Pages)
                {
                    outputDoc.Pages.Add(page.Clone());
                }
            }

            // Load second PDF
            using (FileStream fs2 = new FileStream("document2.pdf", FileMode.Open))
            using (Document doc2 = new Document(fs2))
            {
                foreach (Page page in doc2.Pages)
                {
                    outputDoc.Pages.Add(page.Clone());
                }
            }

            // Save merged document
            using (FileStream output = new FileStream("merged.pdf", FileMode.Create))
            {
                outputDoc.Write(output);
            }
        }
    }
}
// NuGet: Install-Package TallComponents.PDF.Kit
using TallComponents.PDF.Kit;
using System.IO;

class Program
{
    static void Main()
    {
        // Create output document
        using (Document outputDoc = new Document())
        {
            // Load first PDF
            using (FileStream fs1 = new FileStream("document1.pdf", FileMode.Open))
            using (Document doc1 = new Document(fs1))
            {
                foreach (Page page in doc1.Pages)
                {
                    outputDoc.Pages.Add(page.Clone());
                }
            }

            // Load second PDF
            using (FileStream fs2 = new FileStream("document2.pdf", FileMode.Open))
            using (Document doc2 = new Document(fs2))
            {
                foreach (Page page in doc2.Pages)
                {
                    outputDoc.Pages.Add(page.Clone());
                }
            }

            // Save merged document
            using (FileStream output = new FileStream("merged.pdf", FileMode.Create))
            {
                outputDoc.Write(output);
            }
        }
    }
}
Imports TallComponents.PDF.Kit
Imports System.IO

Class Program
    Shared Sub Main()
        ' Create output document
        Using outputDoc As New Document()
            ' Load first PDF
            Using fs1 As New FileStream("document1.pdf", FileMode.Open)
                Using doc1 As New Document(fs1)
                    For Each page As Page In doc1.Pages
                        outputDoc.Pages.Add(page.Clone())
                    Next
                End Using
            End Using

            ' Load second PDF
            Using fs2 As New FileStream("document2.pdf", FileMode.Open)
                Using doc2 As New Document(fs2)
                    For Each page As Page In doc2.Pages
                        outputDoc.Pages.Add(page.Clone())
                    Next
                End Using
            End Using

            ' Save merged document
            Using output As New FileStream("merged.pdf", FileMode.Create)
                outputDoc.Write(output)
            End Using
        End Using
    End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF-Ansatz:

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        // Load PDFs
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");

        // Merge PDFs
        var merged = PdfDocument.Merge(pdf1, pdf2);

        // Save merged document
        merged.SaveAs("merged.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        // Load PDFs
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");

        // Merge PDFs
        var merged = PdfDocument.Merge(pdf1, pdf2);

        // Save merged document
        merged.SaveAs("merged.pdf");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        ' Load PDFs
        Dim pdf1 = PdfDocument.FromFile("document1.pdf")
        Dim pdf2 = PdfDocument.FromFile("document2.pdf")

        ' Merge PDFs
        Dim merged = PdfDocument.Merge(pdf1, pdf2)

        ' Save merged document
        merged.SaveAs("merged.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Die TallComponents-Version erfordert manuelle Seitenwiederholung und Klonen.IronPDF reduziert dies auf einen einzigen PdfDocument.Merge()-Aufruf. Für fortgeschrittene Zusammenführungsszenarien siehe die PDF-Zusammenführungsdokumentation.

Wasserzeichen hinzufügen

Das Wasserzeichen in PDFs zeigt einen weiteren signifikanten Unterschied in der Erfahrung von Entwicklern.

TallComponents Ansatz:

// NuGet: Install-Package TallComponents.PDF.Kit
using TallComponents.PDF.Kit;
using TallComponents.PDF.Layout;
using System.IO;
using System.Drawing;

class Program
{
    static void Main()
    {
        // Load existing PDF
        using (FileStream fs = new FileStream("input.pdf", FileMode.Open))
        using (Document document = new Document(fs))
        {
            // Iterate through pages
            foreach (Page page in document.Pages)
            {
                // Create watermark text
                TextShape watermark = new TextShape();
                watermark.Text = "CONFIDENTIAL";
                watermark.Font = new Font("Arial", 60);
                watermark.PenColor = Color.FromArgb(128, 255, 0, 0);
                watermark.X = 200;
                watermark.Y = 400;
                watermark.Rotate = 45;

                // Add to page
                page.Overlay.Shapes.Add(watermark);
            }

            // Save document
            using (FileStream output = new FileStream("watermarked.pdf", FileMode.Create))
            {
                document.Write(output);
            }
        }
    }
}
// NuGet: Install-Package TallComponents.PDF.Kit
using TallComponents.PDF.Kit;
using TallComponents.PDF.Layout;
using System.IO;
using System.Drawing;

class Program
{
    static void Main()
    {
        // Load existing PDF
        using (FileStream fs = new FileStream("input.pdf", FileMode.Open))
        using (Document document = new Document(fs))
        {
            // Iterate through pages
            foreach (Page page in document.Pages)
            {
                // Create watermark text
                TextShape watermark = new TextShape();
                watermark.Text = "CONFIDENTIAL";
                watermark.Font = new Font("Arial", 60);
                watermark.PenColor = Color.FromArgb(128, 255, 0, 0);
                watermark.X = 200;
                watermark.Y = 400;
                watermark.Rotate = 45;

                // Add to page
                page.Overlay.Shapes.Add(watermark);
            }

            // Save document
            using (FileStream output = new FileStream("watermarked.pdf", FileMode.Create))
            {
                document.Write(output);
            }
        }
    }
}
Imports TallComponents.PDF.Kit
Imports TallComponents.PDF.Layout
Imports System.IO
Imports System.Drawing

Class Program
    Shared Sub Main()
        ' Load existing PDF
        Using fs As New FileStream("input.pdf", FileMode.Open)
            Using document As New Document(fs)
                ' Iterate through pages
                For Each page As Page In document.Pages
                    ' Create watermark text
                    Dim watermark As New TextShape()
                    watermark.Text = "CONFIDENTIAL"
                    watermark.Font = New Font("Arial", 60)
                    watermark.PenColor = Color.FromArgb(128, 255, 0, 0)
                    watermark.X = 200
                    watermark.Y = 400
                    watermark.Rotate = 45

                    ' Add to page
                    page.Overlay.Shapes.Add(watermark)
                Next

                ' Save document
                Using output As New FileStream("watermarked.pdf", FileMode.Create)
                    document.Write(output)
                End Using
            End Using
        End Using
    End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF-Ansatz:

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

class Program
{
    static void Main()
    {
        // Load existing PDF
        var pdf = PdfDocument.FromFile("input.pdf");

        // Create watermark
        var watermark = new TextStamper()
        {
            Text = "CONFIDENTIAL",
            FontSize = 60,
            Opacity = 50,
            Rotation = 45,
            VerticalAlignment = VerticalAlignment.Middle,
            HorizontalAlignment = HorizontalAlignment.Center
        };

        // Apply watermark to all pages
        pdf.ApplyStamp(watermark);

        // Save watermarked PDF
        pdf.SaveAs("watermarked.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Editing;

class Program
{
    static void Main()
    {
        // Load existing PDF
        var pdf = PdfDocument.FromFile("input.pdf");

        // Create watermark
        var watermark = new TextStamper()
        {
            Text = "CONFIDENTIAL",
            FontSize = 60,
            Opacity = 50,
            Rotation = 45,
            VerticalAlignment = VerticalAlignment.Middle,
            HorizontalAlignment = HorizontalAlignment.Center
        };

        // Apply watermark to all pages
        pdf.ApplyStamp(watermark);

        // Save watermarked PDF
        pdf.SaveAs("watermarked.pdf");
    }
}
Imports IronPdf
Imports IronPdf.Editing

Class Program
    Shared Sub Main()
        ' Load existing PDF
        Dim pdf = PdfDocument.FromFile("input.pdf")

        ' Create watermark
        Dim watermark = New TextStamper() With {
            .Text = "CONFIDENTIAL",
            .FontSize = 60,
            .Opacity = 50,
            .Rotation = 45,
            .VerticalAlignment = VerticalAlignment.Middle,
            .HorizontalAlignment = HorizontalAlignment.Center
        }

        ' Apply watermark to all pages
        pdf.ApplyStamp(watermark)

        ' Save watermarked PDF
        pdf.SaveAs("watermarked.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Die Klasse TextStamper von IronPDF bietet intuitive Ausrichtungsoptionen und automatische Seiteniteration. Der Leitfaden für Stempel und Wasserzeichen behandelt zusätzliche Anpassungsmöglichkeiten.

Digitale Signaturen

Das Signieren von Dokumenten ist für Unternehmensanwendungen von entscheidender Bedeutung.

TallComponents Ansatz:

using TallComponents.PDF.Kit;
using TallComponents.PDF.Kit.Signing;

Document document = new Document("unsigned.pdf");

// Load certificate
X509Certificate2 cert = new X509Certificate2("certificate.pfx", "password");

// Create signature
SignatureHandler handler = new SignatureHandler(cert);
document.Sign(handler);

document.Write("signed.pdf");
using TallComponents.PDF.Kit;
using TallComponents.PDF.Kit.Signing;

Document document = new Document("unsigned.pdf");

// Load certificate
X509Certificate2 cert = new X509Certificate2("certificate.pfx", "password");

// Create signature
SignatureHandler handler = new SignatureHandler(cert);
document.Sign(handler);

document.Write("signed.pdf");
Imports TallComponents.PDF.Kit
Imports TallComponents.PDF.Kit.Signing
Imports System.Security.Cryptography.X509Certificates

Dim document As New Document("unsigned.pdf")

' Load certificate
Dim cert As New X509Certificate2("certificate.pfx", "password")

' Create signature
Dim handler As New SignatureHandler(cert)
document.Sign(handler)

document.Write("signed.pdf")
$vbLabelText   $csharpLabel

IronPDF-Ansatz:

using IronPdf;
using IronPdf.Signing;

var pdf = PdfDocument.FromFile("unsigned.pdf");

// Sign with certificate
var signature = new PdfSignature("certificate.pfx", "password")
{
    SigningContact = "support@company.com",
    SigningLocation = "New York",
    SigningReason = "Document Approval"
};

pdf.Sign(signature);
pdf.SaveAs("signed.pdf");
using IronPdf;
using IronPdf.Signing;

var pdf = PdfDocument.FromFile("unsigned.pdf");

// Sign with certificate
var signature = new PdfSignature("certificate.pfx", "password")
{
    SigningContact = "support@company.com",
    SigningLocation = "New York",
    SigningReason = "Document Approval"
};

pdf.Sign(signature);
pdf.SaveAs("signed.pdf");
Imports IronPdf
Imports IronPdf.Signing

Dim pdf = PdfDocument.FromFile("unsigned.pdf")

' Sign with certificate
Dim signature = New PdfSignature("certificate.pfx", "password") With {
    .SigningContact = "support@company.com",
    .SigningLocation = "New York",
    .SigningReason = "Document Approval"
}

pdf.Sign(signature)
pdf.SaveAs("signed.pdf")
$vbLabelText   $csharpLabel

Die Signatur-API von IronPDF enthält zusätzliche Metadaten-Eigenschaften für Kontaktinformationen, den Standort und den Grund für die Unterzeichnung - wichtig für Prüfpfade. In der Dokumentation zur digitalen Signatur finden Sie ausführliche Informationen zur Implementierung.

Funktionsvergleich: TallComponents gegen IronPDF

Feature TallComponents IronPDF
Status ❌ ABGESCHLOSSEN ✅ Aktiv
Unterstützung ❌ Keine ✅ Vollständig
Aktualisierungen ❌ Keine ✅ Regulär
: Inhaltserstellung : HTML zu PDF Nein Vollständiges Chromium
URL zu PDF Nein Ja
CSS-Unterstützung Nein Vollständig CSS3
JavaScript Nein Vollständiger ES2024
XML-Vorlagen Ja Nicht erforderlich
PDF-Operationen : PDFs zusammenführen Ja Ja
PDFs teilen Ja Ja
Wasserzeichen Handbuch Eingebaut
Kopf-/Fußzeilen XML-basiert HTML/CSS
Sicherheit : Passwortschutz Ja Ja
Digitale Signaturen Ja Ja
Verschlüsselung Ja Ja
PDF/A Beschränkt Ja
Bekannte Probleme : Leere Seiten ⚠️ Dokumentierter Fehler Keine
Fehlende Grafiken ⚠️ Dokumentierter Fehler Keine
Schriftart-Probleme ⚠️ Dokumentierter Fehler Keine
: Entwicklung : Lernkurve Hoch (XML) Niedrig (HTML)
Dokumentation Veraltet Umfangreiche
Gemeinschaft Keine Aktiv

Checkliste für die Migration von TallComponents

Vor der Migration anfallende Aufgaben

Überprüfen Sie Ihre Codebasis, um die Verwendung von TallComponents zu identifizieren:

grep -r "using TallComponents" --include="*.cs" .
grep -r "Document\|Section\|TextParagraph" --include="*.cs" .
grep -r "using TallComponents" --include="*.cs" .
grep -r "Document\|Section\|TextParagraph" --include="*.cs" .
SHELL

Dokumentieren Sie vorhandene XML-Vorlagen und Layouts - diese werden in HTML konvertiert. Identifizieren Sie die derzeit verwendeten Sicherheitseinstellungen und beachten Sie dabei Kennwortkonfigurationen und Implementierungen digitaler Signaturen.

Aufgaben der Code-Aktualisierung

  1. TallComponents-Pakete über NuGet entfernen
  2. IronPDF-Paket installieren
  3. Konvertierung von XML-Layouts in HTML-Vorlagen
  4. Ersetzen des Abschnitts-/Absatzmodells durch HTML-Elemente
  5. Aktualisierung des Tabellencodes zur Verwendung von Standard-HTML-Tabellen
  6. Konvertieren Sie Kopf- und Fußzeilen mit HtmlHeaderFooter in HTML.
  7. Aktualisieren Sie die Sicherheitseinstellungen, um pdf.SecuritySettings zu verwenden.
  8. Lizenzinitialisierung beim Start hinzufügen

Migration von Kopf- und Fußzeilen

TallComponents verwendet XML-basierte Kopfzeilen.IronPDF bietet HTML-basierte Kopfzeilen mit dynamischen Platzhaltern:

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align:center;'>Header Text</div>",
    MaxHeight = 25
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align:center;'>Footer Text</div>",
    MaxHeight = 25
};
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align:center;'>Header Text</div>",
    MaxHeight = 25
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align:center;'>Footer Text</div>",
    MaxHeight = 25
};
Imports System

renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
    .HtmlFragment = "<div style='text-align:center;'>Header Text</div>",
    .MaxHeight = 25
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
    .HtmlFragment = "<div style='text-align:center;'>Footer Text</div>",
    .MaxHeight = 25
}
$vbLabelText   $csharpLabel

Erfahren Sie mehr über Kopf- und Fußzeilen in IronPDF.

Testphase

  1. Vergleich der visuellen Ausgabe zwischen TallComponents- und IronPDF-Versionen
  2. Sicherstellen, dass Probleme mit leeren Seiten behoben werden
  3. Testen Sie alle Dokumentvorlagen
  4. Validierung der PDF-Zusammenführungsfunktion
  5. Digitale Signaturen testen
  6. Bestätigen Sie die korrekte Anwendung der Sicherheitseinstellungen

Empfohlener Zeitplan für die Migration

Angesichts der Tatsache, dass TallComponents nicht mehr unterstützt wird, sollte die Migration dringend erfolgen:

Woche 1: Codebasis prüfen und alle Verwendungen von TallComponents identifizieren
Woche 2: Dokumentvorlagen von XML in HTML konvertieren
Woche 3: Sicherheitsupdates, Zusammenführung und Signierung des Codes
Woche 4: Test und Produktionsbereitstellung

Eine Verzögerung bedeutet, dass nicht unterstützte Software mit dokumentierten Rendering-Fehlern eingesetzt wird - ein Risiko, das kein professionelles Entwicklungsteam auf dem Weg ins Jahr 2026 eingehen sollte.

Wichtige Vorteile der Migration

Der Wechsel von TallComponents zu IronPDF bietet unmittelbare Vorteile:

Moderne Chromium-Rendering-Engine: Die vollständige Unterstützung von CSS und JavaScript gewährleistet, dass PDFs genau wie erwartet gerendert werden, wodurch die in TallComponents dokumentierten Fehler wie leere Seiten und fehlende Grafiken beseitigt werden.

Aktive Wartung und Sicherheitsupdates:IronPDF erhält regelmäßige Updates, um die Kompatibilität mit aktuellen und zukünftigen .NET Versionen, einschließlich .NET 10, zu gewährleisten.

Bessere .NET -Integration: Native Unterstützung für async/await und moderne API-Muster entsprechen den zeitgemäßen C#-Entwicklungspraktiken.

Umfassende Dokumentation: Umfangreiche Tutorials und API-Referenzen unterstützen eine schnelle Implementierung.

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