VIDEOS

Wie man CSHTML in PDF unter Verwendung von Razor Headlessly in C# konvertiert

Aktualisiert:18. Mai 2026

Fluid ist eine .NET-Bibliothek (bereitgestellt auf NuGet als Fluid.Core, verfasst von Sebastien Ros, MIT-lizenziert), die die Liquid-Templating-Sprache implementiert und Entwicklern eine flexible Möglichkeit bietet, dynamische Templates zu rendern und Inhalt von Darstellungslogik zu trennen. Fluid ist effektiv bei der Erstellung dynamischer Textausgaben, unterstützt jedoch keine direkte PDF-Erstellung – Entwickler müssen eine zusätzliche PDF-Bibliothek integrieren, um die HTML-Ausgabe in PDF-Dokumente umzuwandeln. 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 zu IronPDF mit Schritt-für-Schritt-Anleitungen, Code-Vergleichen und praktischen Beispielen für professionelle .NET-Entwickler, die diesen Übergang evaluieren.

Warum von Fluid (Templating) zu IronPDF 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.

Liquid Syntax Lernkurve: Entwickler müssen die Liquid-Templating-Syntax ({{ }}, {% %}) lernen, während in C# bereits leistungsstarke Zeichenfolgen-Verarbeitungskapazitäten integriert sind.

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.

Thread-Sicherheitsbedenken: TemplateContext ist nicht thread-sicher und erfordert in gleichzeitigen 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:

# Install IronPDF(all-in-one solution)
dotnet add package IronPdf

# Install IronPDF(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.

Flüssiger 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 Vorlagenzeichenfolge, das Erstellen eines TemplateContext, das Aufrufen von SetValue() für jede Variable, das asynchrone Rendern, um HTML zu erhalten, und dann das Schreiben in eine Datei—was 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.

Flüssiger 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 {{variable}}-Syntax von Liquid mit context.SetValue() für jede Variable. Der Kommentar weist ausdrücklich darauf hin: "Fluid gibt HTML aus - erfordert zusätzliche PDF-Bibliothek."IronPDF verwendet die Standard-C#-Zeichenfolgeninterpolation ($"{variable}")—Syntax, die Entwickler bereits kennen—und gibt direkt als 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.

Flüssiger 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 Templating-Sprache, die Entwickler lernen müssen. Der Kommentar merkt an: "Fluid erzeugt nur HTML - separate PDF-Konvertierung erforderlich."IronPDF verwendet Standard-C#-foreach-Schleifen—keine neue Syntax zu lernen—und gibt direkt als PDF aus.

Fluid API zu IronPDF 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

Flüssige 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;`

Liquid-Syntax zu C# Zuordnung

Flüssige 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 \| anzahl_mit_Genauigkeit: 2}}`	`x.ToString("F2")`

Gängige Migrationsprobleme und Lösungen

Aufgabe 1: Flüssige Syntaxumwandlung

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

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}"; }

' Liquid: {{name | upcase}}
' C#: $"{name.ToUpper()}"
Dim result As String = name.ToUpper()

' Liquid: {% for item in items %}{{item}}{% endfor %}
' C#: foreach (var item in items) { html += $"{item}"; }
For Each item In items
    html &= item.ToString()
Next

$vbLabelText $csharpLabel

Ausgabe 2: TemplateContext-Variablen

Fluid: Verwendet context.SetValue("key", value), um Daten zu übergeben.

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 thread-sicher, erfordert eine sorgfältige Verwaltung in gleichzeitigen Anwendungen.

Lösung: ChromePdfRenderer ist thread-sicher und kann über Threads hinweg geteilt 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

Fluid.Core NuGet-Paket entfernen
Externes PDF-Bibliothekspaket entfernen 3.IronPDF NuGet-Paket installieren
Aktualisieren Sie Namespace-Imports von Fluid zu IronPdf
Konvertieren Sie {{variable}} zu $"{variable}"
Konvertieren Sie {% for item in collection %} zu C# foreach
Konvertieren Sie {% if condition %} zu C# if Anweisungen
Konvertieren Sie Liquid-Filter in C#-Methoden (z. B. |upcase → .ToUpper())
Ersetzen Sie FluidParser durch ChromePdfRenderer
Ersetzen Sie TemplateContext.SetValue() durch direkte C#-Variablen
Externe PDF-Bibliotheksaufrufe entfernen
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 .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 zu IronPDF 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-Erstellung vereinfacht.

Chromium-Rendering-Engine: Das Rendering auf Chromium-Basis unterstützt moderne CSS (einschließlich Flexbox und Grid) und die 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.

Breite .NET-Unterstützung:IronPDF unterstützt .NET Framework 4.6.2+, .NET Core 2.0+, .NET Standard 2.0 und .NET 5 bis .NET 10.

Hinweis:Fluid, PuppeteerSharp und wkhtmltopdf sind Warenzeichen ihrer jeweiligen Eigentümer. Diese Seite ist nicht mit einem dieser Projekte oder deren Verantwortlichen verbunden, unterstützt oder gesponsert. Alle Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Eigentümer. Vergleiche dienen nur zu Informationszwecken und spiegeln öffentlich zugängliche Informationen zum Zeitpunkt des Schreibens wider.

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

Kunden-Highlight:

Entwickler im Rampenlicht:

Webinare:

Starten Sie jetzt Ihre kostenlose 30-Tage-Testphase

Wie man CSHTML in PDF unter Verwendung von Razor Headlessly in C# konvertiert

Warum von Fluid (Templating) zu IronPDF migrieren

IronPDF vs. Fluid (Templating): Funktionsvergleich

Schnellstart: Migration von Fluid zu IronPDF

Schritt 1: Ersetzen von NuGet-Paketen

Schritt 2: Namespaces aktualisieren

Schritt 3: Lizenz initialisieren

Beispiele für die Code-Migration

Einfaches HTML zu PDF

Rechnungsvorlage mit dynamischen Daten

Dynamische Daten mit Schleifen

Fluid API zu IronPDF Mapping Referenz

Kernklassen-Zuordnung

Methoden-Mapping

Liquid-Syntax zu C# Zuordnung

Gängige Migrationsprobleme und Lösungen

Aufgabe 1: Flüssige Syntaxumwandlung

Ausgabe 2: TemplateContext-Variablen

Ausgabe 3: Thread-Sicherheit

Ausgabe 4: Zweistufige Fehlerbehandlung

Checkliste für die flüssige Migration

Vor der Migration anfallende Aufgaben

Aufgaben der Code-Aktualisierung

Post-Migrationstests

Bereinigungsaufgaben

Die wichtigsten Vorteile der Migration zu IronPDF

Ihr Lizenzschlüssel wurde in Ihren Posteingang geliefert

Ihre Demo-Anfrage ist eingegangen.

Iron-Support-Team

Starten Sie jetzt Ihre kostenlose 30-Tage-Testphase

Wie man CSHTML in PDF unter Verwendung von Razor Headlessly in C# konvertiert

Warum von Fluid (Templating) zu IronPDF migrieren

IronPDF vs. Fluid (Templating): Funktionsvergleich

Schnellstart: Migration von Fluid zu IronPDF

Schritt 1: Ersetzen von NuGet-Paketen

Schritt 2: Namespaces aktualisieren

Schritt 3: Lizenz initialisieren

Beispiele für die Code-Migration

Einfaches HTML zu PDF

Rechnungsvorlage mit dynamischen Daten

Dynamische Daten mit Schleifen

Fluid API zu IronPDF Mapping Referenz

Kernklassen-Zuordnung

Methoden-Mapping

Liquid-Syntax zu C# Zuordnung

Gängige Migrationsprobleme und Lösungen

Aufgabe 1: Flüssige Syntaxumwandlung

Ausgabe 2: TemplateContext-Variablen

Ausgabe 3: Thread-Sicherheit

Ausgabe 4: Zweistufige Fehlerbehandlung

Checkliste für die flüssige Migration

Vor der Migration anfallende Aufgaben

Aufgaben der Code-Aktualisierung

Post-Migrationstests

Bereinigungsaufgaben

Die wichtigsten Vorteile der Migration zu IronPDF

Verwandte Artikel

Konvertieren von HTML in PDF mit C# in .NET 10 | IronPDF

Wie man benutzerdefinierte Papierformate für PDFs mit C# setzt | IronPDF

PDF-Seiten umwandeln mit IronPDF in C# | IronPDF

Nächster Schritt: Kostenlosen 30-Tage-Test starten

Thank You

Nächster Schritt: Kostenlosen 30-Tage-Test starten

Möchten Sie IronSuite KOSTENLOS in einem Live-Projekt einsetzen?

DLL-Download

Ihr Lizenzschlüssel wurde in Ihren Posteingang geliefert

Ihre Demo-Anfrage ist eingegangen.

Von Millionen von Ingenieur*innen weltweit vertraut

Iron-Support-Team