Nie znalazłeś tego, czego szukałeś?
Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Przewodniki migracji
  4. migracja z Winnovative do IronPDF
PRZEWODNIKI MIGRACJI

Jak przeprowadzić migrację z Winnovative do IronPDF w języku C#

Curtis Chau
Curtis Chau
Zaktualizowano:

Winnovative jest uznaną marką w branży generowania plików PDF w środowisku .NET, oferującą funkcje konwersji HTML do PDF dla aplikacji napisanych w języku C#. Jednak długotrwała wersja Classic opiera się na starszym, zastrzeżonym silniku renderującym, a jego wsparcie dla nowoczesnego CSS (Grid, ostatnie Flexbox) i nowoczesnego JavaScript (ES2017+) jest niespójne w porównaniu do obecnej przeglądarki Chromium. Odpowiedzią dostawcy było wprowadzenie na rynek osobnego produktu klasy Chromium, Winnovative.Pdf.Next, zamiast aktualizacji Classic na miejscu — co oznacza, że obecni klienci Winnovative stoją przed migracją kodu w każdym przypadku.

Przewodnik ten dostarcza ścieżkę migracji z Winnovative do IronPDF, z instrukcjami krok po kroku, porównaniami kodu i praktycznymi przykładami dla deweloperów .NET oceniających tę transformację.

Dlaczego warto przejść z Winnovative

Klasyczna biblioteka Winnovative używa starszego, zastrzeżonego silnika, który nie został zaktualizowany do nowoczesnych standardów webowych:

Niezgodność CSS Grid / nowoczesne Flexbox: Układy, które polegają na CSS Grid lub ostatnich funkcjach Flexbox, mogą być renderowane nieprawidłowo w porównaniu do obecnej przeglądarki Chromium.

Nowoczesne Luki W Kompatybilności JavaScript: Funkcje ES2017+ (funkcje strzałkowe, async/await, klasy) nie są niezawodnie wykonane, co wpływa na React, Vue i inne nowoczesne frameworki.

Wolne tempo aktualizacji rendering engine Classic otrzymuje rzadkie aktualizacje; Odpowiedzią dostawcy było wprowadzenie na rynek osobnego produktu klasy Chromium Winnovative.Pdf.Next, pozostawiając Classic jako zamrożony.

Ciężar migracji dwóch produktów: Przejście na Winnovative.Pdf.Next samo w sobie jest przepisaniem od podstaw — nowe API działa w innym namespace (Winnovative.Pdf.Next) i jest binarnie niekompatybilne z Classic.

Przypadki brzegowe renderowania czcionek: Czasami czcionki webowe i niestandardowe typografie renderują się inaczej niż w nowoczesnej przeglądarce.

Wpływ na rzeczywistość

Nowoczesne CSS i JavaScript, które mogą renderować się niespójnie w Winnovative Classic:


<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: Porównanie funkcji

Zrozumienie różnic architektonicznych pomaga decydentom technicznym w ocenie inwestycji w migrację:

Aspekt Winnovative Classic IronPDF
Silnik renderujący Starszy, zastrzeżony silnik Chromium (aktualne)
CSS Grid Niespójny Pełne wsparcie
Flexbox Niespójny w przypadkach brzegowych Pełne wsparcie
JavaScript Ograniczony nowoczesny JS ES2024
Bootstrap 5 Problemy z układem Pełne wsparcie
Tailwind CSS Ograniczone Pełne wsparcie
React/Vue SSR Problematyczne Działa
Czcionki internetowe Niezawodny w niektórych konfiguracjach Pełne wsparcie
Aktualizacje Rzadko Miesięcznie
Cena (za programistę) $450 Wdrozenie / $1 200 Redistributable See ironpdf.com/pricing

Szybki start: Migracja z Winnovative do IronPDF

Migrację można rozpocząć natychmiast, wykonując te podstawowe kroki.

Krok 1: Zastąp pakiety NuGet

Usuń wszystkie pakiety Winnovative (sprawdź, które z nich Twój projekt faktycznie używa):

# 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

Zainstaluj IronPDF:

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

Krok 2: Aktualizacja przestrzeni nazw

Zastąp przestrzenie nazw Winnovative przestrzenią nazw IronPDF:

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

Krok 3: Inicjalizacja licencji

Dodaj inicjalizację licencji podczas uruchamiania aplikacji:

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

Przykłady migracji kodu

Konwersja HTML do PDF

Najczęstszy przypadek użycia ilustruje różnice w API między tymi bibliotekami .NET do obsługi plików PDF.

Podejście Winnovative:

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

Podejście IronPDF:

// 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 wymaga utworzenia HtmlToPdfConverter, ustawienia klucza licencyjnego na instancji, wywołania ConvertHtml() z pustym parametrem bazowego URL, odbioru surowych bajtów i ręcznego zapisu do pliku.IronPDF upraszcza to: utwórz ChromePdfRenderer, wywołaj RenderHtmlAsPdf() i użyj wbudowanej metody SaveAs().

W przypadku zaawansowanych scenariuszy konwersji HTML do PDF zapoznaj się z przewodnikiem po konwersji HTML do PDF.

Konwersja adresów URL do formatu PDF

Konwersja adresów URL do formatu PDF wykazuje podobne wzorce.

Podejście Winnovative:

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

Podejście IronPDF:

// 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 używa ConvertUrl() zwracając bajty, które muszą być ręcznie zapisywane.IronPDF zapewnia RenderUrlAsPdf() z obiektem PdfDocument, który dla wygody zawiera SaveAs().

Zapoznaj się z dokumentacją dotyczącą konwersji adresów URL do formatu PDF, aby uzyskać informacje na temat uwierzytelniania i opcji niestandardowych nagłówków.

Dodawanie nagłówków i stopek

Nagłówki i stopki ujawniają istotne różnice architektoniczne. Winnovative używa podejścia opartego na elementach programowych z obiektami TextElement, podczas gdy IronPDF używa nagłówków opartych na HTML z tokenami zastępczymi.

Podejście Winnovative:

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

Podejście IronPDF:

// 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 wymaga włączenia nagłówków/stopków przez PdfDocumentOptions.ShowHeader, ustawienia wysokości, tworzenia obiektów TextElement z pozycjami współrzędnych i obiektów System.Drawing.Font oraz użycia tokenów zastępczych &p; i &P;.IronPDF używa obiektów TextHeaderFooter z prostymi właściwościami jak CenterText i FontSize oraz intuicyjnymi tokenami zastępczymi, jak {page} i {total-pages}.

W przypadku nagłówków opartych na HTML z pełnym stylizowaniem CSS zapoznaj się z dokumentacją dotyczącą nagłówków i stopek.

Winnovative API do IronPDF– dokumentacja API dla mapowania

To mapowanie przyspiesza migrację, pokazując bezpośrednie odpowiedniki API:

Klasa Winnovative Odpowiednik IronPDF
HtmlToPdfConverter ChromePdfRenderer
PdfDocument PdfDocument
PdfDocumentOptions RenderingOptions
PdfHeaderOptions HtmlHeaderFooter
PdfFooterOptions HtmlHeaderFooter
TextElement HTML w HtmlFragment
ImageElement HTML <img>

Mapowanie metod

Metoda Winnovative Metoda IronPDF
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)

Mapowanie opcji

Opcja Winnovative Opcja IronPDF
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 Ustaw właściwość HtmlHeader
ShowFooter = true Ustaw właściwość HtmlFooter
JavaScriptEnabled = true EnableJavaScript = true
Numer strony &p; Numer strony {page}
Łączna liczba stron &P; Łączna liczba stron {total-pages}

Typowe problemy związane z migracją i ich rozwiązania

Problem 1: Układ CSS wygląda inaczej

Objaw: Układ stron, który wyglądał "dobrze" w Winnovative, teraz wygląda inaczej w IronPDF.

Przyczyna: Starszy zastrzeżony silnikWinnovative Classicma błędy renderowania, które programiści obchodzili. Obecny silnik Chromium IronPDF poprawnie renderuje te elementy.

Rozwiązanie: Usuń hacki CSS specyficzne dla Winnovative i użyj standardowego 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

Problem 2: JavaScript nie działa

Objaw: Dynamiczna zawartość nie pojawia się w pliku PDF.

Przyczyna: Konieczność jawnego skonfigurowania opcji oczekiwania w JavaScript.

Rozwiązanie:

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: Podstawowy adres URL nie działa

Objaw: Względne adresy URL obrazów i arkuszy CSS nie są rozpoznawane.

Przyczyna:IronPDF wymaga jawnej konfiguracji adresu URL bazowego.

Rozwiązanie:

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

Problem 4: Różne podziały stron

Objaw: Treść jest dzielona w innych miejscach niż w Winnovative.

Przyczyna: Różne silniki renderujące obsługują podziały stron w różny sposób.

Rozwiązanie: Użyj wyraźnych elementów CSS do sterowania podziałami stron:

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

Problem 5: Czcionki wyglądają inaczej

Objaw: Tekst wyświetla się czcionką inną niż oczekiwano.

Przyczyna:IronPDF korzysta z czcionek systemowych; Czcionki internetowe wymagają wyraźnego załadowania.

Rozwiązanie:

<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

Lista kontrolna migracji Winnovative

Zadania przed migracją

Przeprowadź audyt kodu źródłowego, aby zidentyfikować wszystkie przypadki użycia Winnovative:

# 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

Należy udokumentować aktualne konfiguracje, w tym rozmiary stron, marginesy oraz ustawienia nagłówków i stopek. Zidentyfikuj rozwiązania zastępcze CSS (prefiksy WebKit, siatki oparte na float), które można usunąć. Uwaga: wymagania dotyczące zgodności z JavaScript.

Zadania związane z aktualizacją kodu

  1. Usuń pakiety NuGet firmy Winnovative
  2. Zainstaluj pakiet NuGet IronPDF
  3. Zaktualizuj wszystkie importy namespace z Winnovative do IronPdf
  4. Zamień HtmlToPdfConverter na ChromePdfRenderer
  5. Przekształć wywołania ConvertHtml() na RenderHtmlAsPdf()
  6. Przekształć wywołania ConvertUrl() na RenderUrlAsPdf()
  7. Zaktualizuj ustawienia rozmiaru/orientacji strony do RenderingOptions
  8. Konwersja konfiguracji marginesów
  9. Przenieś nagłówki/stopki oparte na TextElement do opartych na HTML TextHeaderFooter
  10. Zaktualizuj tokeny zastępcze numerów stron z &P; do {total-pages}
  11. Dodaj inicjalizację licencji IronPDF podczas uruchamiania

Testy po migracji

Po migracji należy zweryfikować następujące aspekty:

  • Przetestuj podstawową konwersję HTML do PDF
  • Przetestuj konwersję adresu URL do formatu PDF
  • Zweryfikuj prawidłowe renderowanie układów CSS Grid
  • Zweryfikuj prawidłowe renderowanie układów Flexbox
  • Testuj strony z dużą ilością kodu JavaScript przy użyciu nowoczesnej składni ES6+
  • Sprawdź zgodność z Bootstrap 5
  • Test renderowania nagłówka/stopki
  • Sprawdź podziały stron
  • Porównaj jakość wydruków PDF

Zadania porządkowe

  • Usuń obejścia CSS Winnovative (prefiksy webkit)
  • Zaktualizuj JavaScript ES5 do nowoczesnej składni
  • Usuń rezerwowe siatki oparte na wartości typu float
  • Aktualizacja dokumentacji

Kluczowe korzyści z migracji do IronPDF

Przejście z Winnovative na IronPDF zapewnia kilka kluczowych korzyści:

Nowoczesny silnik renderujący:IronPDF wykorzystuje aktualny silnik Chromium, zapewniając pełną obsługę CSS3, CSS Grid, Flexbox oraz JavaScript ES2024. Nowoczesne frameworki, takie jak Bootstrap 5, Tailwind CSS oraz React/Vue, wyświetlają się poprawnie.

Uproszczone API: Nagłówki i stopki oparte na HTML zastępują programowe pozycjonowanie TextElement. Intuicyjne tokeny zastępcze takie jak {page} zastępują niejasną składnię &p;. Wbudowane metody SaveAs() eliminują ręczną obsługę bajtów.

Aktywny rozwój: Comiesięczne aktualizacje IronPDF zapewniają zgodność z bieżącymi i przyszłymi wersjami .NET.

Nowoczesny CSS bez obejść: CSS Grid, Flexbox i nowoczesna typografia działają bez prefiksów WebKit lub rozwiązań awaryjnych opartych na float.

Nowoczesny JavaScript: funkcje ES6+, w tym funkcje strzałkowe, async/await, klasy i moduły, działają poprawnie.

Zwróć uwagęWinnovative jest zarejestrowanym znakiem towarowym jego właściciela. Ta strona nie jest powiązana z, wspierana ani sponsorowana przez Winnovative Software. Wszystkie nazwy produktów, logo i marki są własnością ich odpowiednich właścicieli. Porównania mają charakter wyłącznie informacyjny i odzwierciedlają informacje dostępne publicznie w momencie pisania.

Curtis Chau
Curtis Chau
  Czat z zespołem inżynierów teraz
Autor tekstów technicznych

Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podrę...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespół wsparcia Iron

Jesteśmy online 24 godziny, 5 dni w tygodniu.
Czat
E-mail
Zadzwoń do mnie