Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Przewodniki migracji
  4. Migracja z Fluid do IronPDF
PRZEWODNIKI MIGRACJI

Migracja z Fluid (szablony) do IronPDF

Curtis Chau
Curtis Chau
Zaktualizowano:

Fluid to biblioteka .NET, która implementuje język szablonów Liquid, oferując programistom elastyczny sposób renderowania dynamicznych szablonów oraz oddzielenia treści od logiki prezentacji. Chociaż Fluid skutecznie generuje dynamiczne wyniki tekstowe, nie obsługuje bezpośrednio tworzenia plików PDF — programiści muszą zintegrować dodatkową bibliotekę PDF, aby przekonwertować wynik HTML na dokumenty PDF. Takie podejście oparte na dwóch bibliotekach wprowadza złożoność, którą wiele zespołów programistycznych stara się wyeliminować.

Niniejszy przewodnik zawiera kompletną ścieżkę migracji z Fluid (szablony) z zewnętrznymi bibliotekami PDF do IronPDF, wraz z instrukcjami krok po kroku, porównaniami kodu i praktycznymi przykładami dla profesjonalnych programistów .NET rozważających tę zmianę.

Dlaczego warto przejść z Fluid (Templating) na IronPDF

Fluid to solidny silnik szablonów oparty na Liquid, ale użycie go do generowania plików PDF wiąże się ze znacznym stopniem złożoności:

Zależność od dwóch bibliotek: Fluid generuje wyłącznie kod HTML — do tworzenia plików PDF potrzebna jest osobna biblioteka do obsługi formatu PDF (wkhtmltopdf, PuppeteerSharp itp.), co podwaja liczbę zależności i obciążenie związane z utrzymaniem.

Złożoność integracji: Koordynacja dwóch bibliotek oznacza zarządzanie dwoma zestawami konfiguracji, obsługą błędów i aktualizacjami. Kiedy coś się psuje, debugowanie staje się trudniejsze.

Krzywa uczenia się składni Liquid: Programiści muszą nauczyć się składni szablonów Liquid ({{ }}, {% %}), podczas gdy język C# ma już wbudowane potężne możliwości obsługi ciągów znaków.

Ograniczona kontrola nad plikami PDF: Jakość wyjściowego pliku PDF zależy od biblioteki PDF, którą wybierzesz do połączenia z Fluid, a nie od dedykowanego silnika renderującego.

Wyzwania związane z debugowaniem: Błędy mogą wystąpić zarówno na etapie tworzenia szablonów, jak i generowania plików PDF, co sprawia, że rozwiązywanie problemów jest trudniejsze niż w przypadku pojedynczego, zintegrowanego rozwiązania.

Kwestie związane z bezpieczeństwem wątków: TemplateContext nie jest bezpieczne dla wątków i wymaga ostrożnego zarządzania w aplikacjach działających współbieżnie.

IronPDFvs Fluid (szablony): Porównanie funkcji

Zrozumienie różnic architektonicznych pomaga decydentom technicznym w ocenie inwestycji w migrację:

Aspekt Fluid + Biblioteka PDF IronPDF
Zależności 2+ pakiety (Fluid + biblioteka PDF) Pojedynczy pakiet
Szablony Składnia Liquid ({{ }}) Interpolacja ciągów znaków w języku C# lub Razor
Generowanie plików PDF Wymagana biblioteka zewnętrzna Wbudowany silnik Chromium
Obsługa CSS Zależy od biblioteki PDF Pełna obsługa CSS3 z Flexbox/Grid
JavaScript Zależy od biblioteki PDF Pełna obsługa JavaScript
Bezpieczeństwo wątków TemplateContext nie jest bezpieczny dla wątków ChromePdfRenderer jest bezpieczny dla wątków
Krzywa uczenia się Liquid + biblioteka API PDF HTML/CSS (standardy internetowe)
Obsługa błędów Dwa źródła błędów Pojedyncze źródło błędu

Szybki start: Migracja z Fluid do IronPDF

Migrację można rozpocząć natychmiast, wykonując te podstawowe kroki.

Krok 1: Zastąp pakiety NuGet

Usuń Fluid i wszelkie zewnętrzne biblioteki PDF:

# 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

Zainstaluj IronPDF:

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

Krok 2: Aktualizacja przestrzeni nazw

Zastąp przestrzenie nazw Fluid przez 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

Krok 3: Inicjalizacja licencji

Dodaj inicjalizację licencji podczas uruchamiania aplikacji:

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

Przykłady migracji kodu

Podstawowy HTML do PDF

Najbardziej podstawowa operacja ujawnia kluczową różnicę między tymi podejściami.

Płynne podejście:

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

Podejście 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 wymaga utworzenia FluidParser, przeanalizowania ciągu szablonu, utworzenia TemplateContext, wywołania SetValue() dla każdej zmiennej, asynchronicznego renderowania w celu uzyskania kodu HTML, a następnie zapisania do pliku — który nadal nie jest plikiem PDF. Komentarz w kodzie wyraźnie stwierdza: "Fluid generuje wyłącznie HTML — do konwersji do formatu PDF potrzebna jest inna biblioteka".

IronPDF eliminuje tę złożoność: wystarczy utworzyć renderer, wywołać RenderHtmlAsPdf() i zapisać bezpośrednio do pliku PDF. Bez pośrednich plików HTML, bez dodatkowych bibliotek.

W przypadku zaawansowanych scenariuszy konwersji HTML do PDF zapoznaj się z przewodnikiem po konwersji HTML do PDF.

Szablon faktury z danymi dynamicznymi

Szablony dokumentów z wieloma zmiennymi wyraźnie pokazują różnice w wzorcach szablonów.

Płynne podejście:

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

Podejście 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 używa składni Liquid {{variable}} z context.SetValue() dla każdej zmiennej. W komentarzu wyraźnie zaznaczono: "Fluid generuje kod HTML — wymaga dodatkowej biblioteki PDF".IronPDFwykorzystuje standardową interpolację ciągów znaków w języku C# ($"{variable}") — składnię znaną programistom — i generuje pliki bezpośrednio w formacie PDF.

Zapoznaj się z samouczkami IronPDF, aby poznać więcej wzorców generowania dokumentów.

Dane dynamiczne z pętlami

Szablony z kolekcjami i pętlami pokazują różnice w przebiegu programu.

Płynne podejście:

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

Podejście 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 wykorzystuje składnię Liquid {% for item in items %}...{% endfor %} — język szablonów, którego programiści muszą się nauczyć. W komentarzu zaznaczono: "Fluid generuje wyłącznie kod HTML — konieczna jest oddzielna konwersja do formatu PDF".IronPDFwykorzystuje standardowe pętle C# foreach — nie trzeba uczyć się nowej składni — i generuje pliki bezpośrednio w formacie PDF.

Przewodnik po mapowaniu Fluid API do IronPDF

To mapowanie przyspiesza migrację, pokazując bezpośrednie odpowiedniki API:

Mapowanie klas podstawowych

Klasa Fluid OdpowiednikIronPDF
FluidParser Nie dotyczy
FluidTemplate Nie dotyczy
TemplateContext Obiekty/ciągi znaków w języku C#
TemplateOptions RenderingOptions
FluidValue Natywne typy C#
Zewnętrzna klasa PDF ChromePdfRenderer

Mapowanie metod

Metoda płynna OdpowiednikIronPDF
new FluidParser() new ChromePdfRenderer()
parser.Parse(source) Nie dotyczy
template.RenderAsync(context) renderer.RenderHtmlAsPdf(html)
context.SetValue("key", value) var key = value;

Mapowanie składni Liquid na C

Liquid Syntax Odpowiednik w języku 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")

Typowe problemy związane z migracją i ich rozwiązania

Problem 1: Konwersja składni Liquid

Fluid: Wykorzystuje składnię {{ variable }} i {% control %}.

Rozwiązanie: Zastąp interpolacją ciągów znaków w języku C# i kontrolą przepływu:

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

Problem 2: Zmienne TemplateContext

Fluid: Używa context.SetValue("key", value) do przekazywania danych.

Rozwiązanie: Użyj standardowych zmiennych języka C#:

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

Problem 3: Bezpieczeństwo wątków

Fluid: TemplateContext nie jest bezpieczny dla wątków, co wymaga ostrożnego zarządzania w aplikacjach działających w trybie współbieżnym.

Rozwiązanie: ChromePdfRenderer jest bezpieczne dla wątków i może być współdzielone między wątkami:

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

Problem 4: Dwustopniowa obsługa błędów

Płynność: Błędy mogą wystąpić na etapie tworzenia szablonów LUB generowania plików PDF.

Rozwiązanie:IronPDFma jedno źródło błędu:

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

Lista kontrolna płynnej migracji

Zadania przed migracją

Przeprowadź audyt kodu źródłowego, aby zidentyfikować wszystkie przypadki użycia 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

Należy udokumentówać wszystkie szablony: lokalizacje plików, użyte zmienne, pętle i warunki oraz konfigurację zewnętrznej biblioteki PDF.

Zadania związane z aktualizacją kodu

  1. Usuń pakiet Fluid.Core NuGet
  2. Usuń zewnętrzny pakiet biblioteki PDF
  3. Zainstaluj pakiet IronPdf NuGet
  4. Zaktualizuj importy przestrzeni nazw z Fluid na IronPdf
  5. Zamień {{ variable }} na $"{variable}"
  6. Przekonwertuj {% for item in collection %} na C# foreach
  7. Przekonwertuj instrukcje {% if condition %} na instrukcje C# if
  8. Przekształć filtry Liquid na metody C# (np. | upcase → .ToUpper())
  9. Zastąp FluidParser przez ChromePdfRenderer
  10. Zastąp TemplateContext.SetValue() bezpośredními proměnnými C#
  11. Usuń wywołania zewnętrznych bibliotek PDF
  12. Dodaj inicjalizację licencjiIronPDFpodczas uruchamiania

Testy po migracji

Po migracji należy zweryfikować następujące aspekty:

  • Sprawdź, czy wynik w formacie PDF jest zgodny z oczekiwaniami
  • Sprawdź, czy wszystkie warianty szablonów wyświetlają się poprawnie
  • Sprawdź, czy obrazy i stylizacja wyświetlają się poprawnie
  • Sprawdź, czy podziały stron występują poprawnie
  • Testowanie z różnymi rozmiarami danych
  • Testy wydajnościowe vs Fluid + biblioteka zewnętrzna
  • Sprawdź bezpieczeństwo wątków w scenariuszach współbieżności

Zadania porządkowe

  • Usuń pliki szablonów .liquid (jeśli nie są już potrzebne)
  • Usuń kod pomocniczy związany z Fluid
  • Aktualizacja dokumentacji
  • Usuń nieużywane zależności

Kluczowe korzyści z migracji do IronPDF

Przejście z Fluid (szablonowanie) z zewnętrznymi bibliotekami PDF naIronPDFzapewnia kilka kluczowych korzyści:

Rozwiązanie w jednym pakiecie: Wyeliminuj zależność od dwóch bibliotek.IronPDFobsługuje zarówno tworzenie szablonów (za pomocą HTML/CSS), jak i generowanie plików PDF w jednym pakiecie.

Nie trzeba uczyć się nowej składni: zamiast uczyć się składni szablonów Liquid, używaj standardowej interpolacji ciągów znaków i sterowania przepływem w języku C#.

Renderowanie bezpieczne dla wątków: ChromePdfRenderer jest bezpieczne dla wątków, w przeciwieństwie do TemplateContext, co upraszcza generowanie plików PDF w trybie współbieżnym.

Silnik renderujący Chromium: Renderowanie zgodne ze standardami branżowymi zapewnia pełną obsługę CSS3, w tym Flexbox i Grid, a także pełne wykonywanie kodu JavaScript.

Jedno źródło błędów: Debugowanie staje się prostsze, ponieważ wystarczy zająć się tylko jedną biblioteką, zamiast koordynować działania na etapie tworzenia szablonów i generowania plików PDF.

Aktywny rozwój: W miarę jak do 2026 r. wzrośnie popularność .NET 10 i C# 14, regularne aktualizacjeIronPDFzapewnią zgodność z obecnymi i przyszłymi wersjami .NET.

Curtis Chau
Curtis Chau
  Czat z zespołem inżynierów teraz
Autor tekstów technicznych

Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podrę...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie