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:

<!-- CSS Grid can render inconsistently inWinnovative 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>

<!-- Modern JavaScript may not execute reliably in Classic -->
<script>
const items = data.map(item => item.name);
const result = await fetchData();
class Report { }
</script>

<!-- CSS Grid can render inconsistently inWinnovative 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>

<!-- Modern JavaScript may not execute reliably in Classic -->
<script>
const items = data.map(item => item.name);
const result = await fetchData();
class Report { }
</script>

##IronPDF vs Winnovative: Porównanie funkcji

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

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

Zainstaluj IronPDF:

# Install IronPDF
dotnet add package IronPdf

# Install IronPDF
dotnet add package IronPdf

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

Imports IronPdf

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"

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

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");
    }
}

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");
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

Module Program
    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 Module

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

Module Program
    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 Module

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");
    }
}

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");
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

Module Program
    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 Module

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

Module Program
    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 Module

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");
    }
}

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");
    }
}

' NuGet: Install-Package IronPdf
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

' NuGet: Install-Package IronPdf
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

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:

Mapowanie metod

Mapowanie opcji

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")

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

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);

net

net

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

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

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;
}

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

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

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.