Fluid est une bibliothèque .NET (distribuée sur NuGet en tant que Fluid.Core, écrite par Sebastien Ros, sous licence MIT) qui implémente le langage de template Liquid, offrant aux développeurs un moyen flexible de rendre des modèles dynamiques et de séparer le contenu de la logique de présentation. Fluid est efficace pour générer des sorties de texte dynamiques, mais 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.
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 template Liquid ({{ }}, {% %}) alors que C# possède déjà des capacités puissantes de manipulation 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 thread-safe et nécessite une gestion minutieuse 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 Liquid ({{ }}) | 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 |
La migration peut commencer immédiatement grâce à ces étapes fondamentales.
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 usedInstallez IronPDF:
# Install IronPDF(all-in-one solution)
dotnet add package IronPdfRemplacez 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 RenderingOptionsImports Fluid
Imports Fluid.Values
Imports SomeExternalPdfLibrary
Imports IronPdf
Imports IronPdf.Rendering ' For RenderingOptionsAjouter l'initialisation de la licence au démarrage de l'application :
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"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
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 ModuleApproche 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");
}
}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 ClassFluid nécessite la création d'un FluidParser, l'analyse de la chaîne du 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—ce 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 en 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.
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
Imports Fluid
Imports System
Imports System.IO
Imports System.Threading.Tasks
Module Program
Async Function Main() As Task
Dim parser = 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 = 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 ModuleApproche 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
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 ModuleFluid utilise la syntaxe {{variable}} de Liquid avec context.SetValue() pour chaque variable. Le commentaire note explicitement "Fluid produit du HTML - nécessite une bibliothèque PDF supplémentaire."IronPDF utilise l'interpolation de chaînes C# standard ($"{variable}")—une syntaxe déjà connue des développeurs—et produit directement en PDF.
Explorez les tutoriels IronPDF pour découvrir d'autres modèles de génération de documents.
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
Imports Fluid
Imports System.Collections.Generic
Imports System.IO
Imports System.Threading.Tasks
Module Program
Async Function Main() As Task
Dim parser = 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 = 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 ModuleApproche 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
Imports IronPdf
Imports System
Imports System.Collections.Generic
Module Program
Sub Main()
Dim renderer = New ChromePdfRenderer()
Dim title = "My List"
Dim items = {"Item 1", "Item 2", "Item 3"}
Dim html = $"
<html><body>
<h1>{title}</h1>
<ul>"
For Each item In items
html += $"<li>{item}</li>"
Next
html += "</ul></body></html>"
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("template-output.pdf")
End Sub
End ModuleFluid utilise la syntaxe {% for item in items %}...{% endfor %} de Liquid—un langage de template que les développeurs doivent apprendre. Le commentaire note "Fluid génère uniquement du HTML - une conversion PDF séparée est nécessaire."IronPDF utilise les boucles C# foreach standards—pas de nouvelle syntaxe à apprendre—et produit directement en PDF.
Cette cartographie accélère la migration en indiquant les équivalents directs des API :
| 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 |
| 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; |
| 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") |
Fluid : Utilise les syntaxes {{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}"; }Fluid : Utilise context.SetValue("key", value) pour passer 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)
Dim context As New TemplateContext()
context.SetValue("customer", customerName)
' After (IronPDF)
Dim customer = customerName
Dim html = $"<p>Customer: {customer}</p>"Fluid : TemplateContext n'est pas thread-safe, nécessitant 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 Shared ReadOnly _renderer As New ChromePdfRenderer()
Public Function GeneratePdf(html As String) As Byte()
Dim pdf = _renderer.RenderHtmlAsPdf(html)
Return pdf.BinaryData
End FunctionFluide: 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
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 TryAuditez 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 "{{"Documentez tous les modèles : emplacements des fichiers, variables utilisées, boucles et conditionnelles, et configuration de la bibliothèque PDF externe.
Fluid à IronPdf{{variable}} en $"{variable}"{% for item in collection %} en C# foreach{% if condition %} en déclarations C# if|upcase → .ToUpper())FluidParser par ChromePdfRendererTemplateContext.SetValue() par des variables C# directesAprès la migration, vérifiez ces aspects :
.liquid (s'ils ne sont plus nécessaires)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 concurrente de PDF.
Moteur de rendu Chromium : Le rendu basé sur Chromium prend en charge les CSS modernes (y compris Flexbox et Grid) et l'exécution de JavaScript.
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.
**Large couverture .NET :**IronPDF prend en charge .NET Framework 4.6.2+, .NET Core 2.0+, .NET Standard 2.0, et .NET 5 à .NET 10.
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 et créer des manuels bien structurés et visuellement attrayants.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
