Comment migrer d'ABCpdf for .NET vers IronPDF ?

Complicité des licences

ABCpdf utilise un modèle de licences à plusieurs niveaux qui peut être difficile à gérer. Les prix débutent à 349 $ mais augmentent en fonction des fonctionnalités, des déploiements de serveurs et des cas d'utilisation. De nombreux développeurs considèrent que ce labyrinthe de licences constitue une charge administrative importante lorsqu'ils établissent le budget de leurs projets.

Architecture Windows-First

Bien qu'ABCpdf ait ajouté un support multiplateforme, sa conception historique centrée sur Windows fait parfois surface dans les flux de travail. Les développeurs ciblant les conteneurs Linux, les environnements Docker ou les configurations de développement macOS peuvent rencontrer des frictions qui n'avaient pas été anticipées lors de la planification du projet.

Style de documentation

La documentation d'ABCpdf, bien que complète, suit un style ancien qui peut sembler dépassé par rapport aux normes modernes de documentation des API. Les nouveaux utilisateurs ont souvent du mal à trouver les exemples exacts dont ils ont besoin, en particulier lorsqu'ils travaillent avec les nouvelles versions de .NET.

Configuration générale du moteur

ABCpdf nécessite une sélection explicite du moteur (Gecko, Trident ou Chrome) et une gestion manuelle des ressources avec des appels Clear(). Les développeurs modernes préféreraient éviter d'ajouter du code standard à chaque opération PDF.

Prérequis

Assurez-vous que votre environnement de développement répond à ces exigences :

• .NET Framework 4.6.2+ ou .NET Core 3.1+ / .NET 5-9
• Visual Studio 2019+ ou JetBrains Rider
• Accès au Package Manager NuGet
• Clé de licence IronPDF (essai gratuit disponible)

Trouver toutes les références ABCpdf

Exécutez ces commandes dans votre répertoire de solutions pour localiser tous les fichiers utilisant ABCpdf for .NET:

grep -r "using WebSupergoo" --include="*.cs" .
grep -r "ABCpdf" --include="*.csproj" .

grep -r "using WebSupergoo" --include="*.cs" .
grep -r "ABCpdf" --include="*.csproj" .

Cet audit identifie chaque fichier nécessitant une modification, garantissant ainsi une couverture complète de la migration.

Modifications importantes à prévoir

La compréhension des différences architecturales entre ABCpdf for .NETet IronPDF permet d'éviter les surprises lors de la migration :

Étape 1 : Mise à jour des paquets NuGet

# Remove ABCpdf
dotnet remove package ABCpdf

# Install IronPDF
dotnet add package IronPdf

# Remove ABCpdf
dotnet remove package ABCpdf

# Install IronPDF
dotnet add package IronPdf

Étape 2 : Définissez votre clé de licence

Ajoutez ceci au démarrage de l'application, avant toute opération d'IronPDF :

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

Étape 3 : Recherche et remplacement globaux

Mettez à jour toutes les références aux espaces de noms dans votre base de code :

Méthodes de création de documents

Le tableau suivant met en correspondance les méthodes d'ABCpdf for .NET avec leurs équivalents IronPDF:

Méthodes de manipulation des pages

Sécurité et méthodes de cryptage

Exemple 1 : HTML vers PDF à partir d'une URL

Cet exemple montre la conversion d'une page web en PDF, l'une des tâches de génération de PDF les plus courantes.

Implémentation d'ABCpdf for .NET :

// NuGet: Install-Package ABCpdf
using System;
using WebSupergoo.ABCpdf13;
using WebSupergoo.ABCpdf13.Objects;

class Program
{
    static void Main()
    {
        Doc doc = new Doc();
        doc.HtmlOptions.Engine = EngineType.Chrome;
        doc.AddImageUrl("https://www.example.com");
        doc.Save("output.pdf");
        doc.Clear();
    }
}

// NuGet: Install-Package ABCpdf
using System;
using WebSupergoo.ABCpdf13;
using WebSupergoo.ABCpdf13.Objects;

class Program
{
    static void Main()
    {
        Doc doc = new Doc();
        doc.HtmlOptions.Engine = EngineType.Chrome;
        doc.AddImageUrl("https://www.example.com");
        doc.Save("output.pdf");
        doc.Clear();
    }
}

Imports System
Imports WebSupergoo.ABCpdf13
Imports WebSupergoo.ABCpdf13.Objects

Class Program
    Shared Sub Main()
        Dim doc As New Doc()
        doc.HtmlOptions.Engine = EngineType.Chrome
        doc.AddImageUrl("https://www.example.com")
        doc.Save("output.pdf")
        doc.Clear()
    End Sub
End Class

Mise en œuvre d'IronPDF:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("output.pdf");
    }
}

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("output.pdf");
    }
}

Imports System
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("output.pdf")
    End Sub
End Class

L'approche d'IronPDF élimine la nécessité d'une configuration explicite du moteur et d'un nettoyage manuel, réduisant ainsi la complexité du code tout en conservant toutes les capacités de rendu de Chrome.

Exemple 2 : Chaîne HTML vers PDF

La conversion de chaînes HTML en PDF est essentielle pour générer des rapports et des documents dynamiques.

Implémentation d'ABCpdf for .NET :

// NuGet: Install-Package ABCpdf
using System;
using WebSupergoo.ABCpdf13;
using WebSupergoo.ABCpdf13.Objects;

class Program
{
    static void Main()
    {
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
        Doc doc = new Doc();
        doc.HtmlOptions.Engine = EngineType.Chrome;
        doc.AddImageHtml(html);
        doc.Save("output.pdf");
        doc.Clear();
    }
}

// NuGet: Install-Package ABCpdf
using System;
using WebSupergoo.ABCpdf13;
using WebSupergoo.ABCpdf13.Objects;

class Program
{
    static void Main()
    {
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
        Doc doc = new Doc();
        doc.HtmlOptions.Engine = EngineType.Chrome;
        doc.AddImageHtml(html);
        doc.Save("output.pdf");
        doc.Clear();
    }
}

Imports System
Imports WebSupergoo.ABCpdf13
Imports WebSupergoo.ABCpdf13.Objects

Class Program
    Shared Sub Main()
        Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"
        Dim doc As New Doc()
        doc.HtmlOptions.Engine = EngineType.Chrome
        doc.AddImageHtml(html)
        doc.Save("output.pdf")
        doc.Clear()
    End Sub
End Class

Mise en œuvre d'IronPDF:

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

class Program
{
    static void Main()
    {
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

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

class Program
{
    static void Main()
    {
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

Imports System
Imports IronPdf

Module Program
    Sub Main()
        Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Module

La version IronPDF nécessite moins de lignes de code et utilise le rendu Chrome par défaut, ce qui garantit une sortie cohérente sur toutes les plateformes.

Exemple 3 : fusionner plusieurs PDF

La combinaison de plusieurs documents PDF est une exigence fréquente dans les flux de travail de traitement des documents.

Implémentation d'ABCpdf for .NET :

// NuGet: Install-Package ABCpdf
using System;
using WebSupergoo.ABCpdf13;
using WebSupergoo.ABCpdf13.Objects;

class Program
{
    static void Main()
    {
        Doc doc1 = new Doc();
        doc1.Read("document1.pdf");

        Doc doc2 = new Doc();
        doc2.Read("document2.pdf");

        doc1.Append(doc2);
        doc1.Save("merged.pdf");

        doc1.Clear();
        doc2.Clear();
    }
}

// NuGet: Install-Package ABCpdf
using System;
using WebSupergoo.ABCpdf13;
using WebSupergoo.ABCpdf13.Objects;

class Program
{
    static void Main()
    {
        Doc doc1 = new Doc();
        doc1.Read("document1.pdf");

        Doc doc2 = new Doc();
        doc2.Read("document2.pdf");

        doc1.Append(doc2);
        doc1.Save("merged.pdf");

        doc1.Clear();
        doc2.Clear();
    }
}

Imports System
Imports WebSupergoo.ABCpdf13
Imports WebSupergoo.ABCpdf13.Objects

Class Program
    Shared Sub Main()
        Dim doc1 As New Doc()
        doc1.Read("document1.pdf")

        Dim doc2 As New Doc()
        doc2.Read("document2.pdf")

        doc1.Append(doc2)
        doc1.Save("merged.pdf")

        doc1.Clear()
        doc2.Clear()
    End Sub
End Class

Mise en œuvre d'IronPDF:

// NuGet: Install-Package IronPdf
using System;
using System.Collections.Generic;
using IronPdf;

class Program
{
    static void Main()
    {
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");

        var merged = PdfDocument.Merge(pdf1, pdf2);
        merged.SaveAs("merged.pdf");
    }
}

// NuGet: Install-Package IronPdf
using System;
using System.Collections.Generic;
using IronPdf;

class Program
{
    static void Main()
    {
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");

        var merged = PdfDocument.Merge(pdf1, pdf2);
        merged.SaveAs("merged.pdf");
    }
}

Imports System
Imports System.Collections.Generic
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim pdf1 = PdfDocument.FromFile("document1.pdf")
        Dim pdf2 = PdfDocument.FromFile("document2.pdf")

        Dim merged = PdfDocument.Merge(pdf1, pdf2)
        merged.SaveAs("merged.pdf")
    End Sub
End Class

La méthode statique Merge d'IronPDF fournit une API plus propre qui accepte plusieurs documents, éliminant ainsi le besoin de suivre et d'effacer les instances individuelles Doc.

Exemple 4 : Modèle de migration complet avec marges

Cet exemple montre une migration complète avant/après pour la génération de PDF avec des marges personnalisées.

Avant (ABCpdf for .NET):

using WebSupergoo.ABCpdf13;
using WebSupergoo.ABCpdf13.Objects;

public byte[] GeneratePdf(string html)
{
    Doc doc = new Doc();
    doc.HtmlOptions.Engine = EngineType.Chrome;
    doc.Rect.Inset(20, 20);
    doc.AddImageHtml(html);
    byte[] data = doc.GetData();
    doc.Clear();  // Manual cleanup required
    return data;
}

using WebSupergoo.ABCpdf13;
using WebSupergoo.ABCpdf13.Objects;

public byte[] GeneratePdf(string html)
{
    Doc doc = new Doc();
    doc.HtmlOptions.Engine = EngineType.Chrome;
    doc.Rect.Inset(20, 20);
    doc.AddImageHtml(html);
    byte[] data = doc.GetData();
    doc.Clear();  // Manual cleanup required
    return data;
}

Imports WebSupergoo.ABCpdf13
Imports WebSupergoo.ABCpdf13.Objects

Public Function GeneratePdf(html As String) As Byte()
    Dim doc As New Doc()
    doc.HtmlOptions.Engine = EngineType.Chrome
    doc.Rect.Inset(20, 20)
    doc.AddImageHtml(html)
    Dim data As Byte() = doc.GetData()
    doc.Clear()  ' Manual cleanup required
    Return data
End Function

Après (IronPDF):

using IronPdf;

public byte[] GeneratePdf(string html)
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.MarginTop = 20;
    renderer.RenderingOptions.MarginBottom = 20;
    renderer.RenderingOptions.MarginLeft = 20;
    renderer.RenderingOptions.MarginRight = 20;

    using var pdf = renderer.RenderHtmlAsPdf(html);
    return pdf.BinaryData;  // Automatic cleanup with 'using'
}

using IronPdf;

public byte[] GeneratePdf(string html)
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.MarginTop = 20;
    renderer.RenderingOptions.MarginBottom = 20;
    renderer.RenderingOptions.MarginLeft = 20;
    renderer.RenderingOptions.MarginRight = 20;

    using var pdf = renderer.RenderHtmlAsPdf(html);
    return pdf.BinaryData;  // Automatic cleanup with 'using'
}

Imports IronPdf

Public Function GeneratePdf(html As String) As Byte()
    Dim renderer As New ChromePdfRenderer()
    renderer.RenderingOptions.MarginTop = 20
    renderer.RenderingOptions.MarginBottom = 20
    renderer.RenderingOptions.MarginLeft = 20
    renderer.RenderingOptions.MarginRight = 20

    Using pdf = renderer.RenderHtmlAsPdf(html)
        Return pdf.BinaryData  ' Automatic cleanup with 'Using'
    End Using
End Function

Application Web ASP.NET Core

Pour les équipes qui créent des applications web avec .NET 6+ ou qui prévoient des versions de .NET 10 en 2025-2026, voici le modèle recommandé :

Modèle ABCpdf:

[HttpPost]
public IActionResult GeneratePdf([FromBody] ReportRequest request)
{
    Doc doc = new Doc();
    doc.HtmlOptions.Engine = EngineType.Chrome;
    doc.AddImageHtml(request.Html);
    byte[] pdfBytes = doc.GetData();
    doc.Clear();

    return File(pdfBytes, "application/pdf", "report.pdf");
}

[HttpPost]
public IActionResult GeneratePdf([FromBody] ReportRequest request)
{
    Doc doc = new Doc();
    doc.HtmlOptions.Engine = EngineType.Chrome;
    doc.AddImageHtml(request.Html);
    byte[] pdfBytes = doc.GetData();
    doc.Clear();

    return File(pdfBytes, "application/pdf", "report.pdf");
}

<HttpPost>
Public Function GeneratePdf(<FromBody> request As ReportRequest) As IActionResult
    Dim doc As New Doc()
    doc.HtmlOptions.Engine = EngineType.Chrome
    doc.AddImageHtml(request.Html)
    Dim pdfBytes As Byte() = doc.GetData()
    doc.Clear()

    Return File(pdfBytes, "application/pdf", "report.pdf")
End Function

Modèle IronPDF:

[HttpPost]
public IActionResult GeneratePdf([FromBody] ReportRequest request)
{
    var renderer = new ChromePdfRenderer();
    using var pdf = renderer.RenderHtmlAsPdf(request.Html);

    return File(pdf.BinaryData, "application/pdf", "report.pdf");
}

[HttpPost]
public IActionResult GeneratePdf([FromBody] ReportRequest request)
{
    var renderer = new ChromePdfRenderer();
    using var pdf = renderer.RenderHtmlAsPdf(request.Html);

    return File(pdf.BinaryData, "application/pdf", "report.pdf");
}

<HttpPost>
Public Function GeneratePdf(<FromBody> request As ReportRequest) As IActionResult
    Dim renderer As New ChromePdfRenderer()
    Using pdf = renderer.RenderHtmlAsPdf(request.Html)
        Return File(pdf.BinaryData, "application/pdf", "report.pdf")
    End Using
End Function

Génération de PDFs asynchrone

ABCpdf n'a pas de support asynchrone natif. IronPDF fournit des méthodes d'asynchronisme pour une meilleure performance des applications web :

using IronPdf;

public async Task<byte[]> GeneratePdfAsync(string html)
{
    var renderer = new ChromePdfRenderer();
    using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return pdf.BinaryData;
}

using IronPdf;

public async Task<byte[]> GeneratePdfAsync(string html)
{
    var renderer = new ChromePdfRenderer();
    using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return pdf.BinaryData;
}

Imports IronPdf

Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
    Dim renderer As New ChromePdfRenderer()
    Using pdf = Await renderer.RenderHtmlAsPdfAsync(html)
        Return pdf.BinaryData
    End Using
End Function

Configuration de l'injection de dépendance

Enregistrez IronPDF dans des applications .NET modernes en utilisant des modèles C# 12+ compatibles avec les futures versions C# 14 :

// Program.cs (.NET 6+)
builder.Services.AddSingleton<ChromePdfRenderer>();

// Or create a service wrapper
public interface IPdfService
{
    Task<byte[]> GeneratePdfAsync(string html);
}

public class IronPdfService : IPdfService
{
    private readonly ChromePdfRenderer _renderer;

    public IronPdfService()
    {
        _renderer = new ChromePdfRenderer();
        _renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
    }

    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        using var pdf = await _renderer.RenderHtmlAsPdfAsync(html);
        return pdf.BinaryData;
    }
}

// Register: builder.Services.AddSingleton<IPdfService, IronPdfService>();

// Program.cs (.NET 6+)
builder.Services.AddSingleton<ChromePdfRenderer>();

// Or create a service wrapper
public interface IPdfService
{
    Task<byte[]> GeneratePdfAsync(string html);
}

public class IronPdfService : IPdfService
{
    private readonly ChromePdfRenderer _renderer;

    public IronPdfService()
    {
        _renderer = new ChromePdfRenderer();
        _renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
    }

    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        using var pdf = await _renderer.RenderHtmlAsPdfAsync(html);
        return pdf.BinaryData;
    }
}

// Register: builder.Services.AddSingleton<IPdfService, IronPdfService>();

Imports Microsoft.Extensions.DependencyInjection
Imports System.Threading.Tasks

' Program.vb (.NET 6+)
builder.Services.AddSingleton(Of ChromePdfRenderer)()

' Or create a service wrapper
Public Interface IPdfService
    Function GeneratePdfAsync(html As String) As Task(Of Byte())
End Interface

Public Class IronPdfService
    Implements IPdfService

    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New()
        _renderer = New ChromePdfRenderer()
        _renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
    End Sub

    Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte()) Implements IPdfService.GeneratePdfAsync
        Using pdf = Await _renderer.RenderHtmlAsPdfAsync(html)
            Return pdf.BinaryData
        End Using
    End Function
End Class

' Register: builder.Services.AddSingleton(Of IPdfService, IronPdfService)()

Réutiliser le moteur de rendu pour les opérations par lots

// Good: Single renderer instance
var renderer = new ChromePdfRenderer();
foreach (var html in htmlList)
{
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs($"output_{i}.pdf");
}

// Bad: New renderer each time (slower startup)
foreach (var html in htmlList)
{
    var renderer = new ChromePdfRenderer(); // Overhead!
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs($"output_{i}.pdf");
}

// Good: Single renderer instance
var renderer = new ChromePdfRenderer();
foreach (var html in htmlList)
{
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs($"output_{i}.pdf");
}

// Bad: New renderer each time (slower startup)
foreach (var html in htmlList)
{
    var renderer = new ChromePdfRenderer(); // Overhead!
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs($"output_{i}.pdf");
}

Imports System

' Good: Single renderer instance
Dim renderer As New ChromePdfRenderer()
For Each html In htmlList
    Using pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs($"output_{i}.pdf")
    End Using
Next

' Bad: New renderer each time (slower startup)
For Each html In htmlList
    Dim renderer As New ChromePdfRenderer() ' Overhead!
    Using pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs($"output_{i}.pdf")
    End Using
Next

Comparaison de l'utilisation de la mémoire

PDF Rendus vierges

Symptôme: Le PDF de sortie comporte des pages vides après la migration.

Solution:Le contenu JavaScript peut ne pas être entièrement chargé avant le rendu :

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.WaitFor.RenderDelay(2000); // Wait 2 seconds
// Or wait for specific element:
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded");

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.WaitFor.RenderDelay(2000); // Wait 2 seconds
// Or wait for specific element:
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded");

Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.WaitFor.RenderDelay(2000) ' Wait 2 seconds
' Or wait for specific element:
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded")

Les en-têtes/pieds de page n'apparaissent pas

Symptôme: TextHeader/TextFooter non visible dans la sortie.

Solution: Veiller à ce que les marges laissent de la place pour le contenu de l'en-tête et du pied de page :

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.MarginTop = 40; // mm - leave room for header
renderer.RenderingOptions.MarginBottom = 40; // mm - leave room for footer

renderer.RenderingOptions.TextHeader = new TextHeaderFooter
{
    CenterText = "Header Text",
    FontSize = 12
};

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.MarginTop = 40; // mm - leave room for header
renderer.RenderingOptions.MarginBottom = 40; // mm - leave room for footer

renderer.RenderingOptions.TextHeader = new TextHeaderFooter
{
    CenterText = "Header Text",
    FontSize = 12
};

Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.MarginTop = 40 ' mm - leave room for header
renderer.RenderingOptions.MarginBottom = 40 ' mm - leave room for footer

renderer.RenderingOptions.TextHeader = New TextHeaderFooter With {
    .CenterText = "Header Text",
    .FontSize = 12
}

Pré-migration

• Vérifier toute utilisation d'ABCpdf avec grep -r "WebSupergoo" --include="*.cs" .
• Documenter les exigences actuelles de sortie PDF
• Créer des cas de test avec des exemples de fichiers PDF à des fins de comparaison
• Obtenir une clé de licence IronPDF
• Code source de sauvegarde

Pendant la migration

• Supprimer le package NuGet ABCpdf
• Installez le package NuGet IronPDF
• Ajouter la clé de licence au démarrage de l'application
• Mettre à jour toutes les déclarations using
• Convertir l'instanciation Doc en ChromePdfRenderer
• Remplacez les instructions doc.Clear() par using
• Mettre à jour les appels de méthode par mappage d'API
• Convertir les mises en page basées sur les coordonnées en marges CSS

Après la migration

• Exécuter tous les tests PDF existants
• Comparaison visuelle des fichiers PDF générés (ABCpdf vs IronPDF)
• Tester tous les flux de travail PDF en phase de test
• Comparaison des performances
• Supprimer la configuration de licence ABCpdf
• Mettre à jour les dépendances du pipeline CI/CD