Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. Migrationsleitfäden
  4. Migration von Fluid zu IronPDF
MIGRATIONSLEITFäDEN

Umstellung von Fluid (Templating) auf IronPDF

Curtis Chau
Curtis Chau
Aktualisiert:

Fluid ist eine .NET Bibliothek, die die Liquid-Templating-Sprache implementiert und Entwicklern eine flexible Möglichkeit bietet, dynamische Templates zu rendern und Inhalte von der Präsentationslogik zu trennen. Fluid eignet sich zwar gut zur Erzeugung dynamischer Textausgaben, unterstützt aber nicht direkt die PDF-Generierung – Entwickler müssen eine zusätzliche PDF-Bibliothek integrieren, um die HTML-Ausgabe in PDF-Dokumente zu konvertieren. Dieser Ansatz mit zwei Bibliotheken führt zu einer Komplexität, die viele Entwicklungsteams vermeiden möchten.

Dieser Leitfaden bietet einen vollständigen Migrationspfad von Fluid (Templating) mit externen PDF-Bibliotheken zuIronPDF mit Schritt-für-Schritt-Anleitungen, Code-Vergleichen und praktischen Beispielen für professionelle .NET-Entwickler, die diesen Übergang evaluieren.

Warum von Fluid (Templating) zuIronPDF migrieren

Fluid ist eine solide, auf Flüssigkeiten basierende Template-Engine, deren Verwendung zur PDF-Generierung jedoch erhebliche Komplexität mit sich bringt:

Zwei Bibliotheken erforderlich: Fluid generiert nur HTML – Sie benötigen eine separate PDF-Bibliothek (wkhtmltopdf, PuppeteerSharp usw.), um PDFs zu erstellen, was Ihre Abhängigkeiten und Ihren Wartungsaufwand verdoppelt.

Integrationskomplexität: Die Koordination zweier Bibliotheken bedeutet die Verwaltung zweier Konfigurationssätze, Fehlerbehandlung und Aktualisierungen. Wenn etwas nicht funktioniert, wird die Fehlersuche schwieriger.

Lernkurve der Liquid-Syntax: Entwickler müssen die Liquid-Templating-Syntax ({{ }}, {% %}) erlernen, obwohl C# bereits über leistungsstarke integrierte Funktionen zur Stringverarbeitung verfügt.

Eingeschränkte PDF-Kontrolle: Die Qualität Ihrer PDF-Ausgabe hängt von der PDF-Bibliothek ab, die Sie mit Fluid kombinieren, und nicht von einer dedizierten Rendering-Engine.

Herausforderungen bei der Fehlersuche: Fehler können sowohl bei der Erstellung der Vorlagen als auch bei der PDF-Generierung auftreten, was die Fehlersuche schwieriger macht als bei einer einzigen integrierten Lösung.

Bedenken hinsichtlich der Thread-Sicherheit: TemplateContext ist nicht threadsicher und erfordert in parallelen Anwendungen eine sorgfältige Verwaltung.

IronPDF vs. Fluid (Templating): Funktionsvergleich

Das Verständnis der architektonischen Unterschiede hilft technischen Entscheidungsträgern, die Investition in die Migration zu bewerten:

Aspekt Fluid + PDF-Bibliothek IronPDF
Abhängigkeiten 2+ Pakete (Fluid + PDF-Bibliothek) Einzelnes Paket
Vorlagen erstellen Liquid-Syntax ({{ }}) C# String-Interpolation oder Razor
PDF-Erstellung Externe Bibliothek erforderlich Eingebaute Chromium-Engine
CSS-Unterstützung Abhängig von der PDF-Bibliothek Vollständiges CSS3 mit Flexbox/Grid
JavaScript Abhängig von der PDF-Bibliothek Volle JavaScript-Unterstützung
Thread-Sicherheit TemplateContext nicht thread-sicher ChromePdfRenderer ist thread-sicher
Lernkurve Liquid + PDF-Bibliothek API HTML/CSS (Web-Standards)
Fehlerbehandlung Zwei Fehlerquellen Einzelne Fehlerquelle

Schnellstart: Migration von Fluid zu IronPDF

Mit diesen grundlegenden Schritten kann die Migration sofort beginnen.

Schritt 1: Ersetzen von NuGet-Paketen

Entfernen Sie Fluid und alle externen PDF-Bibliotheken:

# 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

IronPDF installieren:

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

Schritt 2: Namespaces aktualisieren

Ersetzen Sie Fluid-Namensräume durch 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

Schritt 3: Lizenz initialisieren

Hinzufügen der Lizenzinitialisierung beim Start der Anwendung:

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

Beispiele für die Code-Migration

Einfaches HTML zu PDF

Der grundlegendste Vorgang offenbart den Hauptunterschied zwischen diesen Ansätzen.

Fluid-Ansatz:

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

IronPDF-Ansatz:

// 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 erfordert das Erstellen eines FluidParser, das Parsen der Vorlagenzeichenkette, das Erstellen eines TemplateContext, das Aufrufen von SetValue() für jede Variable, das asynchrone Rendern, um HTML zu erhalten, und das anschließende Schreiben in eine Datei - die immer noch kein PDF ist. Der Kommentar im Code besagt ausdrücklich: "Fluid erzeugt nur HTML - für die Konvertierung in PDF benötigen Sie eine andere Bibliothek."

IronPDF beseitigt diese Komplexität: Erstellen Sie einen Renderer, rufen Sie RenderHtmlAsPdf() auf und speichern Sie direkt als PDF. Keine HTML-Zwischendateien, keine zusätzlichen Bibliotheken.

Für fortgeschrittene HTML-zu-PDF-Szenarien siehe den HTML-zu-PDF-Konvertierungsleitfaden.

Rechnungsvorlage mit dynamischen Daten

Dokumentvorlagen mit mehreren Variablen zeigen die Unterschiede in den Templates deutlich auf.

Fluid-Ansatz:

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

IronPDF-Ansatz:

// 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 verwendet die Liquid-Syntax {{variable}} mit context.SetValue() für jede Variable. Der Kommentar weist ausdrücklich darauf hin, dass "Fluid HTML ausgibt – eine zusätzliche PDF-Bibliothek ist erforderlich."IronPDF verwendet die standardmäßige C#-Stringinterpolation ($"{variable}") – Syntaxentwicklern bereits bekannt – und gibt direkt in PDF aus.

In den IronPDF-Tutorials finden Sie weitere Muster für die Dokumentenerstellung.

Dynamische Daten mit Schleifen

Vorlagen mit Sammlungen und Schleifen demonstrieren die Unterschiede im Kontrollfluss.

Fluid-Ansatz:

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

IronPDF-Ansatz:

// 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 verwendet die {% for item in items %}...{% endfor %} Syntax von Liquid – eine Template-Sprache, die Entwickler lernen müssen. Der Kommentar merkt an: "Fluid generiert nur HTML – separate PDF-Konvertierung erforderlich."IronPDF verwendet standardmäßige C# foreach Schleifen – keine neue Syntax zu lernen – und gibt die Ausgabe direkt in PDF aus.

Fluid API zuIronPDF Mapping Referenz

Dieses Mapping beschleunigt die Migration, indem es direkte API-Entsprechungen aufzeigt:

Kernklassen-Zuordnung

Fluid-Klasse IronPDF-Äquivalent
FluidParser Nicht anwendbar
FluidTemplate Nicht anwendbar
TemplateContext C# Objekte/Strings
TemplateOptions RenderingOptions
FluidValue Native C#-Typen
Externe PDF-Klasse ChromePdfRenderer

Methoden-Mapping

Fluid-Methode IronPDF-Äquivalent
new FluidParser() new ChromePdfRenderer()
parser.Parse(source) Nicht anwendbar
template.RenderAsync(context) renderer.RenderHtmlAsPdf(html)
context.SetValue("key", value) var key = value;

Flüssige Syntaxzu C# Mapping

Fluid-Syntax C# Äquivalent
{{ variable }} $"{variable}"
{% for item in items %} foreach (var item in items)
{% if condition %} if (condition)
{{ x \| upcase }} x.ToUpper()
{{ x \| datum: '%Y-%m-%d' }} x.ToString("yyyy-MM-dd")
{{ x \| round: 2 }} x.ToString("F2")

Gängige Migrationsprobleme und Lösungen

Aufgabe 1: Flüssige Syntaxumwandlung

Fluid: Verwendet die Syntax {{ variable }} und {% control %}.

Lösung: Ersetzen Sie durch C# String-Interpolation und Kontrollfluss:

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

Ausgabe 2: TemplateContext-Variablen

Fluid: Verwendet context.SetValue("key", value) zur Datenübertragung.

Lösung: Verwenden Sie Standard-C#-Variablen:

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

Ausgabe 3: Thread-Sicherheit

Fluid: TemplateContext ist nicht threadsicher und erfordert daher in parallelen Anwendungen eine sorgfältige Verwaltung.

Lösung: ChromePdfRenderer ist threadsicher und kann von mehreren Threads gemeinsam genutzt werden:

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

Ausgabe 4: Zweistufige Fehlerbehandlung

Fluid: Fehler können bei der Erstellung von Vorlagen ODER bei der PDF-Erzeugung auftreten.

Lösung:IronPDF hat eine einzige Fehlerquelle:

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

Checkliste für die flüssige Migration

Vor der Migration anfallende Aufgaben

Überprüfen Sie Ihre Codebasis, um alle Fluid-Verwendungen zu identifizieren:

# 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

Dokumentieren Sie alle Vorlagen: Dateispeicherorte, verwendete Variablen, Schleifen und Bedingungen sowie die Konfiguration der externen PDF-Bibliothek.

Aufgaben der Code-Aktualisierung

  1. Fluid.Core NuGet-Paket entfernen
  2. Externes PDF-Bibliothekspaket entfernen 3.IronPDF NuGet-Paket installieren
  3. Namespace-Importe von Fluid auf IronPdf aktualisieren
  4. Konvertiere {{ variable }} in $"{variable}"
  5. Konvertiere {% for item in collection %} in C# foreach
  6. Konvertieren Sie {% if condition %} in C# if Anweisungen
  7. Konvertieren Sie Liquid-Filter in C#-Methoden (z. B. | upcase → .ToUpper())
  8. Ersetzen Sie FluidParser durch ChromePdfRenderer
  9. Ersetzen Sie TemplateContext.SetValue() durch direkte C#-Variablen
  10. Externe PDF-Bibliotheksaufrufe entfernen
  11. IronPDF-Lizenzinitialisierung beim Start hinzufügen

Post-Migrationstests

Überprüfen Sie diese Aspekte nach der Migration:

  • Überprüfen der PDF-Ausgabe auf Übereinstimmung mit den Erwartungen
  • Testen Sie die korrekte Wiedergabe aller Vorlagenvarianten
  • Prüfen Sie die korrekte Darstellung von Bildern und Stilen
  • Validierung der korrekten Seitenumbrüche
  • Test mit verschiedenen Datengrößen
  • Leistungstests vs. Fluid + externe Bibliothek
  • Testen der Thread-Sicherheit in gleichzeitigen Szenarien

Bereinigungsaufgaben

  • Löschen Sie die .liquid Vorlagendateien (falls nicht mehr benötigt)
  • Fluid-bezogenen Hilfscode entfernen
  • Dokumentation aktualisieren
  • Bereinigen Sie ungenutzte Abhängigkeiten

Die wichtigsten Vorteile der Migration zu IronPDF

Der Wechsel von Fluid (Templating) mit externen PDF-Bibliotheken zuIronPDF bietet mehrere entscheidende Vorteile:

Lösung mit einem einzigen Paket: Beseitigung der Abhängigkeit von zwei Bibliotheken.IronPDF beherrscht sowohl das Templating (über HTML/CSS) als auch die PDF-Generierung in einem Paket.

Keine neue Syntax zu lernen: Verwenden Sie die standardmäßige C#-Stringinterpolation und den Kontrollfluss, anstatt die Liquid-Templating-Syntax zu erlernen.

Thread-sicheres Rendering: ChromePdfRenderer ist thread-sicher, im Gegensatz zu TemplateContext, was die gleichzeitige PDF-Generierung vereinfacht.

Chromium Rendering Engine: Branchenübliches Rendering gewährleistet volle CSS3-Unterstützung einschließlich Flexbox und Grid Plus die vollständige Ausführung von JavaScript .

Eine einzige Fehlerquelle: Die Fehlersuche wird einfacher, da nur eine Bibliothek zur Fehlerbehebung benötigt wird, anstatt die Phasen der Vorlagenerstellung und der PDF-Generierung zu koordinieren.

Aktive Weiterentwicklung: Da die Verbreitung von .NET 10 und C# 14 bis 2026 zunimmt, gewährleisten die regelmäßigen Updates vonIronPDF die Kompatibilität mit aktuellen und zukünftigen .NET Versionen.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an