Didn’t find what you were looking for?
Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Guides de migration
  4. migration de winnovative vers IronPDF
VIDéOS

Comment diviser un PDF de plusieurs pages à l'aide d'IronPDF en C# | IronPDF

Curtis Chau
Curtis Chau
Mis à jour:

Winnovative est un nom reconnu dans l'espace de génération de PDF .NET, offrant des capacités de conversion HTML vers PDF pour les applications C#. Cependant, la bibliothèque Classic à long terme repose sur un moteur de rendu propriétaire plus ancien, et sa prise en charge des CSS modernes (Grid, dernier Flexbox) et du JavaScript moderne (ES2017+) est incohérente par rapport à un navigateur Chromium actuel. La réponse du fournisseur a été d'expédier un produit séparé de classe Chromium, Winnovative.Pdf.Next, plutôt que de mettre à niveau Classic sur place, ce qui signifie que les clients existants de Winnovative font face à une migration de code de toute façon.

Ce guide propose un chemin de migration de Winnovative vers IronPDF, avec des instructions pas-à-pas, des comparaisons de code et des exemples pratiques pour les développeurs .NET évaluant cette transition.

Pourquoi migrer de Winnovative

La bibliothèqueWinnovative Classicutilise un moteur propriétaire plus ancien qui n'a pas été mis à jour selon les normes modernes du web :

Incohérence du CSS Grid / dernier Flexbox : Les mises en page qui dépendent de CSS Grid ou de fonctionnalités récentes de Flexbox peuvent mal se rendre par rapport à un navigateur Chromium actuel.

Lacunes de compatibilité JavaScript moderne : Les fonctionnalités ES2017+ (fonctions fléchées, async/await, classes) ne sont pas exécutées de manière fiable, ce qui affecte React, Vue et d'autres frameworks modernes.

Cadence lente : Le moteur Classic reçoit des mises à jour peu fréquentes de rendu ; la réponse du fournisseur a été d'expédier le produit séparé Winnovative.Pdf.Next de classe Chromium, laissant Classic figé en termes de fonctionnalités.

Fardeau de migration à deux produits : Passer à Winnovative.Pdf.Next est en soi une réécriture - l'API Next vit sous un espace de noms différent (Winnovative.Pdf.Next) et est incompatible binaire avec Classic.

Cas limites de rendu des polices : Les polices web et la typographie personnalisée se rendent parfois différemment d'un navigateur moderne.

Impact sur le monde réel

CSS et JavaScript modernes qui peuvent se rendre de manière incohérente dansWinnovative 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 : Comparaison des fonctionnalités

La compréhension des différences architecturales aide les décideurs techniques à évaluer l'investissement dans la migration :

Aspect Winnovative Classic IronPDF
Moteur de rendu Moteur propriétaire plus ancien Chromium (actuel)
CSS Grid Incohérent Prise en charge complète
Flexbox Incohérent sur les cas limites Prise en charge complète
JavaScript JS moderne limité ES2024
Bootstrap 5 Problèmes de disposition Prise en charge complète
Tailwind CSS Limité Prise en charge complète
React/Vue SSR Problématique Fonctionne
Fontes Web Peu fiable dans certaines configurations Prise en charge complète
Mises à jour Peu fréquents Mensuel
Tarification (par développeur) 450 $ Déploiement / 1 200 $ Redistributable See ironpdf.com/pricing

Démarrage rapide : Migration de Winnovative vers IronPDF

La migration peut commencer immédiatement grâce à ces étapes fondamentales.

Étape 1 : Remplacer les paquets NuGet

Supprimez tous les packs Winnovative (vérifiez lesquels votre projet utilise réellement) :

# 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

Installez IronPDF:

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

Étape 2 : Mise à jour des espaces de noms

Remplacez les espaces de noms Winnovative par l'espace de nom 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

Étape 3 : initialisation de la licence

Ajouter l'initialisation de la licence au démarrage de l'application :

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

Exemples de migration de code

Conversion de HTML en PDF

Le cas d'utilisation le plus courant démontre les différences d'API entre ces bibliothèques PDF .NET.

Approche innovante:

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

Approche 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 nécessite de créer un HtmlToPdfConverter, de définir une clé de licence sur l'instance, d'appeler ConvertHtml() avec un paramètre URL de base vide, de recevoir des octets bruts et d'écrire manuellement dans un fichier.IronPDF simplifie cela : créez un ChromePdfRenderer, appelez RenderHtmlAsPdf(), et utilisez la méthode intégrée SaveAs().

Pour les scénarios avancés de conversion de HTML en PDF, voir le guide de conversion de HTML en PDF.

Conversion des URL en PDF

La conversion d'URL en PDF présente des caractéristiques similaires.

Approche innovante:

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

Approche 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 utilise ConvertUrl() renvoyant des octets qui doivent être sauvegardés manuellement.IronPDF fournit RenderUrlAsPdf() avec un objet PdfDocument qui inclut SaveAs() pour plus de commodité.

Explorez la URL vers la documentation PDF pour l'authentification et les options d'en-tête personnalisées.

Ajouter des en-têtes et des pieds de page

Les en-têtes et les pieds de page révèlent des différences architecturales significatives. Winnovative utilise une approche programmée basée sur des éléments avec des objets TextElement, tandis qu'IronPDF utilise des en-têtes basés sur HTML avec des jetons de remplacement.

Approche innovante:

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

Approche 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 nécessite l'activation des en-têtes/pieds de page via PdfDocumentOptions.ShowHeader, le paramétrage des hauteurs, la création d'objets TextElement avec des positions de coordonnées et des objets System.Drawing.Font, et l'utilisation des jetons de remplacement &p; et &P;.IronPDF utilise des objets TextHeaderFooter avec des propriétés simples comme CenterText et FontSize, et des jetons de remplacement intuitifs comme {page} et {total-pages}.

Pour les en-têtes basés sur HTML avec un style CSS complet, voir la documentation sur les en-têtes et les pieds de page.

Référence de mappage de l'API innovante à IronPDF

Cette cartographie accélère la migration en indiquant les équivalents directs des API :

Classe Winnovative Équivalent d'IronPDF
HtmlToPdfConverter ChromePdfRenderer
PdfDocument PdfDocument
PdfDocumentOptions RenderingOptions
PdfHeaderOptions HtmlHeaderFooter
PdfFooterOptions HtmlHeaderFooter
TextElement HTML dans HtmlFragment
ImageElement HTML <img>

Mise en correspondance des méthodes

Méthode Winnovative Méthode 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)

Cartographie des options

Option Winnovative Option 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 Définir la propriété HtmlHeader
ShowFooter = true Définir la propriété HtmlFooter
JavaScriptEnabled = true EnableJavaScript = true
Numéro de page &p; Numéro de page {page}
Total des pages &P; Total des pages {total-pages}

Problèmes de migration courants et solutions

Enjeu 1 : Les mises en page CSS ont une apparence différente

Symptôme: Les mises en page qui semblaient "correctes" dans Winnovative ont désormais un aspect différent dans IronPDF.

Cause : le moteur propriétaire plus ancien deWinnovative Classica des particularités de rendu avec lesquelles les développeurs ont contourné. Le moteur Chromium actuel d'IronPDF les rend correctement.

Solution :Supprimez les hacks CSS spécifiques à Winnovative et utilisez le CSS standard :

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

Sujet 2 : JavaScript ne s'exécute pas

Symptôme: Le contenu dynamique n'apparaît pas dans le PDF.

Cause:Nécessité de configurer les options d'attente JavaScript de manière explicite.

Solution :

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

Sujet 3 : L'URL de base ne fonctionne pas

Symptôme: Les URL relatives pour les images et les CSS ne se résolvent pas.

Cause:IronPDF a besoin d'une configuration explicite de l'URL de base.

Solution :

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

Edition 4 : Différents sauts de page

Symptôme: Le contenu s'interrompt à différents endroits par rapport à Winnovative.

Cause: Les moteurs de rendu traitent différemment les sauts de page.

Solution : Utiliser des contrôles de saut de page CSS explicites :

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

Edition 5 : Les polices de caractères sont différentes

Symptôme: Le texte apparaît dans des polices différentes de celles prévues.

Cause:IronPDF utilise des polices de caractères système ; les polices web nécessitent un chargement explicite.

Solution :

<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

Liste de contrôle de la migration innovante

Tâches préalables à la migration

Auditez votre base de code pour identifier tous les usages de 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

Documenter les configurations actuelles, y compris la taille des pages, les marges et les paramètres d'en-tête et de pied de page. Identifier les solutions de contournement CSS (préfixes webkit, grilles flottantes) qui peuvent être supprimées. Veuillez noter les exigences de compatibilité JavaScript.

Tâches de mise à jour du code

  1. Supprimer les paquets NuGet de Winnovative
  2. Installez le package NuGet IronPDF
  3. Mettez à jour toutes les importations d'espaces de noms de Winnovative à IronPdf
  4. Remplacez HtmlToPdfConverter par ChromePdfRenderer
  5. Convertissez les appels ConvertHtml() en RenderHtmlAsPdf()
  6. Convertissez les appels ConvertUrl() en RenderUrlAsPdf()
  7. Mettez à jour les paramètres de taille/orientation de page vers RenderingOptions
  8. Convertir les configurations de marge
  9. Migrez les en-têtes/pieds de page basés sur TextElement vers les TextHeaderFooter basés sur HTML
  10. Mettez à jour les espaces réservés de numéro de page de &P; à {total-pages}
  11. Ajouter l'initialisation de la licence IronPDF au démarrage

Test de post-migration

Après la migration, vérifiez ces aspects :

  • Tester la conversion de base de HTML en PDF
  • Test de conversion d'URL en PDF
  • Vérifiez que les mises en page CSS Grid se rendent correctement
  • Vérifiez que les mises en page Flexbox se rendent correctement
  • Testez les pages à forte teneur en JavaScript avec la syntaxe moderne ES6
  • Vérifier la compatibilité avec Bootstrap 5
  • Test du rendu de l'en-tête/du pied de page
  • Vérifier les sauts de page
  • Comparer la qualité de sortie des PDF

Tâches de nettoyage

  • Supprimer les solutions de contournement CSS de Winnovative (préfixes webkit)
  • Mise à jour du JavaScript ES5 vers une syntaxe moderne
  • Suppression de la grille à base de flotteurs
  • Mise à jour de la documentation

Avantages clés de la migration vers IronPDF

Le passage de Winnovative à IronPDF présente plusieurs avantages décisifs :

Moteur de rendu moderne :IronPDF utilise le moteur Chromium actuel, garantissant une prise en charge complète de CSS3, CSS Grid, Flexbox et JavaScript ES2024. Les cadres modernes tels que Bootstrap 5, Tailwind CSS et React/Vue sont correctement rendus.

API simplifiée : Les en-têtes et pieds de page basés sur HTML remplacent le positionnement programmatique TextElement. Les espaces réservés intuitifs comme {page} remplacent la syntaxe obscure &p;. Les méthodes intégrées SaveAs() éliminent la gestion manuelle des octets.

Développement actif : les mises à jour mensuelles d'IronPDF assurent la compatibilité avec les versions .NET actuelles et à venir.

CSS moderne sans solutions de contournement : CSS Grid, Flexbox et la typographie moderne fonctionnent sans préfixes Webkit ni solutions de repli basées sur les flottants.

JavaScript moderne : les fonctionnalités ES6+, notamment les fonctions fléchées, async/await, les classes et les modules, s'exécutent correctement.

Veuillez noterWinnovative est une marque déposée de son propriétaire respectif. Ce site n'est pas affilié à, approuvé par, ou sponsorisé par Winnovative Software. Tous les noms de produits, logos et marques sont la propriété de leurs propriétaires respectifs. Les comparaisons sont à titre informatif uniquement et reflètent les informations publiquement disponibles au moment de l'écriture.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Mis à jour

Comment définir des tailles de papier personnalisées pour les PDF en utilisant C# | IronPDF

Découvrez comment rendre des fichiers PDF avec des tailles de papier personnalisées en utilisant C# et IronPDF. Cette vidéo vous guide à travers la génération de PDF adaptés à des modèles non standards, idéale pour créer des documents personnalisés tels que des invitations, des affiches ou des rapports personnalisés. Améliorez votre processus de création de documents avec facilité.

Lire la suite
Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi