PORóWNANIE

Fluid Templating a IronPDF: Przewodnik po porównaniu technicznym

Zaktualizowano:

Gdy programiści .NET muszą dynamicznie tworzyć dokumenty PDF, wybór technologii ma znaczący wpływ na wydajność pracy i jakość wyników.Fluid Templatingto popularny silnik oparty na Liquidzie, służący do generowania dynamicznej treści HTML. Jednak brak wbudowanej funkcji generowania plików PDF zwiększa złożoność zadania, gdy potrzebny jest plik PDF.IronPDFoferuje kompletne rozwiązanie, które obsługuje zarówno tworzenie szablonów (za pomocą HTML/CSS), jak i generowanie plików PDF dzięki wbudowanemu silnikowi renderowania Chromium.

W niniejszym porównaniu przeanalizowano oba podejścia pod kątem istotnych aspektów technicznych, aby pomóc profesjonalnym programistom i architektom w podejmowaniu świadomych decyzji dotyczących ich potrzeb w zakresie obsługi plików PDF w środowisku .NET.

Zrozumienie płynnego tworzenia szablonów

Fluid to biblioteka .NET, która implementuje język szablonów Liquid, używany głównie do generowania dynamicznych wyników tekstowych przy użyciu szablonów. Biblioteka pozwala programistom oddzielić logikę zawartości od prezentacji za pomocą składni Liquid z {{ }} dla zmiennej wyjściowej i {% %} dla instrukcji przepływu kontroli, takich jak pętle i warunki.

Fluid używa FluidParser do analizowania ciągów szablonów i TemplateContext do wiązania wartości danych. Metoda RenderAsync() produkuje wyjście HTML, które można zapisać do plików lub dalej przetwarzać. Jednak Płynny nie obsługuje bezpośrednio generowania plików PDF — programiści muszą zintegrować oddzielną bibliotekę PDF (taką jak wkhtmltopdf, PuppeteerSharp lub inne) w celu konwersji wyjścia HTML do formatu PDF.

Krytycznym czynnikiem jest to, że TemplateContext nie jest bezpieczny dla wątków, co wymaga ostrożnego zarządzania w aplikacjach równoległych, gdzie jednocześnie generowane są mnogie dokumenty PDF.

Zrozumienie IronPDF

IronPDF to biblioteka .NET do obsługi plików PDF, która zapewnia kompletne rozwiązanie do generowania plików PDF bezpośrednio z treści HTML. Biblioteka wykorzystuje nowoczesny silnik renderujący Chromium, umożliwiający programistom pisanie szablonów przy użyciu znanego HTML i CSS oraz konwertowanie ich bezpośrednio na profesjonalne dokumenty PDF.

IronPDF używa ChromePdfRenderer jako głównej klasy renderującej, przy czym RenderHtmlAsPdf() przyjmuje ciągi HTML i produkuje obiekty PdfDocument, które można zapisać, łączyć, zabezpieczać lub dalej manipulować. Renderer jest bezpieczny dla wątków, co upraszcza scenariusze równoczesnego generowania plików PDF.

Porównanie architektury i zależności

Podstawowa różnica między tymi podejściami polega na ich architekturze i liczbie wymagańych zależności.

Aspekt Płynny + 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

Szablony Płynny stwarzają wyzwanie związane z zależnością od dwóch bibliotek: potrzebujesz Płynny do tworzenia szablonów oraz oddzielnej biblioteki PDF do konwersji. Oznacza to zarządzanie dwoma zestawami konfiguracji, schematami obsługi błędów i cyklami aktualizacji.IronPDFłączy obie te funkcje w jednym pakiecie.

Porównanie kodu: typowe operacje na plikach PDF

Podstawowe generowanie plików PDF z HTML

Najbardziej podstawowa operacja pokazuje różnicę architektoniczną między tymi dwoma podejściami.

Fluid Templating:

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

        // Płynny 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);

        // Płynny 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)

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

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, parsowania ciągu szablonu, tworzenia TemplateContext, ustawienia wartości za pomocą SetValue(), wywołania RenderAsync(), a następnie zapisania wynikowego HTML do pliku. Komentarz w kodzie wyraźnie stwierdza: "Fluid generuje tylko HTML - potrzebujesz innej biblioteki, aby przekształcić do PDF."

IronPDF tworzy ChromePdfRenderer, przekazuje HTML bezpośrednio do RenderHtmlAsPdf(), i wywołuje SaveAs(), aby wygenerować plik PDF — kompletne rozwiązanie końcowe w trzech liniach.

Aby uzyskać informacje na temat zaawansowanych opcji renderowania HTML, zapoznaj się z przewodnikiem dotyczącym konwersji HTML do PDF.

Szablon faktury z danymi dynamicznymi

Generowanie dokumentów biznesowych, takich jak faktury, ilustruje różnice w powiązaniu danych.

Fluid Templating:

// 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);
        // Płynny 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);
        // Płynny 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)
        ' Płynny outputs HTML - requires additional PDF library
        File.WriteAllText("invoice.html", html)
    End Function
End Module
$vbLabelText   $csharpLabel

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 ({{invoiceNumber}}, {{date}}) z context.SetValue() dla każdej zmiennej.IronPDFużywa interpolacji ciągów C# ($"{invoiceNumber}", $"{date}"), którą programiści już znają — brak dodatkowej składni do nauki. W przykładzie Płynny wyraźnie zaznaczono, że do wykonania tego zadania "potrzebna jest dodatkowa biblioteka PDF".

Dynamiczne listy i kolekcje

Przeglądanie zbiorów danych pokazuje różnice w przebiegu kontroli.

Fluid Templating:

// 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);
        // Płynny 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);
        // Płynny 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

Module Program
    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)
        ' Płynny generates HTML only - separate PDF conversion needed
        File.WriteAllText("template-output.html", html)
    End Function
End Module
$vbLabelText   $csharpLabel

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 używa składni pętli Liquid ({% for item in items %}...{% endfor %}), podczas gdyIronPDFużywa standardowych pętli C# foreach. W przykładzie dotyczącym Płynny ponownie zaznaczono, że do zakończenia procesu "konieczna jest oddzielna konwersja do formatu PDF".

Dowiedz się więcej o renderowaniu HTML w samouczkach IronPDF.

Odnośnik do mapowania składni

Dla programistów oceniających migrację doFluid Templatinglub porównujących możliwości, poniższe zestawienie przedstawia równoważną składnię:

Zmienna treść

Fluid (Liquid) IronPDF (C#)
{{ variable }} $"{variable}"
{{ object.property }} $"{object.Property}"

Przebieg kontroli

Fluid (Liquid) IronPDF (C#)
{% for item in items %} foreach (var item in items)
{% endfor %} }
{% if condition %} if (condition)
{% endif %} }

Filtry do metod

Fluid (Liquid) IronPDF (C#)
{{ x \|upcase }} x.ToUpper()
{{ x \|downcase }} x.ToLower()
{{ x \|date: '%Y-%m-%d' }} x.ToString("yyyy-MM-dd")

Mapowanie klas podstawowych

Płynny IronPDF
FluidParser Nie dotyczy
TemplateContext Obiekty/ciągi znaków w języku C#
context.SetValue("key", value) var key = value;
template.RenderAsync(context) renderer.RenderHtmlAsPdf(html)
TemplateOptions RenderingOptions

Podsumowanie porównania funkcji

Funkcja Fluid Templating IronPDF
Generowanie plików PDF ❌(wymaga biblioteki zewnętrznej) ✅(wbudowane)
Wynik w formacie HTML ✅ ✅
Liquid Syntax ✅ Nie dotyczy (używa języka C#)
Interpolacja ciągów znaków w języku C# Nie dotyczy ✅
Kontekst bezpieczny dla wątków ❌ ✅
Rozwiązanie w jednym pakiecie ❌ ✅
CSS3 Flexbox/Grid Zależy od biblioteki PDF ✅
Obsługa JavaScript Zależy od biblioteki PDF ✅
Nagłówki/stopki Zależy od biblioteki PDF ✅(oparte na HTML)
Zabezpieczenia plików PDF Zależy od biblioteki PDF ✅
Łączenie plików PDF Zależy od biblioteki PDF ✅

Kiedy zespoły rozważają przejście zFluid Templatingna IronPDF

Zespoły programistów rozważają przejście z płynnego tworzenia szablonów naIronPDFz kilku powodów:

Złożoność dwóch bibliotek: Płynny generuje wyłącznie kod HTML — zespoły potrzebują oddzielnej biblioteki do tworzenia plików PDF (wkhtmltopdf, PuppeteerSharp itp.), aby tworzyć pliki PDF. Powoduje to podwojenie zależności, konfiguracji i potencjalnych źródeł błędów.IronPDFeliminuje ten problem, zapewniając zarówno tworzenie szablonów (za pomocą HTML/CSS), jak i generowanie plików PDF w jednym pakiecie.

Koszty integracji i debugowania: Koordynacja dwóch bibliotek oznacza zarządzanie dwoma zestawami konfiguracji, schematami obsługi błędów i cyklami aktualizacji. Błędy mogą wystąpić zarówno na etapie tworzenia szablonów, jak i generowania plików PDF, co utrudnia ich usuwanie.IronPDFzapewnia jedno źródło błędów, co ułatwia debugowanie.

Wymagania dotyczące bezpieczeństwa wątków: TemplateContext nie jest bezpieczny dla wątków, co wymaga ostrożnego zarządzania w aplikacjach równoległych. ChromePdfRenderer jest bezpieczny dla wątków, upraszczając scenariusze generowania PDF w wielu wątkach, powszechne w aplikacjach webowych.

Rozważania dotyczące krzywej uczenia się: Programiści muszą nauczyć się składni Liquid Template ({{ }}, {% %}), gdy C# już zapewnia potężne operacje na ciągach poprzez interpolację i StringBuilder.IronPDFwykorzystuje istniejącą wiedzę na temat HTML/CSS, którą posiada większość programistów.

Jakość plików PDF: Jakość i możliwości generowanych plików PDF zależą całkowicie od tego, z jaką zewnętrzną biblioteką PDF współpracuje Fluid. Wbudowany silnik Chromium wIronPDFzapewnia spójne, wysokiej jakości renderowanie z pełną obsługą CSS3, w tym układów Flexbox i Grid.

Mocne strony i kwestie do rozważenia

Zalety płynnego tworzenia szablonów

  • Rozdzielenie zagadnień: wyraźne rozdzielenie treści od logiki prezentacji
  • Kompatybilność z Liquid: standardowa składnia Liquid znana programistom z innych platform
  • Licencja MIT: oprogramowanie open source z liberalną licencją
  • Elastyczność: Możliwość łączenia z różnymi bibliotekami PDF

Uwagi dotyczące płynnego tworzenia szablonów

  • Nie jest to biblioteka PDF: stworzona specjalnie do tworzenia szablonów, nie posiada funkcji generowania plików PDF
  • Konieczność integracji: Wymaga połączenia z innymi rozwiązaniami do generowania plików PDF
  • Krzywa uczenia się: Wymaga opanowania składni Liquid wykraczającej poza standardowy C#
  • Bezpieczeństwo wątków: TemplateContext nie jest bezpieczny dla wątków w scenariuszach równoległych
  • Złożoność debugowania: Błędy mogą wystąpić zarówno na etapie tworzenia szablonów, jak i generowania plików PDF

Atuty IronPDF

  • Kompleksowe rozwiązanie: szablony HTML i generowanie plików PDF w jednym pakiecie
  • Chromium Rendering: standardowy w branży silnik renderujący zapewniający idealną jakość obrazu
  • Technologie internetowe: Pełna obsługa CSS3, Flexbox, Grid i JavaScript
  • Bezpieczeństwo wątków: ChromePdfRenderer jest bezpieczny dla wątków w operacjach równoległych
  • Jedno źródło błędów: Łatwiejsze debugowanie dzięki ujednoliconej obsłudze błędów
  • Funkcje Professional: nagłówki, stopki, znaki wodne, zabezpieczenia — wszystko wbudowane
  • Kompleksowe zasoby: obszerne samouczki i dokumentacja

Uwagi dotyczące IronPDF

  • Brak składni Liquid: zamiast tego używa się interpolacji ciągów znaków w języku C# (znanej programistom C#)
  • Licencja komercyjna: Wymagana jest licencja do użytku produkcyjnego

Wnioski

Fluid Templating iIronPDFsłużą różnym głównym celom w ekosystemie .NET. Płynny wyróżnia się jako silnik szablonów oparty na Liquidzie do generowania dynamicznej treści HTML, charakteryzujący się wyraźnym rozdzieleniem zagadnień i standardową składnią Liquid. Jednakże nie generuje on plików PDF — co wymaga od programistów zintegrowania i koordynacji oddzielnej biblioteki PDF.

IronPDF zapewnia kompleksowe rozwiązanie, które eliminuje problem zależności od dwóch bibliotek. Dzięki wykorzystaniu HTML/CSS do tworzenia szablonów oraz wbudowanemu silnikowi Chromium do renderowania plików PDF,IronPDFzmniejsza złożoność, usprawnia debugowanie i zapewnia bezpieczeństwo wątków od razu po uruchomieniu.

W miarę jak organizacje planują wdrożenie .NET 10, C# 14 oraz tworzenie aplikacji do 2026 r., wybór zależy od konkretnych wymagań. Zespoły, które cenią sobie zgodność ze składnią Liquid i dysponują już infrastrukturą do generowania plików PDF, mogą nadal korzystać z Fluid. Dla zespołów poszukujących usprawnionego generowania plików PDF bez konieczności koordynowania wielu bibliotek,IronPDFzapewnia bardziej zintegrowane podejście.

Zacznij testować IronPDF, korzystając z bezpłatnej wersji próbnej, i zapoznaj się z obszerną dokumentacją, aby ocenić, czy rozwiązanie to spełnia Twoje konkretne wymagania.