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

Wie man von Telerik Document Processing zu IronPDF in C# migriert

Curtis Chau
Curtis Chau
Aktualisiert:

Telerik Document Processing dient dem .NET-Ökosystem als Teil der DevCraft-Suite und bietet Entwicklern neben der Word-, Excel- und PowerPoint-Verarbeitung auch Funktionen zur PDF-Erzeugung. Mit der Weiterentwicklung moderner Webstandards und der Forderung nach vollständiger CSS3-, Flexbox- und Bootstrap-Unterstützung stoßen viele Entwicklungsteams jedoch auf grundlegende Einschränkungen in der HTML-to-PDF-Rendering-Architektur von Telerik.

Dieser Leitfaden bietet einen vollständigen Migrationspfad von Telerik Document Processing zu IronPDF, mit Schritt-für-Schritt-Anleitungen, Code-Vergleichen und praktischen Beispielen, die direkt aus realen Migrationsszenarien stammen.

Warum von Telerik Document Processing migrieren

Die Entscheidung, von Telerik Document Processing zu migrieren, rührt in der Regel von technischen Einschränkungen her, die bei der Arbeit mit modernen Webinhalten deutlich werden. Das Verständnis dieser Einschränkungen trägt dazu bei, den Migrationsaufwand zu rechtfertigen und Erwartungen an die Lösung von IronPDF zu wecken.

Kritische technische Beschränkungen

Telerik Document Processing hat grundlegende Probleme beim Umgang mit modernem HTML und CSS:

Problem Auswirkungen IronPDF Lösung
CSS-Parsing-Einschränkungen Moderne CSS-Frameworks wie Bootstrap versagen Vollständige Chromium-CSS-Unterstützung
Umwandlung von Paragraphen in Absätze HTML-Struktur abgeflacht, Layouts aufgebrochen Direkte HTML-Wiedergabe
Flussdokumentmodell Erzwingt Zwischenkonvertierung Natives HTML-zu-PDF
Externe CSS-Probleme Komplexe Selektoren werden ignoriert Vollständige Unterstützung von CSS-Dateien
Speicherprobleme OutOfMemoryException bei großen Dokumenten Effizientes Streaming

Das Kernproblem: HTML wird nicht korrekt gerendert

Telerik Document Processing konvertiert HTML in ein "Flow Document"-Zwischenmodell, bevor es PDF generiert. Diese architektonische Entscheidung führt zu kaskadenartigen Problemen:

  1. Vereinfacht die HTML-Struktur — <div> Elemente werden zu Absätzen
  2. Ignoriert modernes CSS - Flexbox- und Grid-Layouts fallen komplett aus
  3. Bricht Bootstrap - Spaltensysteme werden nicht als Spalten dargestellt
  4. Verlust von Formatierungen - Komplexe CSS-Selektoren werden ignoriert

Betrachten Sie dieses moderne HTML, das Standard-CSS-Layouts verwendet:


<div class="container">
    <div class="row">
        <div class="col-md-6">Column 1</div>
        <div class="col-md-6">Column 2</div>
    </div>
</div>

<div style="display: flex; gap: 20px;">
    <div style="flex: 1;">Flex Item 1</div>
    <div style="flex: 1;">Flex Item 2</div>
</div>

<div style="display: grid; grid-template-columns: repeat(3, 1fr);">
    <div>Grid Item 1</div>
    <div>Grid Item 2</div>
    <div>Grid Item 3</div>
</div>

<div class="container">
    <div class="row">
        <div class="col-md-6">Column 1</div>
        <div class="col-md-6">Column 2</div>
    </div>
</div>

<div style="display: flex; gap: 20px;">
    <div style="flex: 1;">Flex Item 1</div>
    <div style="flex: 1;">Flex Item 2</div>
</div>

<div style="display: grid; grid-template-columns: repeat(3, 1fr);">
    <div>Grid Item 1</div>
    <div>Grid Item 2</div>
    <div>Grid Item 3</div>
</div>
HTML

In Telerik Document Processing werden alle diese Layouts als aufeinanderfolgende Absätze gerendert. Das zweispaltige Bootstrap-Layout wird zu zwei Textzeilen. Die Flexbox-Elemente werden vertikal gestapelt. Die CSS-Gitterelemente erscheinen nacheinander.

CSS-Funktionen, die in der Telerik Document Processing nicht funktionieren

Die Entwickler haben umfangreiche CSS-Kompatibilitätsprobleme dokumentiert:

/* ❌ These CSS features DON'T WORK in Telerik Document Processing*/

/* Flexbox - Nicht unterstützt */
.container { display: flex; }
.item { flex: 1; }

/* CSS Grid - Nicht unterstützt */
.grid { display: grid; grid-template-columns: repeat(3, 1fr); }

/* Bootstrap columns - Converted to paragraphs */
.col-md-6 { /* Ignored, becomes linear text */ }

/* CSS Variables - Nicht unterstützt */
:root { --primary: #007bff; }
.btn { color: var(--primary); }

/* Complex selectors - Often ignored */
.container > .row:first-child { }
.item:hover { }
.content::before { }

/* Modern units - Limited support */
.box { width: calc(100% - 20px); }
.text { font-size: 1.2rem; }

Performance-Probleme mit großen Dokumenten

Neben den Einschränkungen von CSS hat Telerik Document ProcessingOutOfMemoryException-Fehler bei der Verarbeitung großer Dateien dokumentiert. Entwicklungsteams, die mit der Generierung großer Mengen an Dokumenten arbeiten, sind auf Stabilitätsprobleme gestoßen, die andere Bibliotheken effizienter lösen.

IronPDF vs. Telerik Document Processing: Funktionsvergleich

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

Feature Telerik Document Processing IronPDF
HTML-Rendering Konvertierung von Flow-Dokumenten Direkte Chromium-Wiedergabe
CSS3-Unterstützung Begrenzt, viele Funktionen fehlen Vollständig CSS3
Flexbox Nicht unterstützt Unterstützt
CSS Grid Nicht unterstützt Unterstützt
Bootstrap Broken (div flattening) Unterstützt einschließlich Bootstrap 5
Externes CSS Teilweise Unterstützt
JavaScript Nicht unterstützt Vollständige ES2024-Unterstützung
Große Dokumente Memory-Probleme Effizientes Streaming
API-Komplexität Komplex (Anbieter, Modelle) Einfach (eine Klasse)
Lizenzmodell Kommerziell, Teil von DevCraft Einfache Standalone-Lizenzierung

Schnellstart-Migration: in 5 Minuten zu Ihrer ersten PDF-Datei

Die Migration von Telerik Document Processing zu IronPDF kann sofort beginnen. Hier ist der schnellste Weg zur Erstellung Ihrer ersten PDF-Datei mit IronPDF.

Schritt 1: NuGet-Pakete aktualisieren

Entfernen Sie alle Telerik Document Processing-Pakete:

# Remove Telerik packages
dotnet remove package Telerik.Documents.Core
dotnet remove package Telerik.Documents.Flow
dotnet remove package Telerik.Documents.Flow.FormatProviders.Pdf
dotnet remove package Telerik.Documents.Fixed
# Remove Telerik packages
dotnet remove package Telerik.Documents.Core
dotnet remove package Telerik.Documents.Flow
dotnet remove package Telerik.Documents.Flow.FormatProviders.Pdf
dotnet remove package Telerik.Documents.Fixed
SHELL

IronPDF installieren:

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

Schritt 2: Using-Anweisungen aktualisieren

Ersetzen Sie Telerik-Namensräume durch den IronPDF-Namensraum:

// Before (Telerik Document Processing)
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using Telerik.Documents.Primitives;

// After (IronPDF)
using IronPdf;
// Before (Telerik Document Processing)
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using Telerik.Documents.Primitives;

// After (IronPDF)
using IronPdf;
Imports Telerik.Windows.Documents.Flow.FormatProviders.Html
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Flow.Model
Imports Telerik.Documents.Primitives

' After (IronPDF)
Imports IronPdf
$vbLabelText   $csharpLabel

Schritt 3: Lizenzschlüssel hinzufügen

Initialisieren Sie Ihre Lizenz beim Starten der Anwendung:

// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
' Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Schritt 4: Aktualisieren Sie Ihren PDF-Erzeugungscode

Die Umstellung von Telerik Document Processing auf IronPDF vereinfacht Ihre Codebasis drastisch.

Vor (Telerik Document Processing):

using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;

HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(htmlContent);

PdfFormatProvider pdfProvider = new PdfFormatProvider();
byte[] pdfBytes = pdfProvider.Export(document);

File.WriteAllBytes("output.pdf", pdfBytes);
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;

HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(htmlContent);

PdfFormatProvider pdfProvider = new PdfFormatProvider();
byte[] pdfBytes = pdfProvider.Export(document);

File.WriteAllBytes("output.pdf", pdfBytes);
Imports Telerik.Windows.Documents.Flow.FormatProviders.Html
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Flow.Model

Dim htmlProvider As New HtmlFormatProvider()
Dim document As RadFlowDocument = htmlProvider.Import(htmlContent)

Dim pdfProvider As New PdfFormatProvider()
Dim pdfBytes As Byte() = pdfProvider.Export(document)

File.WriteAllBytes("output.pdf", pdfBytes)
$vbLabelText   $csharpLabel

Nach (IronPDF):

using IronPdf;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("output.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("output.pdf");
Imports IronPdf

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

Der Unterschied ist sofort ersichtlich: 3 Zeilen IronPDF-Code ersetzen 15+ Zeilen Telerik Document Processing-Code. Noch wichtiger ist, dass die IronPDF-Version modernes CSS korrekt wiedergibt, das das Flow Document-Modell von Telerik nicht verarbeiten kann.

Beispiele für die Code-Migration

Konvertierung von HTML in PDF

Dies ist der häufigste Anwendungsfall für die PDF-Erstellung. Die architektonischen Unterschiede zwischen Telerik Document Processing und IronPDF werden in diesem Vergleich deutlich.

Telerik Dokumentverarbeitungsansatz:

// NuGet: Install-Package Telerik.Documents.Flow
// NuGet: Install-Package Telerik.Documents.Flow.FormatProviders.Pdf
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using System.IO;

string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";

HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(html);

PdfFormatProvider pdfProvider = new PdfFormatProvider();
using (FileStream output = File.OpenWrite("output.pdf"))
{
    pdfProvider.Export(document, output);
}
// NuGet: Install-Package Telerik.Documents.Flow
// NuGet: Install-Package Telerik.Documents.Flow.FormatProviders.Pdf
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using System.IO;

string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";

HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(html);

PdfFormatProvider pdfProvider = new PdfFormatProvider();
using (FileStream output = File.OpenWrite("output.pdf"))
{
    pdfProvider.Export(document, output);
}
Imports Telerik.Windows.Documents.Flow.FormatProviders.Html
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Flow.Model
Imports System.IO

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

Dim htmlProvider As New HtmlFormatProvider()
Dim document As RadFlowDocument = htmlProvider.Import(html)

Dim pdfProvider As New PdfFormatProvider()
Using output As FileStream = File.OpenWrite("output.pdf")
    pdfProvider.Export(document, output)
End Using
$vbLabelText   $csharpLabel

IronPDF-Ansatz:

// NuGet: Install-Package IronPdf
using IronPdf;

string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";

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

string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";

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

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

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

Die Telerik-Version erfordert das Erstellen eines HtmlFormatProvider, das Importieren in ein RadFlowDocument, das Erstellen eines PdfFormatProvider und die manuelle Verwaltung von Dateiströmen. IronPDF's ChromePdfRenderer erledigt den gesamten Prozess mit einem einzigen Methodenaufruf.

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

Konvertierung von URLs zu PDF

Bei der Erfassung von Webseiten als PDF-Dateien zeigt sich ein weiterer wesentlicher Unterschied zwischen den Bibliotheken.

Telerik Dokumentverarbeitungsansatz:

// NuGet: Install-Package Telerik.Documents.Flow
// NuGet: Install-Package Telerik.Documents.Flow.FormatProviders.Pdf
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

string url = "https://example.com";

using HttpClient client = new HttpClient();
string html = await client.GetStringAsync(url);

HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(html);

PdfFormatProvider pdfProvider = new PdfFormatProvider();
using (FileStream output = File.OpenWrite("webpage.pdf"))
{
    pdfProvider.Export(document, output);
}
// NuGet: Install-Package Telerik.Documents.Flow
// NuGet: Install-Package Telerik.Documents.Flow.FormatProviders.Pdf
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

string url = "https://example.com";

using HttpClient client = new HttpClient();
string html = await client.GetStringAsync(url);

HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(html);

PdfFormatProvider pdfProvider = new PdfFormatProvider();
using (FileStream output = File.OpenWrite("webpage.pdf"))
{
    pdfProvider.Export(document, output);
}
Imports Telerik.Windows.Documents.Flow.FormatProviders.Html
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Flow.Model
Imports System.IO
Imports System.Net.Http
Imports System.Threading.Tasks

Module Module1
    Sub Main()
        Dim url As String = "https://example.com"

        Using client As New HttpClient()
            Dim html As String = Await client.GetStringAsync(url)

            Dim htmlProvider As New HtmlFormatProvider()
            Dim document As RadFlowDocument = htmlProvider.Import(html)

            Dim pdfProvider As New PdfFormatProvider()
            Using output As FileStream = File.OpenWrite("webpage.pdf")
                pdfProvider.Export(document, output)
            End Using
        End Using
    End Sub
End Module
$vbLabelText   $csharpLabel

IronPDF-Ansatz:

// NuGet: Install-Package IronPdf
using IronPdf;

string url = "https://example.com";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf(url);
pdf.SaveAs("webpage.pdf");
// NuGet: Install-Package IronPdf
using IronPdf;

string url = "https://example.com";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf(url);
pdf.SaveAs("webpage.pdf");
Imports IronPdf

Dim url As String = "https://example.com"

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderUrlAsPdf(url)
pdf.SaveAs("webpage.pdf")
$vbLabelText   $csharpLabel

Telerik Document Processing hat keine native URL-zu-PDF-Funktion. Sie müssen HTML-Inhalte manuell mit HttpClient abrufen, wodurch externes CSS, JavaScript-Ausführung und dynamische Inhalte verloren gehen. Die Methode RenderUrlAsPdf von IronPDF erfasst die gesamte gerenderte Seite genau so, wie sie im Browser angezeigt wird.

In der URL zur PDF-Dokumentation finden Sie zusätzliche Optionen wie Authentifizierung und benutzerdefinierte Kopfzeilen.

Mehrere PDFs zusammenführen

Die PDF-Zusammenführung demonstriert den Unterschied in der Ausführlichkeit dieser .NET-PDF-Bibliotheken.

Telerik Dokumentverarbeitungsansatz:

// NuGet: Install-Package Telerik.Documents.Fixed
using Telerik.Windows.Documents.Fixed.FormatProviders.Pdf;
using Telerik.Windows.Documents.Fixed.Model;
using System.IO;

PdfFormatProvider provider = new PdfFormatProvider();

RadFixedDocument document1;
using (FileStream input = File.OpenRead("document1.pdf"))
{
    document1 = provider.Import(input);
}

RadFixedDocument document2;
using (FileStream input = File.OpenRead("document2.pdf"))
{
    document2 = provider.Import(input);
}

RadFixedDocument mergedDocument = new RadFixedDocument();
foreach (var page in document1.Pages)
{
    mergedDocument.Pages.Add(page);
}
foreach (var page in document2.Pages)
{
    mergedDocument.Pages.Add(page);
}

using (FileStream output = File.OpenWrite("merged.pdf"))
{
    provider.Export(mergedDocument, output);
}
// NuGet: Install-Package Telerik.Documents.Fixed
using Telerik.Windows.Documents.Fixed.FormatProviders.Pdf;
using Telerik.Windows.Documents.Fixed.Model;
using System.IO;

PdfFormatProvider provider = new PdfFormatProvider();

RadFixedDocument document1;
using (FileStream input = File.OpenRead("document1.pdf"))
{
    document1 = provider.Import(input);
}

RadFixedDocument document2;
using (FileStream input = File.OpenRead("document2.pdf"))
{
    document2 = provider.Import(input);
}

RadFixedDocument mergedDocument = new RadFixedDocument();
foreach (var page in document1.Pages)
{
    mergedDocument.Pages.Add(page);
}
foreach (var page in document2.Pages)
{
    mergedDocument.Pages.Add(page);
}

using (FileStream output = File.OpenWrite("merged.pdf"))
{
    provider.Export(mergedDocument, output);
}
Imports Telerik.Windows.Documents.Fixed.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Fixed.Model
Imports System.IO

Dim provider As New PdfFormatProvider()

Dim document1 As RadFixedDocument
Using input As FileStream = File.OpenRead("document1.pdf")
    document1 = provider.Import(input)
End Using

Dim document2 As RadFixedDocument
Using input As FileStream = File.OpenRead("document2.pdf")
    document2 = provider.Import(input)
End Using

Dim mergedDocument As New RadFixedDocument()
For Each page In document1.Pages
    mergedDocument.Pages.Add(page)
Next
For Each page In document2.Pages
    mergedDocument.Pages.Add(page)
Next

Using output As FileStream = File.OpenWrite("merged.pdf")
    provider.Export(mergedDocument, output)
End Using
$vbLabelText   $csharpLabel

IronPDF-Ansatz:

// NuGet: Install-Package IronPdf
using IronPdf;

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;

var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");

var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");
Imports IronPdf

Dim pdf1 = PdfDocument.FromFile("document1.pdf")
Dim pdf2 = PdfDocument.FromFile("document2.pdf")

Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("merged.pdf")
$vbLabelText   $csharpLabel

Bei der Telerik-Version muss jedes Dokument einzeln importiert werden, die Seiten müssen manuell durchlaufen und einem neuen Dokument hinzugefügt werden, und es müssen mehrere Dateiströme verwaltet werden. Die Methode PdfDocument.Merge() von IronPDF erledigt alles in einem einzigen Aufruf.

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

Telerik Document Processing API zu IronPDF Mapping

Diese Referenztabelle beschleunigt die Migration, indem sie direkte API-Entsprechungen aufzeigt:

Telerik Document Processing IronPDF
HtmlFormatProvider ChromePdfRenderer
RadFlowDocument Nicht erforderlich
PdfFormatProvider pdf.SaveAs()
RadFlowDocumentEditor HTML-Bearbeitung
Section HTML <section>
Paragraph HTML <p>
PdfExportSettings RenderingOptions
RadFixedDocument PdfDocument
Manuelle Seitenüberarbeitung PdfDocument.Merge()

Handhabung von Kopf- und Fußzeilen

Telerik Document Processing verwendet ein programmatisches Modell für Kopf- und Fußzeilen. IronPDF bietet HTML-basierte Kopfzeilen mit dynamischen Platzhaltern.

Telerik Dokumentenverarbeitung:

section.Headers.Default.Blocks.AddParagraph().Inlines.AddRun("Header Text");
section.Footers.Default.Blocks.AddParagraph().Inlines.AddRun("Footer Text");
section.Headers.Default.Blocks.AddParagraph().Inlines.AddRun("Header Text");
section.Footers.Default.Blocks.AddParagraph().Inlines.AddRun("Footer Text");
section.Headers.Default.Blocks.AddParagraph().Inlines.AddRun("Header Text")
section.Footers.Default.Blocks.AddParagraph().Inlines.AddRun("Footer Text")
$vbLabelText   $csharpLabel

IronPDF:

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

Der HTML-basierte Ansatz von IronPDF ermöglicht ein vollständiges CSS-Styling in Kopf- und Fußzeilen sowie dynamische Platzhalter für Seitenzahlen und Daten. Weitere Informationen finden Sie in der Kopf- und Fußzeilen-Dokumentation.

Umrechnung von Einheiten: DIPs zu Millimetern

Telerik Document Processing verwendet geräteunabhängige Pixel (DIPs) für Messungen. IronPDF arbeitet mit Millimetern. Dies erfordert eine Konvertierung während der Migration:

// Telerik uses DIPs (device-independent pixels)
//IronPDF uses millimeters

// 1 inch = 25.4mm
renderer.RenderingOptions.MarginTop = 25.4;    // 1 inch
renderer.RenderingOptions.MarginBottom = 25.4;

// Or use the helper method for paper size
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11);
// Telerik uses DIPs (device-independent pixels)
//IronPDF uses millimeters

// 1 inch = 25.4mm
renderer.RenderingOptions.MarginTop = 25.4;    // 1 inch
renderer.RenderingOptions.MarginBottom = 25.4;

// Or use the helper method for paper size
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11);
' Telerik uses DIPs (device-independent pixels)
' IronPDF uses millimeters

' 1 inch = 25.4mm
renderer.RenderingOptions.MarginTop = 25.4    ' 1 inch
renderer.RenderingOptions.MarginBottom = 25.4

' Or use the helper method for paper size
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11)
$vbLabelText   $csharpLabel

Telerik Document Processing Migration Checkliste

Vor der Migration anfallende Aufgaben

Überprüfen Sie Ihre Codebasis, um alle Verwendungen von Telerik Document Processing zu identifizieren:

grep -r "using Telerik.Windows.Documents" --include="*.cs" .
grep -r "RadFlowDocument\|HtmlFormatProvider\|PdfFormatProvider" --include="*.cs" .
grep -r "using Telerik.Windows.Documents" --include="*.cs" .
grep -r "RadFlowDocument\|HtmlFormatProvider\|PdfFormatProvider" --include="*.cs" .
SHELL

Dokumentieren Sie bestehende Implementierungen, einschließlich verwendeter Formatanbieter, Kopf-/Fußzeilenkonfigurationen, benutzerdefinierter Seiteneinstellungen und aller Änderungen am Flow Document-Modell.

Während der Migration

  1. Telerik NuGet-Pakete entfernen
  2. IronPDF NuGet-Paket installieren
  3. Aktualisieren Sie die Anweisungen von Telerik.Windows.Documents bis IronPdf
  4. Initialisierung des Lizenzschlüssels beim Start hinzufügen
  5. Ersetzen Sie HtmlFormatProvider durch ChromePdfRenderer
  6. Entfernen Sie die Zwischenschritte RadFlowDocument
  7. Ersetzen Sie PdfFormatProvider-Exporte durch direkte SaveAs()-Aufrufe
  8. Aktualisieren Sie Kopf- und Fußzeilen, um HtmlHeaderFooter zu verwenden.
  9. Seiteneinstellungen konvertieren in RenderingOptions
  10. Aktualisierung der Randeinheiten von DIPs zu Millimetern

Post-Migrationsüberprüfung

Überprüfen Sie diese Verbesserungen nach der Migration:

  • Das CSS-Rendering sollte deutlich verbessert werden
  • Bootstrap-Layouts sollten korrekt gerendert werden (das tun sie in Telerik nicht)
  • Flexbox- und Grid-Layouts sollten funktionieren (in Telerik funktionieren sie nicht)
  • Die Ausführung von JavaScript sollte für dynamische Inhalte funktionieren
  • Die Generierung großer Dokumente sollte ohne Memory-Ausnahmen ablaufen

Die wichtigsten Vorteile der Migration zu IronPDF

Der Wechsel von Telerik Document Processing zu IronPDF bringt unmittelbare Vorteile mit sich:

Moderne Chromium-Rendering-Engine: IronPDF verwendet dieselbe Rendering-Engine wie Google Chrome, wodurch sichergestellt wird, dass PDFs genau so dargestellt werden, wie der Inhalt in modernen Browsern erscheint. Dadurch werden die CSS-Kompatibilitätsprobleme, die mit dem Flow-Dokumentenmodell von Telerik einhergehen, beseitigt.

Volle CSS3- und JavaScript Unterstützung: Flexbox, Grid, Bootstrap 5, CSS-Variablen und modernes JavaScript funktionieren einwandfrei. Da die Verbreitung von .NET 10 und C# 14 bis 2026 zunimmt, gewährleistet die moderne Darstellung von IronPDF die Kompatibilität mit aktuellen Webstandards.

Einfachere API: Weniger Codezeilen, keine Zwischendokumentmodelle und intuitive Methodennamen reduzieren Entwicklungszeit und Wartungsaufwand.

Einzelplatzlizenzierung: IronPDF bietet eine unkomplizierte Lizenzierung, ohne dass der Kauf einer kompletten Suite erforderlich ist. Dies ist eine kostengünstige Lösung für Teams, die lediglich PDF-Funktionen benötigen.

Aktive Weiterentwicklung: Regelmäßige Updates gewährleisten Kompatibilität mit aktuellen und zukünftigen .NET Versionen, Sicherheitspatches und Funktionserweiterungen.

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