VIDEOS

Aufteilung einer mehrseitigen PDF-Datei mit IronPDF in C# | IronPDF

Aktualisiert:19. Juli 2026

Winnovative ist ein anerkannter Name im Bereich der .NET-PDF-Generierung und bietet HTML-zu-PDF-Konvertierungsfunktionen für C#-Anwendungen. Allerdings basiert die langlaufende Classic-Bibliothek auf einem älteren proprietären Rendering-Engine, und ihre Unterstützung für moderne CSS (Grid, aktuelle Flexbox) und modernen JavaScript (ES2017+) ist im Vergleich zu einem aktuellen Chromium-Browser uneinheitlich. Die Antwort des Anbieters war, ein separates Produkt der Chromium-Klasse, Winnovative.Pdf.Next, zu versenden, anstatt Classic vor Ort zu aktualisieren – was bedeutet, dass bestehende Winnovative-Kunden so oder so eine Code-Migration vornehmen müssen.

Dieser Leitfaden bietet einen Migrationspfad von Winnovative zu IronPDF, mit Schritt-für-Schritt-Anleitungen, Codevergleichen und praktischen Beispielen for .NET-Entwickler, die diesen Übergang bewerten.

Warum von Winnovative migrieren

Winnovatives Classic- Bibliothek nutzt eine ältere proprietäre Engine, die nicht auf moderne Webstandards aktualisiert wurde:

Uneinheitliches CSS Grid / moderne Flexbox: Layouts, die auf CSS Grid oder aktuelle Flexbox-Funktionen basieren, können im Vergleich zu einem aktuellen Chromium-Browser falsch dargestellt werden.

Moderne JavaScript-Kompatibilitätslücken: ES2017+ Funktionen (Pfeilfunktionen, async/await, Klassen) werden nicht zuverlässig ausgeführt, was sich auf React, Vue und andere moderne Frameworks auswirkt.

Langsame Cadenz: Die Classic-Engine erhält seltene Aktualisierungen des Rendering-Engines; Die Antwort des Anbieters war, das separate Produkt der Chromium-Klasse Winnovative.Pdf.Next zu versenden, wodurch Classic in seinen Funktionen eingefroren bleibt.

Zwei-Produkt-Migrationslast: Der Umzug zu Winnovative.Pdf.Next ist selbst eine Neufassung – die Next-API lebt unter einem anderen Namespace (Winnovative.Pdf.Next) und ist binär inkompatibel mit Classic.

Schriftdarstellungsrandfälle: Web-Schriften und benutzerdefinierte Typografien stellen sich manchmal anders dar als ein moderner Browser.

Wirkung in der realen Welt

Moderne CSS und JavaScript, die inkonsistent inWinnovative Classicgerendert werden können:


<div style="display: grid; grid-template-columns: repeat(3, 1fr); gap: 20px;">
  <div>Column 1</div>
  <div>Column 2</div>
  <div>Column 3</div>
</div>

<script>
const items = data.map(item => item.name);
const result = await fetchData();
class Report { }
</script>


<div style="display: grid; grid-template-columns: repeat(3, 1fr); gap: 20px;">
  <div>Column 1</div>
  <div>Column 2</div>
  <div>Column 3</div>
</div>

<script>
const items = data.map(item => item.name);
const result = await fetchData();
class Report { }
</script>

HTML

IronPDF vs. Winnovative: Funktionsvergleich

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

Aspekt	Winnovative Classic	IronPDF
Rendering Engine	Ältere proprietäre Engine	Chromium (aktuell)
CSS Grid	Inkonsistent	Volle Unterstützung
Flexbox	Inkonsistent bei Randfällen	Volle Unterstützung
JavaScript	Eingeschränkt modernes JS	ES2024
Bootstrap 5	Layout-Probleme	Volle Unterstützung
Tailwind CSS	Beschränkt	Volle Unterstützung
React/Vue SSR	Problematisch	Funktioniert
Web-Schriftarten	Unzuverlässig in einigen Setups	Volle Unterstützung
Aktualisierungen	Unregelmäßig	Monatlich
Preis (pro Entwickler)	$450 Bereitstellung / $1.200 Weiterverbreitung	See ironpdf.com/pricing

Schnellstart: Migration von Winnovative zu IronPDF

Mit diesen grundlegenden Schritten kann die Migration sofort beginnen.

Schritt 1: Ersetzen von NuGet-Paketen

Entfernen Sie alle Winnovative-Pakete (überprüfen Sie, welche Ihr Projekt tatsächlich verwendet):

# Remove Winnovative (Classic + related utilities)
dotnet remove package Winnovative.HtmlToPdf
# Also remove any of these your project references:
# dotnet remove package Winnovative.PdfMerge
# dotnet remove package Winnovative.PdfSecurity
# dotnet remove package Winnovative.Pdf.Next.Core
# dotnet remove package Winnovative.Client

# Remove Winnovative (Classic + related utilities)
dotnet remove package Winnovative.HtmlToPdf
# Also remove any of these your project references:
# dotnet remove package Winnovative.PdfMerge
# dotnet remove package Winnovative.PdfSecurity
# dotnet remove package Winnovative.Pdf.Next.Core
# dotnet remove package Winnovative.Client

SHELL

IronPDF installieren:

# Install IronPDF
dotnet add package IronPdf

# Install IronPDF
dotnet add package IronPdf

SHELL

Schritt 2: Namespaces aktualisieren

Ersetzen Sie die Winnovative-Namespaces durch den IronPDF-Namespace:

// Before (Winnovative)
using Winnovative;
using Winnovative.WebKit;

// After (IronPDF)
using IronPdf;

// Before (Winnovative)
using Winnovative;
using Winnovative.WebKit;

// After (IronPDF)
using 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 demonstriert die API-Unterschiede zwischen diesen .NET-PDF-Bibliotheken.

Innovativer Ansatz:

// NuGet: Install-Package Winnovative.HtmlToPdf
using Winnovative;
using System;

class Program
{
    static void Main()
    {
        // Create the HTML to PDF converter
        HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();

        // Set license key
        htmlToPdfConverter.LicenseKey = "your-license-key";

        // Convert HTML string to PDF
        string htmlString = "<html><body><h1>Hello World</h1></body></html>";
        byte[] pdfBytes = htmlToPdfConverter.ConvertHtml(htmlString, "");

        // Save to file
        System.IO.File.WriteAllBytes("output.pdf", pdfBytes);

        Console.WriteLine("PDF created successfully");
    }
}

// NuGet: Install-Package Winnovative.HtmlToPdf
using Winnovative;
using System;

class Program
{
    static void Main()
    {
        // Create the HTML to PDF converter
        HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();

        // Set license key
        htmlToPdfConverter.LicenseKey = "your-license-key";

        // Convert HTML string to PDF
        string htmlString = "<html><body><h1>Hello World</h1></body></html>";
        byte[] pdfBytes = htmlToPdfConverter.ConvertHtml(htmlString, "");

        // Save to file
        System.IO.File.WriteAllBytes("output.pdf", pdfBytes);

        Console.WriteLine("PDF created successfully");
    }
}

Imports Winnovative
Imports System

Module Program
    Sub Main()
        ' Create the HTML to PDF converter
        Dim htmlToPdfConverter As New HtmlToPdfConverter()

        ' Set license key
        htmlToPdfConverter.LicenseKey = "your-license-key"

        ' Convert HTML string to PDF
        Dim htmlString As String = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdfBytes As Byte() = htmlToPdfConverter.ConvertHtml(htmlString, "")

        ' Save to file
        System.IO.File.WriteAllBytes("output.pdf", pdfBytes)

        Console.WriteLine("PDF created successfully")
    End Sub
End Module

$vbLabelText $csharpLabel

IronPDF-Ansatz:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        // Create a PDF renderer
        var renderer = new ChromePdfRenderer();

        // Convert HTML string to PDF
        string htmlString = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(htmlString);

        // Save to file
        pdf.SaveAs("output.pdf");

        Console.WriteLine("PDF created successfully");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        // Create a PDF renderer
        var renderer = new ChromePdfRenderer();

        // Convert HTML string to PDF
        string htmlString = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(htmlString);

        // Save to file
        pdf.SaveAs("output.pdf");

        Console.WriteLine("PDF created successfully");
    }
}

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        ' Create a PDF renderer
        Dim renderer As New ChromePdfRenderer()

        ' Convert HTML string to PDF
        Dim htmlString As String = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(htmlString)

        ' Save to file
        pdf.SaveAs("output.pdf")

        Console.WriteLine("PDF created successfully")
    End Sub
End Class

$vbLabelText $csharpLabel

Winnovative erfordert die Erstellung eines HtmlToPdfConverter, das Setzen eines Lizenzschlüssels auf der Instanz, das Aufrufen von ConvertHtml() mit einem leeren Basis-URL-Parameter, das Empfangen von Rohbytes und das manuelle Schreiben in eine Datei.IronPDF vereinfacht dies: Erstellen Sie ein ChromePdfRenderer, rufen Sie RenderHtmlAsPdf() auf und nutzen Sie die integrierte Methode SaveAs().

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

Konvertierung von URLs zu PDF

Die URL-zu-PDF-Konvertierung zeigt ähnliche Muster.

Innovativer Ansatz:

// NuGet: Install-Package Winnovative.HtmlToPdf
using Winnovative;
using System;

class Program
{
    static void Main()
    {
        // Create the HTML to PDF converter
        HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();

        // Set license key
        htmlToPdfConverter.LicenseKey = "your-license-key";

        // Convert URL to PDF
        string url = "https://www.example.com";
        byte[] pdfBytes = htmlToPdfConverter.ConvertUrl(url);

        // Save to file
        System.IO.File.WriteAllBytes("webpage.pdf", pdfBytes);

        Console.WriteLine("PDF from URL created successfully");
    }
}

// NuGet: Install-Package Winnovative.HtmlToPdf
using Winnovative;
using System;

class Program
{
    static void Main()
    {
        // Create the HTML to PDF converter
        HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();

        // Set license key
        htmlToPdfConverter.LicenseKey = "your-license-key";

        // Convert URL to PDF
        string url = "https://www.example.com";
        byte[] pdfBytes = htmlToPdfConverter.ConvertUrl(url);

        // Save to file
        System.IO.File.WriteAllBytes("webpage.pdf", pdfBytes);

        Console.WriteLine("PDF from URL created successfully");
    }
}

Imports Winnovative
Imports System

Module Program
    Sub Main()
        ' Create the HTML to PDF converter
        Dim htmlToPdfConverter As New HtmlToPdfConverter()

        ' Set license key
        htmlToPdfConverter.LicenseKey = "your-license-key"

        ' Convert URL to PDF
        Dim url As String = "https://www.example.com"
        Dim pdfBytes As Byte() = htmlToPdfConverter.ConvertUrl(url)

        ' Save to file
        System.IO.File.WriteAllBytes("webpage.pdf", pdfBytes)

        Console.WriteLine("PDF from URL created successfully")
    End Sub
End Module

$vbLabelText $csharpLabel

IronPDF-Ansatz:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        // Create a PDF renderer
        var renderer = new ChromePdfRenderer();

        // Convert URL to PDF
        string url = "https://www.example.com";
        var pdf = renderer.RenderUrlAsPdf(url);

        // Save to file
        pdf.SaveAs("webpage.pdf");

        Console.WriteLine("PDF from URL created successfully");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        // Create a PDF renderer
        var renderer = new ChromePdfRenderer();

        // Convert URL to PDF
        string url = "https://www.example.com";
        var pdf = renderer.RenderUrlAsPdf(url);

        // Save to file
        pdf.SaveAs("webpage.pdf");

        Console.WriteLine("PDF from URL created successfully");
    }
}

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        ' Create a PDF renderer
        Dim renderer As New ChromePdfRenderer()

        ' Convert URL to PDF
        Dim url As String = "https://www.example.com"
        Dim pdf = renderer.RenderUrlAsPdf(url)

        ' Save to file
        pdf.SaveAs("webpage.pdf")

        Console.WriteLine("PDF from URL created successfully")
    End Sub
End Class

$vbLabelText $csharpLabel

Winnovative verwendet ConvertUrl(), das Bytes zurückgibt, die manuell gespeichert werden müssen.IronPDF bietet RenderUrlAsPdf() mit einem PdfDocument-Objekt, das SaveAs() zur Verfügung stellt.

In der URL zur PDF-Dokumentation finden Sie Informationen zur Authentifizierung und zu benutzerdefinierten Kopfzeilenoptionen.

Kopf- und Fußzeilen einfügen

In den Kopf- und Fußzeilen sind erhebliche Unterschiede in der Architektur zu erkennen. Winnovative verwendet einen programmatischen elementbasierten Ansatz mit TextElement-Objekten, während IronPDF HTML-basierte Header mit Platzhalter-Token verwendet.

Innovativer Ansatz:

// NuGet: Install-Package Winnovative.HtmlToPdf
using Winnovative;
using System;
using System.Drawing;

class Program
{
    static void Main()
    {
        // Create the HTML to PDF converter
        HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();

        // Set license key
        htmlToPdfConverter.LicenseKey = "your-license-key";

        // Enable header
        htmlToPdfConverter.PdfDocumentOptions.ShowHeader = true;
        htmlToPdfConverter.PdfHeaderOptions.HeaderHeight = 60;

        // Add header text
        TextElement headerText = new TextElement(0, 0, "Document Header", new Font("Arial", 12));
        htmlToPdfConverter.PdfHeaderOptions.AddElement(headerText);

        // Enable footer
        htmlToPdfConverter.PdfDocumentOptions.ShowFooter = true;
        htmlToPdfConverter.PdfFooterOptions.FooterHeight = 60;

        // Add footer with page number
        TextElement footerText = new TextElement(0, 0, "Page &p; of &P;", new Font("Arial", 10));
        htmlToPdfConverter.PdfFooterOptions.AddElement(footerText);

        // Convert HTML to PDF
        string htmlString = "<html><body><h1>Document with Header and Footer</h1><p>Content goes here</p></body></html>";
        byte[] pdfBytes = htmlToPdfConverter.ConvertHtml(htmlString, "");

        // Save to file
        System.IO.File.WriteAllBytes("document.pdf", pdfBytes);

        Console.WriteLine("PDF with header and footer created successfully");
    }
}

// NuGet: Install-Package Winnovative.HtmlToPdf
using Winnovative;
using System;
using System.Drawing;

class Program
{
    static void Main()
    {
        // Create the HTML to PDF converter
        HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();

        // Set license key
        htmlToPdfConverter.LicenseKey = "your-license-key";

        // Enable header
        htmlToPdfConverter.PdfDocumentOptions.ShowHeader = true;
        htmlToPdfConverter.PdfHeaderOptions.HeaderHeight = 60;

        // Add header text
        TextElement headerText = new TextElement(0, 0, "Document Header", new Font("Arial", 12));
        htmlToPdfConverter.PdfHeaderOptions.AddElement(headerText);

        // Enable footer
        htmlToPdfConverter.PdfDocumentOptions.ShowFooter = true;
        htmlToPdfConverter.PdfFooterOptions.FooterHeight = 60;

        // Add footer with page number
        TextElement footerText = new TextElement(0, 0, "Page &p; of &P;", new Font("Arial", 10));
        htmlToPdfConverter.PdfFooterOptions.AddElement(footerText);

        // Convert HTML to PDF
        string htmlString = "<html><body><h1>Document with Header and Footer</h1><p>Content goes here</p></body></html>";
        byte[] pdfBytes = htmlToPdfConverter.ConvertHtml(htmlString, "");

        // Save to file
        System.IO.File.WriteAllBytes("document.pdf", pdfBytes);

        Console.WriteLine("PDF with header and footer created successfully");
    }
}

Imports Winnovative
Imports System
Imports System.Drawing

Module Program
    Sub Main()
        ' Create the HTML to PDF converter
        Dim htmlToPdfConverter As New HtmlToPdfConverter()

        ' Set license key
        htmlToPdfConverter.LicenseKey = "your-license-key"

        ' Enable header
        htmlToPdfConverter.PdfDocumentOptions.ShowHeader = True
        htmlToPdfConverter.PdfHeaderOptions.HeaderHeight = 60

        ' Add header text
        Dim headerText As New TextElement(0, 0, "Document Header", New Font("Arial", 12))
        htmlToPdfConverter.PdfHeaderOptions.AddElement(headerText)

        ' Enable footer
        htmlToPdfConverter.PdfDocumentOptions.ShowFooter = True
        htmlToPdfConverter.PdfFooterOptions.FooterHeight = 60

        ' Add footer with page number
        Dim footerText As New TextElement(0, 0, "Page &p; of &P;", New Font("Arial", 10))
        htmlToPdfConverter.PdfFooterOptions.AddElement(footerText)

        ' Convert HTML to PDF
        Dim htmlString As String = "<html><body><h1>Document with Header and Footer</h1><p>Content goes here</p></body></html>"
        Dim pdfBytes As Byte() = htmlToPdfConverter.ConvertHtml(htmlString, "")

        ' Save to file
        System.IO.File.WriteAllBytes("document.pdf", pdfBytes)

        Console.WriteLine("PDF with header and footer created successfully")
    End Sub
End Module

$vbLabelText $csharpLabel

IronPDF-Ansatz:

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

class Program
{
    static void Main()
    {
        // Create a PDF renderer
        var renderer = new ChromePdfRenderer();

        // Configure header and footer
        renderer.RenderingOptions.TextHeader = new TextHeaderFooter()
        {
            CenterText = "Document Header",
            FontSize = 12
        };

        renderer.RenderingOptions.TextFooter = new TextHeaderFooter()
        {
            CenterText = "Page {page} of {total-pages}",
            FontSize = 10
        };

        // Convert HTML to PDF
        string htmlString = "<html><body><h1>Document with Header and Footer</h1><p>Content goes here</p></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(htmlString);

        // Save to file
        pdf.SaveAs("document.pdf");

        Console.WriteLine("PDF with header and footer created successfully");
    }
}

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

class Program
{
    static void Main()
    {
        // Create a PDF renderer
        var renderer = new ChromePdfRenderer();

        // Configure header and footer
        renderer.RenderingOptions.TextHeader = new TextHeaderFooter()
        {
            CenterText = "Document Header",
            FontSize = 12
        };

        renderer.RenderingOptions.TextFooter = new TextHeaderFooter()
        {
            CenterText = "Page {page} of {total-pages}",
            FontSize = 10
        };

        // Convert HTML to PDF
        string htmlString = "<html><body><h1>Document with Header and Footer</h1><p>Content goes here</p></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(htmlString);

        // Save to file
        pdf.SaveAs("document.pdf");

        Console.WriteLine("PDF with header and footer created successfully");
    }
}

Imports IronPdf
Imports IronPdf.Rendering
Imports System

Module Program
    Sub Main()
        ' Create a PDF renderer
        Dim renderer As New ChromePdfRenderer()

        ' Configure header and footer
        renderer.RenderingOptions.TextHeader = New TextHeaderFooter() With {
            .CenterText = "Document Header",
            .FontSize = 12
        }

        renderer.RenderingOptions.TextFooter = New TextHeaderFooter() With {
            .CenterText = "Page {page} of {total-pages}",
            .FontSize = 10
        }

        ' Convert HTML to PDF
        Dim htmlString As String = "<html><body><h1>Document with Header and Footer</h1><p>Content goes here</p></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(htmlString)

        ' Save to file
        pdf.SaveAs("document.pdf")

        Console.WriteLine("PDF with header and footer created successfully")
    End Sub
End Module

$vbLabelText $csharpLabel

Winnovative erfordert das Aktivieren der Header/Footer durch PdfDocumentOptions.ShowHeader, das Setzen der Höhen, das Erstellen von TextElement-Objekten mit Koordinatenpositionen und System.Drawing.Font-Objekten und die Nutzung von &p; und &P; Platzhaltern.IronPDF verwendet TextHeaderFooter-Objekte mit einfachen Eigenschaften wie CenterText und FontSize und intuitiven Platzhaltern wie {page} und {total-pages}.

Für HTML-basierte Kopfzeilen mit vollständigem CSS-Styling siehe die Kopf- und Fußzeilen-Dokumentation.

Referenz für die Zuordnung von innovativen APIs zu IronPDF

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

Winnovative Klasse	IronPDF-Äquivalent
`HtmlToPdfConverter`	`ChromePdfRenderer`
`PdfDocument`	`PdfDocument`
`PdfDocumentOptions`	`RenderingOptions`
`PdfHeaderOptions`	`HtmlHeaderFooter`
`PdfFooterOptions`	`HtmlHeaderFooter`
`TextElement`	HTML in `HtmlFragment`
`ImageElement`	HTML `<img>`

Methoden-Mapping

Winnovative Methode	IronPDF-Methode
`ConvertUrl(url)`	`RenderUrlAsPdf(url)`
`ConvertUrlToFile(url, path)`	`RenderUrlAsPdf(url).SaveAs(path)`
`ConvertHtml(html, baseUrl)`	`RenderHtmlAsPdf(html)`
`ConvertHtmlToFile(html, path)`	`RenderHtmlAsPdf(html).SaveAs(path)`
`ConvertHtmlFile(path)`	`RenderHtmlFileAsPdf(path)`
`MergePdf(streams)`	`PdfDocument.Merge(pdfs)`
`AppendPdf(pdf)`	`pdf1.AppendPdf(pdf2)`

Optionen-Zuordnung

Winnovative Option	IronPDF-Option
`PdfPageSize.A4`	`PaperSize = PdfPaperSize.A4`
`PdfPageSize.Letter`	`PaperSize = PdfPaperSize.Letter`
`PdfPageOrientation.Portrait`	`PaperOrientation = PdfPaperOrientation.Portrait`
`PdfPageOrientation.Landscape`	`PaperOrientation = PdfPaperOrientation.Landscape`
`TopMargin = 20`	`MarginTop = 20`
`BottomMargin = 20`	`MarginBottom = 20`
`LeftMargin = 15`	`MarginLeft = 15`
`RightMargin = 15`	`MarginRight = 15`
`ShowHeader = true`	Setzen Sie die `HtmlHeader`-Eigenschaft
`ShowFooter = true`	Setzen Sie die `HtmlFooter`-Eigenschaft
`JavaScriptEnabled = true`	`EnableJavaScript = true`
Seitennummer `&p;`	Seitennummer `{page}`
Gesamtseiten `&P;`	Gesamtseiten `{total-pages}`

Gängige Migrationsprobleme und Lösungen

Ausgabe 1: CSS-Layouts sehen anders aus

Symptom: Layouts, die in Winnovative "okay" aussahen, sehen in IronPDF anders aus.

Ursache: Winnovative Classics älterer proprietärer Motor hat Rendering-Eigenarten, die Entwickler umgangen haben. Der aktuelle Chromium-Engine von IronPDF rendert diese korrekt.

Lösung: Entfernen Sie Winnovative-spezifische CSS-Hacks und verwenden Sie Standard-CSS:

// Clean up legacy CSS
string cleanedHtml = html
    .Replace("-webkit-flex", "flex")
    .Replace("display: -webkit-box", "display: flex");

// Clean up legacy CSS
string cleanedHtml = html
    .Replace("-webkit-flex", "flex")
    .Replace("display: -webkit-box", "display: flex");

Dim cleanedHtml As String = html _
    .Replace("-webkit-flex", "flex") _
    .Replace("display: -webkit-box", "display: flex")

$vbLabelText $csharpLabel

Ausgabe 2: JavaScript wird nicht ausgeführt

Symptom: Dynamische Inhalte werden in der PDF-Datei nicht angezeigt.

Ursache: JavaScript-Warteoptionen müssen explizit konfiguriert werden.

Lösung:

renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.JavaScript(5000);
// Or wait for specific element
renderer.RenderingOptions.WaitFor.HtmlElementById("content-ready", 10000);

renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.JavaScript(5000);
// Or wait for specific element
renderer.RenderingOptions.WaitFor.HtmlElementById("content-ready", 10000);

$vbLabelText $csharpLabel

Problem 3: Basis-URL funktioniert nicht

Symptom: Relative URLs für Bilder und CSS werden nicht aufgelöst.

Ursache:IronPDF benötigt eine explizite Konfiguration der Basis-URL.

Lösung:

renderer.RenderingOptions.BaseUrl = new Uri("https://example.com/");

renderer.RenderingOptions.BaseUrl = new Uri("https://example.com/");

renderer.RenderingOptions.BaseUrl = New Uri("https://example.com/")

$vbLabelText $csharpLabel

Ausgabe 4: Verschiedene Seitenumbrüche

Symptom: Der Inhalt bricht an anderen Stellen als bei Winnovative ab.

Ursache: Verschiedene Rendering-Engines behandeln Seitenumbrüche unterschiedlich.

Lösung: Verwenden Sie explizite CSS-Seitenumbruchsteuerungen:

/* Control page breaks explicitly */
.no-break {
    page-break-inside: avoid;
}
.page-break-before {
    page-break-before: always;
}
.page-break-after {
    page-break-after: always;
}

Ausgabe 5: Schriftarten sehen anders aus

Symptom: Text erscheint in anderen Schriftarten als erwartet.

Ursache:IronPDF verwendet Systemschriftarten; web-Fonts müssen explizit geladen werden.

Lösung:

<style>
@import url('https://fonts.googleapis.com/css2?family=Roboto&display=swap');

body {
    font-family: 'Roboto', Arial, sans-serif;
}
</style>

<style>
@import url('https://fonts.googleapis.com/css2?family=Roboto&display=swap');

body {
    font-family: 'Roboto', Arial, sans-serif;
}
</style>

HTML

Checkliste für eine innovative Migration

Vor der Migration anfallende Aufgaben

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

# Find all Winnovative references
grep -r "Winnovative" --include="*.cs" .
grep -r "HtmlToPdfConverter" --include="*.cs" .
grep -r "PdfDocumentOptions" --include="*.cs" .
grep -r "ConvertUrl\|ConvertHtml" --include="*.cs" .

# Find all Winnovative references
grep -r "Winnovative" --include="*.cs" .
grep -r "HtmlToPdfConverter" --include="*.cs" .
grep -r "PdfDocumentOptions" --include="*.cs" .
grep -r "ConvertUrl\|ConvertHtml" --include="*.cs" .

SHELL

Dokumentieren Sie die aktuellen Konfigurationen, einschließlich Seitengrößen, Ränder und Kopf-/Fußzeileneinstellungen. Identifizieren Sie CSS-Umgehungen (Webkit-Präfixe, float-basierte Raster), die entfernt werden können. Beachten Sie die Anforderungen an die JavaScript-Kompatibilität.

Aufgaben der Code-Aktualisierung

Winnovative NuGet-Pakete entfernen 2.IronPDF NuGet-Paket installieren
Aktualisieren Sie alle Namespace-Importe von Winnovative zu IronPdf
Ersetzen Sie HtmlToPdfConverter durch ChromePdfRenderer
Konvertieren Sie ConvertHtml()-Aufrufe zu RenderHtmlAsPdf()
Konvertieren Sie ConvertUrl()-Aufrufe zu RenderUrlAsPdf()
Aktualisieren Sie die Seitengröße/-orientierungseinstellungen zu RenderingOptions
Konvertieren von Randkonfigurationen
Migrieren Sie auf TextElement basierende Header/Footer zu HTML-basierten TextHeaderFooter
Aktualisieren Sie die Platzhalter für Seitenzahlen von &P; zu {total-pages}
IronPDF-Lizenzinitialisierung beim Start hinzufügen

Post-Migrationstests

Überprüfen Sie diese Aspekte nach der Migration:

Testen Sie die grundlegende Konvertierung von HTML in PDF
Test der URL-zu-PDF-Konvertierung
Überprüfen Sie, dass CSS-Grid-Layouts korrekt gerendert werden
Überprüfen Sie, dass Flexbox-Layouts korrekt gerendert werden
Testen Sie JavaScript-lastige Seiten mit moderner ES6+-Syntax
Überprüfen Sie die Kompatibilität mit Bootstrap 5
Testen Sie das Rendering von Kopf- und Fußzeilen
Seitenumbrüche überprüfen
Vergleich der PDF-Ausgabequalität

Bereinigungsaufgaben

Winnovative CSS-Workarounds (Webkit-Präfixe) entfernen
Aktualisierung von ES5-JavaScript auf eine moderne Syntax
Fallbacks für float-basierte Raster entfernen
Dokumentation aktualisieren

Die wichtigsten Vorteile der Migration zu IronPDF

Der Wechsel von Winnovative zu IronPDF bietet mehrere entscheidende Vorteile:

Moderne Rendering-Engine:IronPDF nutzt die aktuelle Chromium-Engine und gewährleistet so volle Unterstützung für CSS3, CSS Grid, Flexbox und ES2024JavaScript . Moderne Frameworks wie Bootstrap 5, Tailwind CSS und React/Vue werden korrekt wiedergegeben.

Vereinfachte API: HTML-basierte Header und Footer ersetzen die programmgesteuerte TextElement-Positionierung. Intuitive Platzhalter wie {page} ersetzen die obskure &p;-Syntax. Eingebaute SaveAs()-Methoden eliminieren die manuelle Byte-Verarbeitung.

Aktive Entwicklung: IronPDFs monatliche Updates gewährleisten die Kompatibilität mit aktuellen und kommenden .NET-Versionen.

Modernes CSS ohne Workarounds: CSS Grid, Flexbox und moderne Typografie funktionieren ohne Webkit-Präfixe oder Float-basierte Fallbacks.

Modernes JavaScript: ES6+-Funktionen wie Arrow-Funktionen, async/await, Klassen und Module werden korrekt ausgeführt.

Hinweis:Winnovative ist eine eingetragene Marke ihres jeweiligen Eigentümers. Diese Website steht in keinem Zusammenhang mit, wird nicht unterstützt oder gesponsert von Winnovative Software. Alle Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Eigentümer. Vergleiche dienen nur zu Informationszwecken und spiegeln öffentlich zugängliche Informationen zum Zeitpunkt des Schreibens wider.

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

Kunden-Highlight:

Entwickler im Rampenlicht:

Webinare:

Starten Sie jetzt Ihre kostenlose 30-Tage-Testphase

Aufteilung einer mehrseitigen PDF-Datei mit IronPDF in C# | IronPDF

Warum von Winnovative migrieren

Wirkung in der realen Welt

IronPDF vs. Winnovative: Funktionsvergleich

Schnellstart: Migration von Winnovative zu IronPDF

Schritt 1: Ersetzen von NuGet-Paketen

Schritt 2: Namespaces aktualisieren

Schritt 3: Lizenz initialisieren

Beispiele für die Code-Migration

Konvertierung von HTML in PDF

Konvertierung von URLs zu PDF

Kopf- und Fußzeilen einfügen

Referenz für die Zuordnung von innovativen APIs zu IronPDF

Methoden-Mapping

Optionen-Zuordnung

Gängige Migrationsprobleme und Lösungen

Ausgabe 1: CSS-Layouts sehen anders aus

Ausgabe 2: JavaScript wird nicht ausgeführt

Problem 3: Basis-URL funktioniert nicht

Ausgabe 4: Verschiedene Seitenumbrüche

Ausgabe 5: Schriftarten sehen anders aus

Checkliste für eine innovative Migration

Vor der Migration anfallende Aufgaben

Aufgaben der Code-Aktualisierung

Post-Migrationstests

Bereinigungsaufgaben

Die wichtigsten Vorteile der Migration zu IronPDF

Ihr Lizenzschlüssel wurde in Ihren Posteingang geliefert

Ihre Demo-Anfrage ist eingegangen.

Iron-Support-Team

Starten Sie jetzt Ihre kostenlose 30-Tage-Testphase

Aufteilung einer mehrseitigen PDF-Datei mit IronPDF in C# | IronPDF

Warum von Winnovative migrieren

Wirkung in der realen Welt

IronPDF vs. Winnovative: Funktionsvergleich

Schnellstart: Migration von Winnovative zu IronPDF

Schritt 1: Ersetzen von NuGet-Paketen

Schritt 2: Namespaces aktualisieren

Schritt 3: Lizenz initialisieren

Beispiele für die Code-Migration

Konvertierung von HTML in PDF

Konvertierung von URLs zu PDF

Kopf- und Fußzeilen einfügen

Referenz für die Zuordnung von innovativen APIs zu IronPDF

Methoden-Mapping

Optionen-Zuordnung

Gängige Migrationsprobleme und Lösungen

Ausgabe 1: CSS-Layouts sehen anders aus

Ausgabe 2: JavaScript wird nicht ausgeführt

Problem 3: Basis-URL funktioniert nicht

Ausgabe 4: Verschiedene Seitenumbrüche

Ausgabe 5: Schriftarten sehen anders aus

Checkliste für eine innovative Migration

Vor der Migration anfallende Aufgaben

Aufgaben der Code-Aktualisierung

Post-Migrationstests

Bereinigungsaufgaben

Die wichtigsten Vorteile der Migration zu IronPDF

Verwandte Artikel

Konvertieren von HTML in PDF mit C# in .NET 10 | IronPDF

Wie man benutzerdefinierte Papierformate für PDFs mit C# setzt | IronPDF

PDF-Seiten umwandeln mit IronPDF in C# | IronPDF

Nächster Schritt: Kostenlosen 30-Tage-Test starten

Thank You

Nächster Schritt: Kostenlosen 30-Tage-Test starten

Möchten Sie IronSuite KOSTENLOS in einem Live-Projekt einsetzen?

DLL-Download

Ihr Lizenzschlüssel wurde in Ihren Posteingang geliefert

Ihre Demo-Anfrage ist eingegangen.

Von Millionen von Ingenieur*innen weltweit vertraut

Iron-Support-Team