Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Guides de migration
  4. Migration de Fluid vers IronPDF
GUIDES DE MIGRATION

Migration de Fluid (Templating) vers IronPDF

Curtis Chau
Curtis Chau
Mis à jour:

Fluid est une bibliothèque .NET qui implémente le langage de modèles Liquid, offrant aux développeurs une manière flexible de générer des modèles dynamiques et de séparer le contenu de la logique de présentation. Bien que Fluid soit efficace pour générer des sorties de texte dynamiques, il ne prend pas directement en charge la génération de PDF ; les développeurs doivent intégrer une bibliothèque PDF supplémentaire pour convertir la sortie HTML en documents PDF. Cette approche à deux bibliothèques introduit une complexité que de nombreuses équipes de développement cherchent à éliminer.

Ce guide fournit un chemin de migration complet de Fluid (templating) avec des bibliothèques PDF externes vers IronPDF, avec des instructions étape par étape, des comparaisons de code et des exemples pratiques pour les développeurs .NET professionnels qui évaluent cette transition.

Pourquoi migrer de Fluid (Templating) vers IronPDF

Fluid est un moteur de modèles solide basé sur Liquid, mais son utilisation pour la génération de PDF introduit une complexité importante :

Dépendance à deux bibliothèques : Fluid ne génère que du HTML ; vous avez besoin d'une bibliothèque PDF distincte (wkhtmltopdf, PuppeteerSharp, etc.) pour créer des PDF, ce qui double vos dépendances et votre charge de maintenance.

Complexité de l'intégration : coordonner deux bibliothèques implique de gérer deux ensembles de configurations, de gestion des erreurs et de mises à jour. Lorsque quelque chose se casse, le débogage devient plus difficile.

Courbe d'apprentissage de la syntaxe Liquid : les développeurs doivent apprendre la syntaxe de modèle Liquid ({{ }}, {% %}) alors que C# possède déjà de puissantes capacités de gestion de chaînes intégrées.

Contrôle limité des PDF : la qualité de vos fichiers PDF dépend de la bibliothèque PDF que vous choisissez d'associer à Fluid, et non d'un moteur de rendu dédié.

Difficultés de débogage : des erreurs peuvent survenir lors de la création des modèles ou de la génération des PDF, ce qui rend le dépannage plus difficile qu'avec une solution intégrée unique.

Problèmes de sécurité des threads : TemplateContext n'est pas sûr pour les threads et nécessite une gestion attentive dans les applications concurrentes.

IronPDF vs Fluid (Templating) : Comparaison des fonctionnalités

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

Aspect Bibliothèque Fluid + PDF IronPDF
Dépendances 2+ packages (Fluid + bibliothèque PDF) Paquet unique
Templir Syntaxe liquide ({{ }}) Interpolation de chaînes de caractères en C# ou Razor
Génération de PDF Bibliothèque externe requise Moteur Chromium intégré
Support CSS Dépend de la bibliothèque PDF CSS3 complet avec Flexbox/Grid
JavaScript Dépend de la bibliothèque PDF Prise en charge complète de JavaScript
Sécurité des threads TemplateContext n'est pas sûr pour les threads ChromePdfRenderer est sûr pour les threads
Courbe d'apprentissage Bibliothèque Liquid + PDF API HTML/CSS (normes web)
Gestion des erreurs Deux sources d'erreurs Une seule source d'erreur

Démarrage rapide : Migration de Fluid vers IronPDF

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

Étape 1 : Remplacer les paquets NuGet

Supprimez Fluid et toute bibliothèque PDF externe :

# Remove Fluid and external PDF library
dotnet remove package Fluid.Core
dotnet remove package WkHtmlToPdf-DotNet  # or whatever PDF library you used
dotnet remove package PuppeteerSharp       # if used
# Remove Fluid and external PDF library
dotnet remove package Fluid.Core
dotnet remove package WkHtmlToPdf-DotNet  # or whatever PDF library you used
dotnet remove package PuppeteerSharp       # if used
SHELL

Installez IronPDF :

# InstallIronPDF(all-in-one solution)
dotnet add package IronPdf
# InstallIronPDF(all-in-one solution)
dotnet add package IronPdf
SHELL

Étape 2 : Mise à jour des espaces de noms

Remplacez les espaces de noms Fluid par IronPDF :

// Before (Fluid + external PDF library)
using Fluid;
using Fluid.Values;
using SomeExternalPdfLibrary;

// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;  // For RenderingOptions
// Before (Fluid + external PDF library)
using Fluid;
using Fluid.Values;
using SomeExternalPdfLibrary;

// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;  // For RenderingOptions
Imports Fluid
Imports Fluid.Values
Imports SomeExternalPdfLibrary

Imports IronPdf
Imports IronPdf.Rendering ' For RenderingOptions
$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

Les bases du HTML au PDF

L'opération la plus fondamentale révèle la différence essentielle entre ces approches.

Approche fluide:

// NuGet: Install-Package Fluid.Core
using Fluid;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var parser = new FluidParser();
        var template = parser.Parse("<html><body><h1>Hello {{name}}!</h1></body></html>");
        var context = new TemplateContext();
        context.SetValue("name", "World");
        var html = await template.RenderAsync(context);

        // Fluid only generates HTML - you'd need another library to convert to PDF
        File.WriteAllText("output.html", html);
    }
}
// NuGet: Install-Package Fluid.Core
using Fluid;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var parser = new FluidParser();
        var template = parser.Parse("<html><body><h1>Hello {{name}}!</h1></body></html>");
        var context = new TemplateContext();
        context.SetValue("name", "World");
        var html = await template.RenderAsync(context);

        // Fluid only generates HTML - you'd need another library to convert to PDF
        File.WriteAllText("output.html", html);
    }
}
Imports Fluid
Imports System.IO
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim parser As New FluidParser()
        Dim template = parser.Parse("<html><body><h1>Hello {{name}}!</h1></body></html>")
        Dim context As New TemplateContext()
        context.SetValue("name", "World")
        Dim html = Await template.RenderAsync(context)

        ' Fluid only generates HTML - you'd need another library to convert to PDF
        File.WriteAllText("output.html", html)
    End Function
End Module
$vbLabelText   $csharpLabel

Approche IronPDF:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World!</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World!</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html = "<html><body><h1>Hello World!</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Fluid nécessite la création d'un FluidParser, l'analyse de la chaîne modèle, la création d'un TemplateContext, l'appel de SetValue() pour chaque variable, le rendu asynchrone pour obtenir du HTML, puis l'écriture dans un fichier, qui n'est toujours pas un PDF. Le commentaire dans le code indique explicitement que "Fluid ne génère que du HTML - vous aurez besoin d'une autre bibliothèque pour convertir en PDF"

IronPDF élimine cette complexité : créez un moteur de rendu, appelez RenderHtmlAsPdf() et enregistrez directement au format PDF. Pas de fichiers HTML intermédiaires, pas de bibliothèques supplémentaires.

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

Modèle de facture avec données dynamiques

Les modèles de documents comportant plusieurs variables montrent clairement les différences de modèles.

Approche fluide:

// NuGet: Install-Package Fluid.Core
using Fluid;
using System;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var parser = new FluidParser();
        var template = parser.Parse(@"
            <html><body>
                <h1>Invoice #{{invoiceNumber}}</h1>
                <p>Date: {{date}}</p>
                <p>Customer: {{customer}}</p>
                <p>Total: ${{total}}</p>
            </body></html>");

        var context = new TemplateContext();
        context.SetValue("invoiceNumber", "12345");
        context.SetValue("date", DateTime.Now.ToShortDateString());
        context.SetValue("customer", "John Doe");
        context.SetValue("total", 599.99);

        var html = await template.RenderAsync(context);
        // Fluid outputs HTML - requires additional PDF library
        File.WriteAllText("invoice.html", html);
    }
}
// NuGet: Install-Package Fluid.Core
using Fluid;
using System;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var parser = new FluidParser();
        var template = parser.Parse(@"
            <html><body>
                <h1>Invoice #{{invoiceNumber}}</h1>
                <p>Date: {{date}}</p>
                <p>Customer: {{customer}}</p>
                <p>Total: ${{total}}</p>
            </body></html>");

        var context = new TemplateContext();
        context.SetValue("invoiceNumber", "12345");
        context.SetValue("date", DateTime.Now.ToShortDateString());
        context.SetValue("customer", "John Doe");
        context.SetValue("total", 599.99);

        var html = await template.RenderAsync(context);
        // Fluid outputs HTML - requires additional PDF library
        File.WriteAllText("invoice.html", html);
    }
}
Imports Fluid
Imports System
Imports System.IO
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim parser As New FluidParser()
        Dim template = parser.Parse("
            <html><body>
                <h1>Invoice #{{invoiceNumber}}</h1>
                <p>Date: {{date}}</p>
                <p>Customer: {{customer}}</p>
                <p>Total: ${{total}}</p>
            </body></html>")

        Dim context As New TemplateContext()
        context.SetValue("invoiceNumber", "12345")
        context.SetValue("date", DateTime.Now.ToShortDateString())
        context.SetValue("customer", "John Doe")
        context.SetValue("total", 599.99)

        Dim html = Await template.RenderAsync(context)
        ' Fluid outputs HTML - requires additional PDF library
        File.WriteAllText("invoice.html", html)
    End Function
End Module
$vbLabelText   $csharpLabel

Approche IronPDF:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var invoiceNumber = "12345";
        var date = DateTime.Now.ToShortDateString();
        var customer = "John Doe";
        var total = 599.99;

        var html = $@"
            <html><body>
                <h1>Invoice #{invoiceNumber}</h1>
                <p>Date: {date}</p>
                <p>Customer: {customer}</p>
                <p>Total: ${total}</p>
            </body></html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("invoice.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var invoiceNumber = "12345";
        var date = DateTime.Now.ToShortDateString();
        var customer = "John Doe";
        var total = 599.99;

        var html = $@"
            <html><body>
                <h1>Invoice #{invoiceNumber}</h1>
                <p>Date: {date}</p>
                <p>Customer: {customer}</p>
                <p>Total: ${total}</p>
            </body></html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("invoice.pdf");
    }
}
Imports IronPdf
Imports System

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        Dim invoiceNumber As String = "12345"
        Dim [date] As String = DateTime.Now.ToShortDateString()
        Dim customer As String = "John Doe"
        Dim total As Double = 599.99

        Dim html As String = $"
            <html><body>
                <h1>Invoice #{invoiceNumber}</h1>
                <p>Date: {[date]}</p>
                <p>Customer: {customer}</p>
                <p>Total: ${total}</p>
            </body></html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("invoice.pdf")
    End Sub
End Module
$vbLabelText   $csharpLabel

Fluid utilise la syntaxe {{variable}} de Liquid avec context.SetValue() pour chaque variable. Le commentaire indique explicitement que " Fluid génère du HTML et nécessite une bibliothèque PDF supplémentaire ". IronPDF utilise l'interpolation de chaînes C# standard ($"{variable}") — une syntaxe que les développeurs connaissent déjà — et génère directement un PDF.

Explorez les tutoriels IronPDF pour découvrir d'autres modèles de génération de documents.

Données dynamiques avec des boucles

Des modèles avec des collections et des boucles démontrent les différences de flux de contrôle.

Approche fluide:

// NuGet: Install-Package Fluid.Core
using Fluid;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var parser = new FluidParser();
        var template = parser.Parse(@"
            <html><body>
                <h1>{{title}}</h1>
                <ul>
                {% for item in items %}
                    <li>{{item}}</li>
                {% endfor %}
                </ul>
            </body></html>");

        var context = new TemplateContext();
        context.SetValue("title", "My List");
        context.SetValue("items", new[] { "Item 1", "Item 2", "Item 3" });

        var html = await template.RenderAsync(context);
        // Fluid generates HTML only - separate PDF conversion needed
        File.WriteAllText("template-output.html", html);
    }
}
// NuGet: Install-Package Fluid.Core
using Fluid;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var parser = new FluidParser();
        var template = parser.Parse(@"
            <html><body>
                <h1>{{title}}</h1>
                <ul>
                {% for item in items %}
                    <li>{{item}}</li>
                {% endfor %}
                </ul>
            </body></html>");

        var context = new TemplateContext();
        context.SetValue("title", "My List");
        context.SetValue("items", new[] { "Item 1", "Item 2", "Item 3" });

        var html = await template.RenderAsync(context);
        // Fluid generates HTML only - separate PDF conversion needed
        File.WriteAllText("template-output.html", html);
    }
}
Imports Fluid
Imports System.Collections.Generic
Imports System.IO
Imports System.Threading.Tasks

Class Program
    Shared Async Function Main() As Task
        Dim parser As New FluidParser()
        Dim template = parser.Parse("
            <html><body>
                <h1>{{title}}</h1>
                <ul>
                {% for item in items %}
                    <li>{{item}}</li>
                {% endfor %}
                </ul>
            </body></html>")

        Dim context As New TemplateContext()
        context.SetValue("title", "My List")
        context.SetValue("items", New String() {"Item 1", "Item 2", "Item 3"})

        Dim html = Await template.RenderAsync(context)
        ' Fluid generates HTML only - separate PDF conversion needed
        File.WriteAllText("template-output.html", html)
    End Function
End Class
$vbLabelText   $csharpLabel

Approche IronPDF:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var title = "My List";
        var items = new[] { "Item 1", "Item 2", "Item 3" };

        var html = $@"
            <html><body>
                <h1>{title}</h1>
                <ul>";

        foreach (var item in items)
        {
            html += $"<li>{item}</li>";
        }

        html += "</ul></body></html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("template-output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var title = "My List";
        var items = new[] { "Item 1", "Item 2", "Item 3" };

        var html = $@"
            <html><body>
                <h1>{title}</h1>
                <ul>";

        foreach (var item in items)
        {
            html += $"<li>{item}</li>";
        }

        html += "</ul></body></html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("template-output.pdf");
    }
}
Imports IronPdf
Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        Dim title As String = "My List"
        Dim items As String() = {"Item 1", "Item 2", "Item 3"}

        Dim html As String = $"
            <html><body>
                <h1>{title}</h1>
                <ul>"

        For Each item As String In items
            html += $"<li>{item}</li>"
        Next

        html += "</ul></body></html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("template-output.pdf")
    End Sub
End Module
$vbLabelText   $csharpLabel

Fluid utilise la syntaxe {% for item in items %}...{% endfor %} de Liquid, un langage de modèles que les développeurs doivent apprendre. Le commentaire indique : " Fluid génère uniquement du HTML ; une conversion PDF séparée est nécessaire. "IronPDF utilise des boucles C# standard (pas de nouvelle syntaxe à apprendre) et génère directement un PDF.

Référence de mappage de l'API fluide vers IronPDF

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

Mappage des classes de base

Classe Fluide Équivalent d'IronPDF
FluidParser N/A
FluidTemplate N/A
TemplateContext Objets/chaînes C#
TemplateOptions RenderingOptions
FluidValue Types de C# natifs
Classe PDF externe ChromePdfRenderer

Mise en correspondance des méthodes

Méthode fluide Équivalent d'IronPDF
new FluidParser() new ChromePdfRenderer()
parser.Parse(source) N/A
template.RenderAsync(context) renderer.RenderHtmlAsPdf(html)
context.SetValue("key", value) var key = value;

Mappage de la syntaxe liquide vers C

Syntaxe de Liquid Équivalent en C#
{{ variable }} $"{variable}"
{% for item in items %} foreach (var item in items)
{% if condition %} if (condition)
{{ x \| upcase }} x.ToUpper()
{{ x \| date : '%Y-%m-%d' }} x.ToString("yyyy-MM-dd")
{{ x \| number_with_precision : 2 }} x.ToString("F2")

Problèmes de migration courants et solutions

Édition 1 : Conversion de la syntaxe liquide

Fluide : Utilise la syntaxe {{ variable }} et {% control %}.

Solution: Remplacer par l'interpolation de chaînes de caractères et le flux de contrôle en C# :

// Liquid: {{ name | upcase }}
// C#: $"{name.ToUpper()}"

// Liquid: {% for item in items %}{{item}}{% endfor %}
// C#: foreach (var item in items) { html += $"{item}"; }
// Liquid: {{ name | upcase }}
// C#: $"{name.ToUpper()}"

// Liquid: {% for item in items %}{{item}}{% endfor %}
// C#: foreach (var item in items) { html += $"{item}"; }
$vbLabelText   $csharpLabel

Edition 2 : Variables TemplateContext

Fluide : Utilise context.SetValue("key", value) pour transmettre des données.

Solution: Utilisez des variables C# standard :

// Before (Fluid)
var context = new TemplateContext();
context.SetValue("customer", customerName);

// After (IronPDF)
var customer = customerName;
var html = $"<p>Customer: {customer}</p>";
// Before (Fluid)
var context = new TemplateContext();
context.SetValue("customer", customerName);

// After (IronPDF)
var customer = customerName;
var html = $"<p>Customer: {customer}</p>";
' Before (Fluid)
Dim context As New TemplateContext()
context.SetValue("customer", customerName)

' After (IronPDF)
Dim customer = customerName
Dim html = $"<p>Customer: {customer}</p>"
$vbLabelText   $csharpLabel

Numéro 3 : Thread Safety

Fluide : TemplateContext n'est pas sûr pour les threads, ce qui nécessite une gestion attentive dans les applications concurrentes.

Solution : ChromePdfRenderer est thread-safe et peut être partagé entre les threads :

// Thread-safe usage
private static readonly ChromePdfRenderer _renderer = new ChromePdfRenderer();

public byte[] GeneratePdf(string html)
{
    var pdf = _renderer.RenderHtmlAsPdf(html);
    return pdf.BinaryData;
}
// Thread-safe usage
private static readonly ChromePdfRenderer _renderer = new ChromePdfRenderer();

public byte[] GeneratePdf(string html)
{
    var pdf = _renderer.RenderHtmlAsPdf(html);
    return pdf.BinaryData;
}
' Thread-safe usage
Private Shared ReadOnly _renderer As New ChromePdfRenderer()

Public Function GeneratePdf(html As String) As Byte()
    Dim pdf = _renderer.RenderHtmlAsPdf(html)
    Return pdf.BinaryData
End Function
$vbLabelText   $csharpLabel

Edition 4 : Traitement des erreurs en deux étapes

Fluide: Des erreurs peuvent se produire à l'étape de la mise en page OU à l'étape de la génération du PDF.

Solution:IronPDF a une seule source d'erreur :

try
{
    var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs("output.pdf");
}
catch (Exception ex)
{
    // Single point of failure—easier debugging
    Console.WriteLine($"PDF generation failed: {ex.Message}");
}
try
{
    var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs("output.pdf");
}
catch (Exception ex)
{
    // Single point of failure—easier debugging
    Console.WriteLine($"PDF generation failed: {ex.Message}");
}
Try
    Dim pdf = renderer.RenderHtmlAsPdf(html)
    pdf.SaveAs("output.pdf")
Catch ex As Exception
    ' Single point of failure—easier debugging
    Console.WriteLine($"PDF generation failed: {ex.Message}")
End Try
$vbLabelText   $csharpLabel

Liste de contrôle de la migration des fluides

Tâches préalables à la migration

Auditez votre base de code pour identifier toutes les utilisations de Fluid :

# Find all Fluid references
grep -r "FluidParser\|FluidTemplate\|TemplateContext\|using Fluid" --include="*.cs" --include="*.csproj" .

# Find Liquid template files
find . -name "*.liquid" -o -name "*.html" | xargs grep -l "{{"
# Find all Fluid references
grep -r "FluidParser\|FluidTemplate\|TemplateContext\|using Fluid" --include="*.cs" --include="*.csproj" .

# Find Liquid template files
find . -name "*.liquid" -o -name "*.html" | xargs grep -l "{{"
SHELL

Documentez tous les modèles : emplacements des fichiers, variables utilisées, boucles et conditionnelles, et configuration de la bibliothèque PDF externe.

Tâches de mise à jour du code

  1. Supprimer le paquet NuGet Fluid.Core
  2. Suppression d'une bibliothèque PDF externe
  3. Installer le paquet NuGet IronPDF
  4. Mettez à jour les importations d'espace de noms de Fluid à IronPdf
  5. Convertir {{ variable }} en $"{variable}"
  6. Convertir {% for item in collection %} en C# foreach
  7. Convertir {% if condition %} en instructions C# if
  8. Convertir les filtres Liquid en méthodes C# (par exemple, | upcase → .ToUpper())
  9. Remplacez FluidParser par ChromePdfRenderer
  10. Remplacez TemplateContext.SetValue() par des variables C# directes
  11. Supprimer les appels à la bibliothèque PDF externe
  12. Ajouter l'initialisation de la licence IronPDF au démarrage

Test de post-migration

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

  • Vérifier que la sortie PDF correspond aux attentes
  • Testez le bon rendu de toutes les variantes du modèle
  • Vérifier que les images et le style s'affichent correctement
  • Valider que les sauts de page se produisent correctement
  • Test avec différentes tailles de données
  • Test de performance vs Fluid + bibliothèque externe
  • Tester la sécurité des threads dans des scénarios concurrents

Tâches de nettoyage

  • Supprimez les fichiers modèles .liquid (s'ils ne sont plus nécessaires)
  • Suppression du code d'aide lié à Fluid
  • Mise à jour de la documentation
  • Nettoyer les dépendances inutilisées

Avantages clés de la migration vers IronPDF

Passer de Fluid (templating) avec des bibliothèques PDF externes à IronPDF offre plusieurs avantages cruciaux :

Solution à package unique : éliminez la dépendance à deux bibliothèques. IronPDF gère à la fois la création de modèles (via HTML/CSS) et la génération de PDF dans un seul et même package.

Aucune nouvelle syntaxe à apprendre : utilisez l'interpolation de chaînes et le flux de contrôle standard de C# au lieu d'apprendre la syntaxe des modèles Liquid.

Rendu thread-safe : ChromePdfRenderer est thread-safe, contrairement à TemplateContext, simplifiant la génération de PDF simultanée.

Moteur de rendu Chromium : Le rendu conforme aux normes de l'industrie assure une prise en charge complète de CSS3, y compris Flexbox et Grid, Plus qu'une exécution JavaScript complète.

Source d'erreur unique : le débogage est simplifié grâce à une seule bibliothèque à dépanner, au lieu de devoir coordonner les étapes de création de modèles et de génération de PDF.

Développement actif : Avec l'adoption croissante de .NET 10 et C# 14 jusqu'en 2026, les mises à jour régulières d'IronPDF garantissent la compatibilité avec les versions actuelles et futures de .NET .

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

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