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

Migrieren von Winnovative zu IronPDF in C#

Curtis Chau
Curtis Chau
Aktualisiert:

Winnovative ist ein anerkannter Name im Bereich der .NET-PDF-Generierung und bietet HTML-zu-PDF-Konvertierungsfunktionen für C#-Anwendungen. Da die Bibliothek jedoch auf eine WebKit-Engine aus dem Jahr 2016 zurückgreift, ergeben sich für die moderne Webentwicklung erhebliche Herausforderungen. Zeitgemäße CSS-Funktionen wie Grid-Layout, moderne JavaScript-Syntax und beliebte Frameworks wie Bootstrap 5 und Tailwind CSS werden oft nicht korrekt - oder überhaupt nicht - dargestellt.

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

Warum von Winnovative migrieren

Winnovative setzt auf eine WebKit-Engine aus dem Jahr 2016, die für moderne Webanwendungen erhebliche Probleme verursacht:

Keine CSS Grid-Unterstützung: Bootstrap 5, Tailwind CSS und moderne Layouts funktionieren überhaupt nicht mehr. Jede Seite, die CSS Grid verwendet, wird nicht wie erwartet dargestellt.

Fehlerhafte Flexbox-Implementierung: Inkonsistente Darstellung im Vergleich zu modernen Browsern. Entwickler verbringen oft Stunden damit, Layout-Probleme zu beheben, die es nur in Winnovative gibt.

Nur ES5 JavaScript : Moderne ES6+ JavaScript Funktionen (Pfeilfunktionen, async/await, Klassen) funktionieren nicht ohne Fehlermeldung. Das bedeutet, dass React, Vue und andere moderne Frameworks oft fehlerhafte Ausgaben produzieren.

Stagnierende Entwicklung: Obwohl "Winnovative" Innovation suggeriert, hat das Produkt in den letzten Jahren nur minimale Aktualisierungen erfahren.

Probleme bei der Schriftwiedergabe: Webfonts und benutzerdefinierte Typografie werden oft falsch oder gar nicht dargestellt.

Sicherheitsbedenken: Eine WebKit-Engine aus dem Jahr 2016 verfügt über jahrelange Sicherheitsupdates und die Behebung von Schwachstellen nicht.

Wirkung in der realen Welt

Modernes CSS und JavaScript funktionieren in Winnovative einfach nicht:


<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); // Arrow functions: FAIL
const result = await fetchData(); // Async/await: FAIL
class Report { } // Classes: FAIL
</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); // Arrow functions: FAIL
const result = await fetchData(); // Async/await: FAIL
class Report { } // Classes: FAIL
</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 IronPDF
Rendering Engine WebKit (2016) Chromium (aktuell)
CSS Grid Nicht unterstützt Volle Unterstützung
Flexbox Fehlerhaft Volle Unterstützung
JavaScript Nur ES5 ES2024
Bootstrap 5 Gebrochen Volle Unterstützung
Tailwind CSS Nicht unterstützt Volle Unterstützung
React/Vue SSR Problematisch Funktioniert einwandfrei
Web-Schriftarten Unzuverlässig Volle Unterstützung
Aktualisierungen Unregelmäßig Monatlich
Preis $750-$1,600 Konkurrenzfähig

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:

# Remove Winnovative
dotnet remove package Winnovative.WebKitHtmlToPdf
dotnet remove package Winnovative.HtmlToPdf
dotnet remove package Winnovative.WebToPdfConverter
# Remove Winnovative
dotnet remove package Winnovative.WebKitHtmlToPdf
dotnet remove package Winnovative.HtmlToPdf
dotnet remove package Winnovative.WebToPdfConverter
SHELL

IronPDF installieren:

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

Schritt 2: Namespaces aktualisieren

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

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

Winnovative Approach:

// NuGet: Install-Package Winnovative.WebToPdfConverter
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.WebToPdfConverter
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 das Erstellen einer Instanz (HtmlToPdfConverter), das Festlegen eines Lizenzschlüssels für die Instanz, den Aufruf von (ConvertHtml()) mit einem leeren Basis-URL-Parameter, den Empfang von Rohdaten und das manuelle Schreiben in eine Datei.IronPDF vereinfacht dies: Erstellen Sie eine Instanz (ChromePdfRenderer), rufen Sie (RenderHtmlAsPdf()) auf und verwenden 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.

Winnovative Approach:

// NuGet: Install-Package Winnovative.WebToPdfConverter
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.WebToPdfConverter
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(), die Bytes zurückgibt, die manuell gespeichert werden müssen.IronPDF stellt RenderUrlAsPdf() ein PdfDocument Objekt bereit, das SaveAs() zur Vereinfachung enthält.

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

Winnovative Approach:

// NuGet: Install-Package Winnovative.WebToPdfConverter
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.WebToPdfConverter
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 von Kopf- und Fußzeilen über PdfDocumentOptions.ShowHeader, das Festlegen von Höhen, das Erstellen von TextElement-Objekten mit Koordinatenpositionen und System.Drawing.Font-Objekten sowie die Verwendung von &p;- und &P;-Platzhaltern. IronPDF verwendet TextHeaderFooter Objekte mit einfachen Eigenschaften wie CenterText und FontSize sowie intuitive Platzhalter 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:

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

Methoden-Mapping

WinnovativeMethode 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

WinnovativeOption 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 Setze HtmlHeader Eigenschaft
ShowFooter = true Setze die Eigenschaft HtmlFooter
JavaScriptEnabled = true EnableJavaScript = true
Seitenzahl &p; Seitenzahl {page}
Gesamtzahl der Seiten &P; Gesamtzahl der Seiten {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: Das WebKit von Winnovative aus dem Jahr 2016 hatte Rendering-Fehler, die von den Entwicklern umgangen wurden.IronPDF rendert korrekt nach modernen Standards.

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 Winnovativereferences
grep -r "Winnovative" --include="*.cs" .
grep -r "HtmlToPdfConverter" --include="*.cs" .
grep -r "PdfDocumentOptions" --include="*.cs" .
grep -r "ConvertUrl\|ConvertHtml" --include="*.cs" .
# Find all Winnovativereferences
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

  1. Winnovative NuGet-Pakete entfernen
  2. IronPDF NuGet-Paket installieren
  3. Aktualisiere alle Namespace-Importe von Winnovative nach IronPdf
  4. Ersetzen Sie HtmlToPdfConverter durch ChromePdfRenderer
  5. Konvertiere ConvertHtml()-Aufrufe in RenderHtmlAsPdf()-Aufrufe.
  6. Konvertiere ConvertUrl()-Aufrufe in RenderUrlAsPdf()-Aufrufe.
  7. Aktualisieren Sie die Einstellungen für Seitengröße/-ausrichtung auf RenderingOptions
  8. Konvertieren von Randkonfigurationen
  9. Migration von TextElement-basierten Kopf- und Fußzeilen zu HTML-basierten TextHeaderFooter
  10. Aktualisieren Sie die Platzhalter für Seitenzahlen von &P; auf {total-pages}
  11. 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 die korrekte Darstellung von CSS-Grid-Layouts (sie funktionieren jetzt)
  • Überprüfen Sie die korrekte Darstellung von Flexbox-Layouts (sie funktionieren jetzt)
  • 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 Kopf- und Fußzeilen ersetzen die programmatische TextElement Positionierung. Intuitive Platzhalter wie {page} ersetzen die schwer verständliche Syntax &p;. Die integrierten SaveAs() Methoden eliminieren die manuelle Byte-Verarbeitung.

Aktive Weiterentwicklung: Da die Verbreitung von .NET 10 und C# 14 bis 2026 zunimmt, gewährleisten die monatlichen Updates von IronPDF die Kompatibilität mit aktuellen und zukünftigen .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.

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