IronPDF umożliwia płynną konwersję HTML do PDF w ASP.NET Core przy użyciu silnika renderującego opartego na przeglądarce Chrome, który zachowuje formatowanie, CSS i JavaScript — niezbędne do generowania faktur, raportów i dokumentów do pobrania w nowoczesnych aplikacjach internetowych.
Konwersja dynamicznego kodu HTML do dokumentów PDF jest podstawowym wymogiem w nowoczesnych aplikacjach ASP.NET. Niezależnie od tego, czy generujesz faktury, tworzysz raporty, czy przygotowujesz pliki do pobrania, przekształcanie treści HTML w profesjonalne pliki PDF jest niezbędne do zapewnienia doskonałych wrażeń użytkownika.
IronPDF upraszcza ten proces konwersji, zapewniając solidny silnik renderujący oparty na przeglądarce Chrome, który doskonale zachowuje formatowanie HTML, stylizację CSS i funkcjonalność JavaScript w wynikowych dokumentach. Ten samouczek przedstawia skuteczne metody konwersji HTML do PDF w aplikacjach ASP.NET Core przy użyciu biblioteki IronPDF.
Aplikacje .NET Core często generują dynamiczną zawartość HTML, którą użytkownicy muszą pobrać, udostępnić lub zarchiwizować w formacie PDF. Konwersja HTML do PDF zapewnia kilka kluczowych korzyści w porównaniu z prostym zapisywaniem stron internetowych lub robieniem zrzutów ekranu.
Pliki PDF zachowują spójne formatowanie na wszystkich urządzeniach i platformach, dzięki czemu faktury wyglądają identycznie niezależnie od tego, czy są wyświetlane w systemie Windows, na komputerach Mac czy na urządzeniach mobilnych. Są one idealne do dokumentów wymagających podpisów cyfrowych, ustawień zabezpieczeń lub profesjonalnego drukowania. Konwersja po stronie serwera eliminuje konieczność instalowania przez użytkowników specjalnego oprogramowania i zapewnia lepszą kontrolę nad końcowym wynikiem.
Typowe zastosowania obejmują generowanie raportów finansowych na podstawie danych z pulpitu nawigacyjnego, tworzenie faktur do pobrania na podstawie informacji o zamówieniach, generowanie biletów i karnetów z kodami QR oraz przekształcanie przesłanych formularzy w trwałe zapisy. Dzięki obsłudze konwersji na serwerze zapewniasz spójne wyniki niezależnie od przeglądarki użytkownika lub możliwości urządzenia. Format archiwizacji PDF/A zapewnia długoterminową ochronę dokumentów, a kompresja PDF zmniejsza rozmiar plików, umożliwiając ich wydajne przechowywanie i przesyłanie.
Dla DevOps inżynierów, to podejście serwerowe integruje się płynnie z wdrożeniami konteneryzowanymi i pipeline'ami CI/CD, zapewniając niezawodne generowanie PDF w różnych środowiskach. Funkcje optymalizacji wydajności umożliwiają efektywne wykorzystanie zasobów w środowiskach produkcyjnych. Przewodniki wdrażania platformy Azure oraz integracja z AWS Lambda zapewniają strategie optymalizacji dostosowane do konkretnych platform.
Rozpoczęcie pracy z IronPDF w projekcie ASP.NET Core jest bardzo proste. Biblioteka obsługuje .NET Core 2.0 i nowsze wersje, a także .NET 5, 6, 7 i 8, dzięki czemu jest kompatybilna ze wszystkimi nowoczesnymi aplikacjami ASP.NET Core. W przypadku środowisk kontenerowych IronPDF zapewnia oficjalną obsługę Docker. Przegląd instalacji obejmuje wszystkie scenariusze wdrożenia.
Najszybszym sposobem na dodanie IronPDF do projektu jest skorzystanie z menedżera pakietów NuGet w Visual Studio. Kliknij prawym przyciskiem myszy swój projekt w Eksploratorze rozwiązań, wybierz "Zarządzaj pakietami NuGet" i wyszukaj IronPDF. Kliknij "Zainstaluj" przy najnowszej wersji, aby dodać ją do swojego projektu. Szczegółowe instrukcje instalacji można znaleźć w przewodniku instalacji IronPDF. Alternatywne metody obejmują użycie instalatora Windows lub zaawansowanej konfiguracji NuGet.
W przypadku wdrożeń kontenerowych należy użyć pakietu IronPdf.Slim, który zmniejsza początkowy rozmiar wdrożenia:
Takie podejście jest korzystne w przypadku wdrożeń AWS Lambda lub Azure Functions, gdzie ograniczenia dotyczące rozmiaru pakietów mają kluczowe znaczenie. Porównanie silników natywnych i zdalnych pomaga wybrać optymalną strategię wdrożenia.
Po zainstalowaniu dodaj przestrzeń nazw IronPDF do dowolnego pliku C#, w którym będziesz pracować nad generowaniem plików PDF:
using IronPdf;Imports IronPdfTen import daje dostęp do całej funkcjonalności IronPDF, w tym klasy ChromePdfRenderer do konwersji HTML oraz różnych opcji konfiguracji do dostosowania wyniku. Dokumentacja API zawiera wyczerpujące informacje na temat wszystkich dostępnych klas i metod.
W przypadku większości aplikacji ASP.NET Core IronPDF działa natychmiast po instalacji bez dodatkowej konfiguracji. Jednakże, można ustawić globalne opcje w pliku Program.cs lub Startup.cs:
// Optional: Configure IronPDF settings
Installation.TempFolderPath = @"C:\Temp\IronPdf\";
Installation.LinuxAndDockerDependenciesAutoConfig = true;
// Configure license key for production
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";' Optional: Configure IronPDF settings
Installation.TempFolderPath = "C:\Temp\IronPdf\"
Installation.LinuxAndDockerDependenciesAutoConfig = True
' Configure license key for production
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"Te opcje konfiguracyjne pomagają zoptymalizować IronPDF pod kątem konkretnego środowiska hostingowego, niezależnie od tego, czy działa ono w systemie Windows, Linux, czy w kontenerach Docker. Upewnij się, że pliki skryptów i aplikacji nie znajdują się w tym samym katalogu, aby zapobiec konfliktom. Przewodnik po kluczach licencyjnych wyjaśnia prawidłową konfigurację licencji, a sekcja dotycząca rozwiązywania problemów z wdrażaniem pomaga rozwiązać typowe problemy.
W przypadku wdrożeń produkcyjnych warto rozważyć dodanie punktów końcowych sprawdzania stanu w celu monitorowania usług generowania plików PDF:
// Add health checks for monitoring
services.AddHealthChecks()
.AddCheck("pdf-service", () =>
{
try
{
var renderer = new ChromePdfRenderer();
var test = renderer.RenderHtmlAsPdf("<p>Health Check</p>");
return HealthCheckResult.Healthy();
}
catch (Exception ex)
{
return HealthCheckResult.Unhealthy(ex.Message);
}
});' Add health checks for monitoring
services.AddHealthChecks() _
.AddCheck("pdf-service", Function()
Try
Dim renderer = New ChromePdfRenderer()
Dim test = renderer.RenderHtmlAsPdf("<p>Health Check</p>")
Return HealthCheckResult.Healthy()
Catch ex As Exception
Return HealthCheckResult.Unhealthy(ex.Message)
End Try
End Function)W przypadku wdrożeń Kubernetes należy wdrożyć sondy gotowości i aktywności, aby zapewnić dostępność usług. Przewodnik dotyczący wydajności zawiera dodatkowe strategie optymalizacji.
Uruchom program Visual Studio i wybierz typ projektu ASP.NET, który najlepiej odpowiada Twoim potrzebom. W dzisiejszym przykładzie utworzę aplikację internetową ASP.NET Core (Model-View-Controller).
Następnie wprowadź nazwę projektu i wybierz lokalizację, w której ma on zostać umieszczony.
Na koniec wybierz platformę .NET Framework dla projektu i zmień wszelkie dodatkowe ustawienia projektu, takie jak typ uwierzytelniania lub włączenie obsługi kontenerów i Docker.
Aby utworzyć nowy kontroler, w którym umieścimy nasz kod HTML do PDF, najpierw kliknij prawym przyciskiem myszy folder "Controllers" w eksploratorze rozwiązań i wybierz "Dodaj -> Kontroler".
Spowoduje to otwarcie nowego okna, w którym można wybrać typ kontrolera, który chcesz dodać do projektu. Wybraliśmy pusty kontroler MVC.
Na koniec nadajemy nowemu kontrolerowi nazwę i klikamy "Dodaj", aby dodać go do naszego projektu.
Najbardziej podstawową operacją w IronPDF jest konwersja ciągów znaków HTML bezpośrednio do dokumentów PDF. To podejście sprawdza się idealnie podczas dynamicznego tworzenia treści HTML w aplikacji ASP.NET lub pracy z szablonami. Kompleksowy samouczek obejmuje zaawansowane scenariusze.
// Create a PDF converter instance
var renderer = new ChromePdfRenderer();
// Convert HTML string to PDF document
var pdf = renderer.RenderHtmlAsPdf("<h1>Sales Report</h1><p>Generated on: " + DateTime.Now + "</p>");
// Save the resultant PDF document to a file
pdf.SaveAs("report.pdf");' Create a PDF converter instance
Dim renderer = New ChromePdfRenderer()
' Convert HTML string to PDF document
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Sales Report</h1><p>Generated on: " & DateTime.Now & "</p>")
' Save the resultant PDF document to a file
pdf.SaveAs("report.pdf")Ten kod tworzy nową instancję ChromePdfRenderer, która wykorzystuje silnik Chromium do renderowania zawartości HTML. Metoda RenderHtmlAsPdf akceptuje dowolny prawidłowy ciąg HTML i zwraca obiekt PdfDocument. Następnie można zapisać ten dokument na dysku lub przesłać go bezpośrednio do użytkowników jako tablicę bajtów. Dowiedz się więcej o klasie ChromePdfRenderer i jej możliwościach. Przewodnik po tworzeniu plików PDF zawiera dodatkowe metody tworzenia.
W środowiskach produkcyjnych o wysokiej współbieżności należy wdrożyć odpowiednie zarządzanie zasobami:
// Implement using statement for proper disposal
using (var renderer = new ChromePdfRenderer())
{
// Configure for optimal performance
renderer.RenderingOptions.CreatePdfFormsFromHtml = false;
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
// Use memory stream for better resource management
using (var ms = new MemoryStream())
{
pdf.SaveAs(ms);
return ms.ToArray();
}
}' Implement using statement for proper disposal
Using renderer As New ChromePdfRenderer()
' Configure for optimal performance
renderer.RenderingOptions.CreatePdfFormsFromHtml = False
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
renderer.RenderingOptions.PrintHtmlBackgrounds = True
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
' Use memory stream for better resource management
Using ms As New MemoryStream()
pdf.SaveAs(ms)
Return ms.ToArray()
End Using
End UsingPrzewodnik dotyczący strumienia pamięci wyjaśnia, jak efektywnie obsługiwać pliki PDF w pamięci. W przypadku operacji asynchronicznych należy stosować metody renderowania asynchronicznego w celu poprawy przepustowości.
IronPDF w pełni obsługuje stylizację CSS i umożliwia osadzanie obrazów z różnych źródeł. Konwerter obsługuje wszystkie elementy z pełną wiernością, w tym różne tagi i adresy URL obrazów. Obsługa grafiki SVG zapewnia idealne renderowanie obrazów wektorowych.
var html = @"
<style>
body { font-family: Arial, sans-serif; margin: 40px; }
h1 { color: #2c3e50; border-bottom: 2px solid #3498db; }
.highlight { background-color: #f1c40f; padding: 5px; }
</style>
<h1>Monthly Report</h1>
<p>This HTML document includes <span class='highlight'>highlighted text</span> and styling.</p>
<img src='data:image/png;base64,iVBORw0KGgoAAAANS...' alt='Logo' />";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);Dim html As String = "
<style>
body { font-family: Arial, sans-serif; margin: 40px; }
h1 { color: #2c3e50; border-bottom: 2px solid #3498db; }
.highlight { background-color: #f1c40f; padding: 5px; }
</style>
<h1>Monthly Report</h1>
<p>This HTML document includes <span class='highlight'>highlighted text</span> and styling.</p>
<img src='data:image/png;base64,iVBORw0KGgoAAAANS...' alt='Logo' />"
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)Renderer przetwarza style wbudowane, pliki CSS, a nawet obrazy zakodowane w base64. Dzięki temu strony zachowają dokładnie taki sam wygląd treści HTML, w tym nowoczesne funkcje CSS3, takie jak układy flexbox i grid. Konwersja zachowuje wszystkie tagi i stylizację bez generowania pustych stron. W pełni obsługiwane są czcionki internetowe i czcionki ikon, w tym Google Fonts.
W przypadku środowisk kontenerowych należy zapewnić dostępność lub osadzenie zasobów zewnętrznych:
// Configure base URL for resource loading
renderer.RenderingOptions.BaseUrl = new Uri("___PROTECTED_URL_105___");
// Or embed resources using data URIs for self-contained PDFs
var htmlWithEmbeddedResources = @"
<style>
@font-face {
font-family: 'CustomFont';
src: url(data:font/woff2;base64,...) format('woff2');
}
</style>";' Configure base URL for resource loading
renderer.RenderingOptions.BaseUrl = New Uri("___PROTECTED_URL_105___")
' Or embed resources using data URIs for self-contained PDFs
Dim htmlWithEmbeddedResources As String = "
<style>
@font-face {
font-family: 'CustomFont';
src: url(data:font/woff2;base64,...) format('woff2');
}
</style>"Przewodnik po adresach URL bazowych wyjaśnia właściwe strategie odwoływania się do zasobów. Aby zapewnić obsługę języków międzynarodowych, należy zastosować odpowiednie kodowanie UTF-8.
Konwersja całych widoków ASP.NET Core do formatu PDF jest powszechną praktyką, zwłaszcza w przypadku generowania raportów na podstawie istniejących szablonów. IronPDF oferuje kilka rozwiązań dla tego scenariusza, niezależnie od tego, czy pracujesz z jedną, czy z wieloma stronami. Samouczki dotyczące konwersji CSHTML do PDF obejmują implementacje specyficzne dla poszczególnych frameworków.
W kontrolerze ASP.NET Core wyrenderuj widok do formatu HTML, a następnie przekonwertuj go do formatu PDF, korzystając z zaawansowanych możliwości renderowania IronPDF:
[HttpGet]
public async Task<IActionResult> DownloadPdf()
{
var invoiceModel = new InvoiceModel
{
InvoiceNumber = 12345,
Date = DateTime.Now,
CustomerName = "Acme Corporation",
Items = new List<InvoiceItem>
{
new InvoiceItem { Description = "Service", Quantity = 1, Price = 100.0 }
},
Total = 100.0
};
// Render the view to HTML string
var htmlContent = await RenderViewToString("Invoice", invoiceModel);
// Convert HTML to PDF
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
// Return PDF to browser
var contentType = "application/pdf";
var fileName = $"invoice_{DateTime.Now:yyyyMMdd}.pdf";
return File(pdf.BinaryData, contentType, fileName);
}
private async Task<string> RenderViewToString(string viewName, object model)
{
ViewData.Model = model;
using (var writer = new StringWriter())
{
var viewResult = viewEngine.FindView(ControllerContext, viewName, false);
var viewContext = new ViewContext(
ControllerContext,
viewResult.View,
ViewData,
TempData,
writer,
new HtmlHelperOptions()
);
await viewResult.View.RenderAsync(viewContext);
return writer.GetStringBuilder().ToString();
}
}Imports System
Imports System.Collections.Generic
Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc
<HttpGet>
Public Async Function DownloadPdf() As Task(Of IActionResult)
Dim invoiceModel = New InvoiceModel With {
.InvoiceNumber = 12345,
.Date = DateTime.Now,
.CustomerName = "Acme Corporation",
.Items = New List(Of InvoiceItem) From {
New InvoiceItem With {.Description = "Service", .Quantity = 1, .Price = 100.0}
},
.Total = 100.0
}
' Render the view to HTML string
Dim htmlContent = Await RenderViewToString("Invoice", invoiceModel)
' Convert HTML to PDF
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
' Return PDF to browser
Dim contentType = "application/pdf"
Dim fileName = $"invoice_{DateTime.Now:yyyyMMdd}.pdf"
Return File(pdf.BinaryData, contentType, fileName)
End Function
Private Async Function RenderViewToString(viewName As String, model As Object) As Task(Of String)
ViewData.Model = model
Using writer = New StringWriter()
Dim viewResult = viewEngine.FindView(ControllerContext, viewName, False)
Dim viewContext = New ViewContext(
ControllerContext,
viewResult.View,
ViewData,
TempData,
writer,
New HtmlHelperOptions()
)
Await viewResult.View.RenderAsync(viewContext)
Return writer.GetStringBuilder().ToString()
End Using
End FunctionTo podejście najpierw renderuje widok Razor do ciągu znaków HTML, a następnie konwertuje go do formatu PDF. Plik PDF jest zwracany jako plik do pobrania w przeglądarce użytkownika z odpowiednią nazwą. Działa to płynnie zarówno z plikami ASPX, jak i nowoczesnymi widokami Razor. W przypadku Razor Pages należy używać dedykowanych metod renderowania. Przewodnik po frameworku MVC obejmuje starsze wersje ASP.NET.
W przypadku wdrożeń produkcyjnych należy wdrożyć buforowanie w celu zmniejszenia obciążenia serwera:
private readonly IMemoryCache _cache;
[HttpGet]
public async Task<IActionResult> DownloadCachedPdf(int invoiceId)
{
var cacheKey = $"invoice_pdf_{invoiceId}";
if (!_cache.TryGetValue(cacheKey, out byte[] pdfBytes))
{
// Generate PDF if not cached
var htmlContent = await RenderViewToString("Invoice", model);
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdfBytes = pdf.BinaryData;
// Cache for 1 hour
_cache.Set(cacheKey, pdfBytes, TimeSpan.FromHours(1));
}
return File(pdfBytes, "application/pdf", $"invoice_{invoiceId}.pdf");
}Private ReadOnly _cache As IMemoryCache
<HttpGet>
Public Async Function DownloadCachedPdf(invoiceId As Integer) As Task(Of IActionResult)
Dim cacheKey = $"invoice_pdf_{invoiceId}"
Dim pdfBytes As Byte() = Nothing
If Not _cache.TryGetValue(cacheKey, pdfBytes) Then
' Generate PDF if not cached
Dim htmlContent = Await RenderViewToString("Invoice", model)
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdfBytes = pdf.BinaryData
' Cache for 1 hour
_cache.Set(cacheKey, pdfBytes, TimeSpan.FromHours(1))
End If
Return File(pdfBytes, "application/pdf", $"invoice_{invoiceId}.pdf")
End FunctionPrzewodnik po renderowaniu bezinterfejsowym pokazuje, jak generować pliki PDF bez kontekstu GUI, co idealnie nadaje się do usług działających w tle.
W przypadku istniejących stron internetowych użyj IronPDF, aby przekształcić dowolny adres URL bezpośrednio w plik PDF. Wystarczy podać adres HTTP lub HTTPS:
[HttpGet]
public IActionResult GeneratePdfFromUrl()
{
var renderer = new ChromePdfRenderer();
// Convert a specified URL to PDF document
var pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_106___");
// Stream the PDF file to the browser
return File(pdf.BinaryData, "application/pdf", "invoice.pdf");
}<HttpGet>
Public Function GeneratePdfFromUrl() As IActionResult
Dim renderer = New ChromePdfRenderer()
' Convert a specified URL to PDF document
Dim pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_106___")
' Stream the PDF file to the browser
Return File(pdf.BinaryData, "application/pdf", "invoice.pdf")
End FunctionTa metoda sprawdza się dobrze, gdy dysponujesz już dobrze sformatowanymi stronami internetowymi i chcesz udostępnić je do pobrania w formacie PDF. Biblioteka obsługuje wszystkie zasoby zewnętrzne, w tym arkusze stylów, skrypty i obrazy, zapewniając pełne renderowanie. Konwerter zwraca odpowiedni kod statusu HTTP, jeśli napotka nieprawidłowy adres URL. W przypadku stron zawierających dużo kodu JavaScript należy skonfigurować odpowiednie opóźnienia renderowania.
W przypadku środowisk kontenerowych należy odpowiednio skonfigurować ustawienia sieciowe:
// Configure for Docker/Kubernetes environments
renderer.RenderingOptions.Timeout = 60000; // 60 second timeout
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor = new WaitFor()
{
RenderDelay = 500, // Wait 500ms after page load
NetworkIdle = IronPdf.Engines.Chrome.NetworkIdle.NetworkIdle2
};' Configure for Docker/Kubernetes environments
renderer.RenderingOptions.Timeout = 60000 ' 60 second timeout
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor = New WaitFor() With {
.RenderDelay = 500, ' Wait 500ms after page load
.NetworkIdle = IronPdf.Engines.Chrome.NetworkIdle.NetworkIdle2
}Przewodnik po opcjach renderowania zawiera wyczerpujące informacje dotyczące konfiguracji. W przypadku treści WebGL należy włączyć przyspieszenie GPU.
Podczas konwersji stron wymagających uwierzytelnienia za pomocą uwierzytelniania formularzy .NET lub innych mechanizmów bezpieczeństwa należy przekazać pliki cookie lub nagłówki, aby zachować sesję użytkownika. Zapobiega to przekierowaniu do ekranów logowania podczas konwersji:
var renderer = new ChromePdfRenderer();
// Set cookies for authenticated requests with user database credentials
renderer.RenderingOptions.CustomCookies.Add("auth_token", Request.Cookies["auth_token"]);
// Convert protected web pages to PDF
var pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_107___");Dim renderer As New ChromePdfRenderer()
' Set cookies for authenticated requests with user database credentials
renderer.RenderingOptions.CustomCookies.Add("auth_token", Request.Cookies("auth_token"))
' Convert protected web pages to PDF
Dim pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_107___")Dzięki temu chronione treści mogą być konwertowane do formatu PDF przy zachowaniu bezpieczeństwa. Proces konwersji uwzględnia uwierzytelnianie podstawowe i uwierzytelnianie formularzy w aplikacji, zapobiegając nieautoryzowanemu dostępowi do poufnych dokumentów. W razie potrzeby można również przekazać argumenty nazwy użytkownika i hasła w scenariuszach uwierzytelniania podstawowego. Przewodnik po zarządzaniu plikami cookie wyjaśnia zaawansowane sposoby obsługi plików cookie. W przypadku uwierzytelniania Kerberos należy skonfigurować odpowiednie poświadczenia.
W przypadku architektur mikrousług należy rozważyć uwierzytelnianie między usługami:
// Add service authentication headers
renderer.RenderingOptions.ExtraHttpHeaders.Add("X-Service-Token", GetServiceToken());
renderer.RenderingOptions.ExtraHttpHeaders.Add("X-Request-ID", Activity.Current?.Id);
// Configure for internal service mesh
renderer.RenderingOptions.BaseUrl = new Uri("___PROTECTED_URL_108___");' Add service authentication headers
renderer.RenderingOptions.ExtraHttpHeaders.Add("X-Service-Token", GetServiceToken())
renderer.RenderingOptions.ExtraHttpHeaders.Add("X-Request-ID", Activity.Current?.Id)
' Configure for internal service mesh
renderer.RenderingOptions.BaseUrl = New Uri("___PROTECTED_URL_108___")Przetwarzanie danych z formularzy przed wygenerowaniem pliku PDF jest powszechną praktyką w aplikacjach ASP.NET — potwierdzenia zamówień, listy przewozowe i pokwitowania są tworzone zgodnie z tym modelem. Podejście polega na powiązaniu przesłanych danych formularza z modelem, zbudowaniu ciągu HTML na podstawie tego modelu, a następnie renderowaniu tego ciągu jako pliku PDF:
[HttpPost]
public IActionResult ProcessFormToPdf(OrderModel model)
{
var renderer = new ChromePdfRenderer();
string html = $@"
<h2>Order Confirmation</h2>
<p>Customer: {model.CustomerName}</p>
<p>Order Date: {model.OrderDate:yyyy-MM-dd}</p>
<ul>
{string.Join("", model.Items.Select(i => $"<li>{i.Name} -- ${i.Price}</li>"))}
</ul>
<p><strong>Total: ${model.Total}</strong></p>";
var pdf = renderer.RenderHtmlAsPdf(html);
string fileName = $"order-{model.OrderId}.pdf";
return File(pdf.BinaryData, "application/pdf", fileName);
}Imports System
Imports System.Linq
Imports Microsoft.AspNetCore.Mvc
<HttpPost>
Public Function ProcessFormToPdf(model As OrderModel) As IActionResult
Dim renderer = New ChromePdfRenderer()
Dim html As String = $"
<h2>Order Confirmation</h2>
<p>Customer: {model.CustomerName}</p>
<p>Order Date: {model.OrderDate:yyyy-MM-dd}</p>
<ul>
{String.Join("", model.Items.Select(Function(i) $"<li>{i.Name} -- ${i.Price}</li>"))}
</ul>
<p><strong>Total: ${model.Total}</strong></p>"
Dim pdf = renderer.RenderHtmlAsPdf(html)
Dim fileName As String = $"order-{model.OrderId}.pdf"
Return File(pdf.BinaryData, "application/pdf", fileName)
End Function
W przypadku bardziej zaawansowanych scenariuszy dokumentów można zintegrować formularze PDF lub edytować istniejące szablony PDF z wstępnie wypełnionymi polami. Biblioteka obsługuje również podpisy cyfrowe dla dokumentów prawnych i umów, umożliwiając dodawanie podpisów weryfikowalnych kryptograficznie do każdego wygenerowanego dokumentu.
Ważną kwestią przy osadzaniu danych użytkownika w ciągach HTML jest ich oczyszczanie. Zawsze należy stosować escape w ciągach znaków dostarczonych przez użytkownika przed wstawieniem ich do kodu HTML, aby zapobiec problemom związanym z wstrzyknięciem kodu. Proste wywolanie System.Web.HttpUtility.HtmlEncode(model.CustomerName) na kazdym polu zachowuje bezpieczenstwo szablonu przed przekazaniem go do renderer'a.
IronPDF oferuje szerokie możliwości dostosowywania, pozwalające kontrolować sposób generowania dokumentów z kodu HTML. Te ustawienia pomogą Ci stworzyć profesjonalne pliki PDF, które spełniają konkretne wymagania dotyczące układu strony i formatowania. Przykłady ustawień renderowania pokazują praktyczne zastosowania.
var renderer = new ChromePdfRenderer();
// Set default page size for PDF pages
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
// Control page width and margins for the resultant PDF document
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;
renderer.RenderingOptions.MarginLeft = 20;
renderer.RenderingOptions.MarginRight = 20;Dim renderer As New ChromePdfRenderer()
' Set default page size for PDF pages
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait
' Control page width and margins for the resultant PDF document
renderer.RenderingOptions.MarginTop = 25
renderer.RenderingOptions.MarginBottom = 25
renderer.RenderingOptions.MarginLeft = 20
renderer.RenderingOptions.MarginRight = 20Te ustawienia kontrolują fizyczny układ stron. Możesz wybierać spośród standardowych rozmiarów papieru lub zdefiniować własne wymiary, ustawić orientację pionową lub poziomą oraz dostosować marginesy zgodnie z wymaganiami projektowymi. System szablonów graficznych zapewnia spójny styl na wszystkich stronach. W przypadku podziałów stron należy używać właściwości CSS do kontrolowania przepływu treści.
W kwestii responsywnego projektowania:
// Configure viewport for mobile-friendly PDFs
renderer.RenderingOptions.ViewportWidth = 1024;
renderer.RenderingOptions.ViewportHeight = 768;
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
renderer.RenderingOptions.FitToPaperMode = FitToPaperModes.Zoom;
renderer.RenderingOptions.Zoom = 100;' Configure viewport for mobile-friendly PDFs
renderer.RenderingOptions.ViewportWidth = 1024
renderer.RenderingOptions.ViewportHeight = 768
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
renderer.RenderingOptions.FitToPaperMode = FitToPaperModes.Zoom
renderer.RenderingOptions.Zoom = 100W przewodniku po konfiguracji okna wyświetlania wyjaśniono optymalne ustawienia dla różnych typów treści. Aby uzyskać wydruk w skali szarości, włącz odpowiednią opcję renderowania.
Dodanie spójnych nagłówków i stopek poprawia profesjonalny wygląd dokumentów:
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
HtmlFragment = "<div style='text-align: center'>Company Report</div>",
MaxHeight = 20
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
HtmlFragment = "<div style='text-align: center'>Page {page} of {total-pages}</div>",
MaxHeight = 20
};Imports System
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
.HtmlFragment = "<div style='text-align: center'>Company Report</div>",
.MaxHeight = 20
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
.HtmlFragment = "<div style='text-align: center'>Page {page} of {total-pages}</div>",
.MaxHeight = 20
}Nagłówki i stopki obsługują formatowanie HTML ze specjalnymi symbolami zastępczymi dla numerów stron, dat i innych treści dynamicznych na wszystkich stronach. Poniższy kod pokazuje, jak dodać profesjonalne nagłówki do wygenerowanych dokumentów. Przewodnik po nagłówkach HTML przedstawia zaawansowane opcje formatowania. W przypadku nagłówków zawierających wyłącznie tekst należy używać prostszych metod API.
W przypadku zaawansowanych konfiguracji nagłówków/stopek z treścią dynamiczną:
// Create dynamic headers with metadata
var headerHtml = $@"
<div style='display: flex; justify-content: space-between; font-size: 10px;'>
<span>Generated: {DateTime.UtcNow:yyyy-MM-dd HH:mm} UTC</span>
<span>Environment: {Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}</span>
</div>";
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
HtmlFragment = headerHtml,
MaxHeight = 30,
DrawDividerLine = true
};' Create dynamic headers with metadata
Dim headerHtml = $"
<div style='display: flex; justify-content: space-between; font-size: 10px;'>
<span>Generated: {DateTime.UtcNow:yyyy-MM-dd HH:mm} UTC</span>
<span>Environment: {Environment.GetEnvironmentVariable(""ASPNETCORE_ENVIRONMENT"")}</span>
</div>"
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
.HtmlFragment = headerHtml,
.MaxHeight = 30,
.DrawDividerLine = True
}Nagłówki na konkretnych stronach przewodnika pokazują warunkowe stosowanie nagłówków/stopek.
Profesjonalne dokumenty PDF często wymagają nagłówków i stopek na każdej stronie, a także znaków wodnych w przypadku dokumentów roboczych lub poufnych. IronPDF obsluguje oba przypadki za posrednictwem wlasciwosci obiektu RenderingOptions oraz metody ApplyWatermark na wynikowym PdfDocument:
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
MaxHeight = 25,
HtmlFragment = "<div style='text-align:center'>Annual Report 2024</div>"
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
MaxHeight = 20,
HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages}</div>"
};
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.ApplyWatermark("<h2 style='color:red;opacity:0.3'>CONFIDENTIAL</h2>",
30, VerticalAlignment.Middle, HorizontalAlignment.Center);
pdf.SaveAs("report-with-watermark.pdf");Imports IronPdf
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
.MaxHeight = 25,
.HtmlFragment = "<div style='text-align:center'>Annual Report 2024</div>"
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
.MaxHeight = 20,
.HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages}</div>"
}
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.ApplyWatermark("<h2 style='color:red;opacity:0.3'>CONFIDENTIAL</h2>", 30, VerticalAlignment.Middle, HorizontalAlignment.Center)
pdf.SaveAs("report-with-watermark.pdf")
Zastepcze miejsca {page} i {total-pages} w stopce HTML sa automatycznie zastapiane podczas renderowania, wiec otrzymujesz poprawne numery stron bez zadnej dalszej obrobki. Można również dodać numery stron, obrazy tła lub nakładki na pierwszym planie oraz niestandardowe tekstowe lub graficzne stemple.
Aby upewnic sie, ze twoj PDF odpowiada oczekiwaniom, uzyj reguly CSS @media print oraz ustawienia PdfCssMediaType.Print. IronPDF w pełni obsługuje kontrolę podziału stron i niestandardowe rozmiary papieru:
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
renderer.RenderingOptions.ViewPortWidth = 1024;
renderer.RenderingOptions.MarginTop = 10;
renderer.RenderingOptions.MarginBottom = 10;
renderer.RenderingOptions.MarginLeft = 10;
renderer.RenderingOptions.MarginRight = 10;
string html = @"
<style>
@media print {
.no-print { display: none; }
body { font-size: 12pt; }
.page-break { page-break-after: always; }
}
@page {
size: A4;
margin: 1cm;
}
</style>
<div class='content'>
<h1>Professional Report</h1>
<div class='page-break'></div>
<h2>Section 2</h2>
</div>";
var pdf = renderer.RenderHtmlAsPdf(html);Imports IronPdf
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
renderer.RenderingOptions.ViewPortWidth = 1024
renderer.RenderingOptions.MarginTop = 10
renderer.RenderingOptions.MarginBottom = 10
renderer.RenderingOptions.MarginLeft = 10
renderer.RenderingOptions.MarginRight = 10
Dim html As String = "
<style>
@media print {
.no-print { display: none; }
body { font-size: 12pt; }
.page-break { page-break-after: always; }
}
@page {
size: A4;
margin: 1cm;
}
</style>
<div class='content'>
<h1>Professional Report</h1>
<div class='page-break'></div>
<h2>Section 2</h2>
</div>"
Dim pdf = renderer.RenderHtmlAsPdf(html)
Zastosowanie CSS do drukowania gwarantuje, że dokumenty PDF zachowają profesjonalne formatowanie, jednocześnie ukrywając zbędne elementy stron internetowych, takie jak menu nawigacyjne czy interaktywne przyciski. Ustawienie CssMediaType = PdfCssMediaType.Print instruuje renderer do zastosowania twoich reguł @media print zamiast ekranowych stylow, co zazwyczaj usuwa dekoracje tla i dostosowuje typografie dla wydruku. Można również skonfigurować niestandardowe marginesy dla każdej strony oraz kontrolować orientację i obrót strony w przypadku raportów w formacie szerokim lub obróconych.
Specyfikacja W3C CSS Paged Media definiuje jak wlasciwosci takie jak @page, page-break-before i widows powinny zachowywac sie w wyjsciu stronowym. Silnik IronPDF dla przeglądarki Chrome ściśle przestrzega tej specyfikacji, dzięki czemu style napisane zgodnie ze standardem CSS są dokładnie przekładane do pliku PDF bez konieczności ręcznych poprawek.
W przypadku konwersji starszych stron ASPX lub dokumentów, które wykorzystują JavaScript do wypełniania treści w czasie wykonywania, IronPDF niezawodnie obsługuje proces renderowania. Można skonfigurować opóźnienie renderowania, aby umożliwić zakończenie wykonywania kodu JavaScript przed przechwyceniem strony:
public IActionResult ConvertDynamicContent()
{
var renderer = new ChromePdfRenderer();
// Enable JavaScript so dynamic content renders correctly
renderer.RenderingOptions.EnableJavaScript = true;
// Wait 1 second after page load for JavaScript to complete
renderer.RenderingOptions.WaitFor.RenderDelay(1000);
// Generate your dynamic HTML string
string dynamicHtml = GenerateDynamicHtml();
var pdf = renderer.RenderHtmlAsPdf(dynamicHtml);
return File(pdf.BinaryData, "application/pdf", "dynamic.pdf");
}Imports IronPdf
Public Function ConvertDynamicContent() As IActionResult
Dim renderer As New ChromePdfRenderer()
' Enable JavaScript so dynamic content renders correctly
renderer.RenderingOptions.EnableJavaScript = True
' Wait 1 second after page load for JavaScript to complete
renderer.RenderingOptions.WaitFor.RenderDelay(1000)
' Generate your dynamic HTML string
Dim dynamicHtml As String = GenerateDynamicHtml()
Dim pdf = renderer.RenderHtmlAsPdf(dynamicHtml)
Return File(pdf.BinaryData, "application/pdf", "dynamic.pdf")
End Function
Częstym problemem podczas konwersji HTML do PDF są niepożądane podziały stron, które oddzielają nagłówki od treści lub przecinają wiersze tabel w połowie. IronPDF adresuje to przez konfigurowalna kontrole podzialu stron przy uzyciu standardowych zasad CSS page-break-before i page-break-inside obok WaitFor API IronPDF. Biblioteka obsługuje również asynchroniczne generowanie plików PDF w celu zwiększenia przepustowości w scenariuszach o dużym natężeniu ruchu.
W przypadku zaawansowanych aplikacji JavaScript — takich jak wykresy renderowane przez D3.js lub komponenty React — można wstrzyknąć i wykonać niestandardowy kod JavaScript przed wykonaniem migawki renderowania, zapewniając, że wykres lub komponent zostanie w pełni zamontowany przed wygenerowaniem pliku PDF.
Wdrażanie IronPDF w środowiskach kontenerowych wymaga uwzględnienia konkretnych kwestii, aby zapewnić optymalną wydajność i niezawodność. Oto przykład pliku Dockerfile gotowego do użycia w środowisku produkcyjnym:
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443
# Install IronPDF Linux dependencies
RUN apt-get update && apt-get install -y \
libgdiplus \
libx11-6 \
libxcomposite1 \
libxdamage1 \
libxext6 \
libxfixes3 \
libxrandr2 \
libxrender1 \
libxtst6 \
fonts-liberation \
libnss3 \
libatk-bridge2.0-0 \
libdrm2 \
libxkbcommon0 \
libgbm1 \
libasound2 \
&& apt-get clean \
&& rm -rf /var/lib/apt/lists/*
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["YourProject.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet build -c Release -o /app/build
FROM build AS publish
RUN dotnet publish -c Release -o /app/publish
FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
# Set IronPDF temp folder for container environment
ENV IRONPDF_TEMP_FOLDER=/tmp/ironpdf
ENTRYPOINT ["dotnet", "YourProject.dll"]Przewodnik po integracji z Dockerem zawiera kompletne instrukcje wdrożeniowe. W przypadku minimalnych rozmiarów kontenerów należy stosować kompilacje wieloetapowe. Przewodnik wdrożeniowy dla systemu Linux obejmuje zależności specyficzne dla platformy.
W przypadku wdrożeń Kubernetes należy skonfigurować odpowiednie limity zasobów:
apiVersion: apps/v1
kind: Deployment
metadata:
name: pdf-service
spec:
replicas: 3
template:
spec:
containers:
- name: pdf-generator
image: your-registry/pdf-service:latest
resources:
requests:
memory: "512Mi"
cpu: "500m"
limits:
memory: "2Gi"
cpu: "2000m"
env:
- name: IRONPDF_LICENSE_KEY
valueFrom:
secretKeyRef:
name: ironpdf-license
key: key
livenessProbe:
httpGet:
path: /health
port: 80
initialDelaySeconds: 30
periodSeconds: 10Przewodnik po folderach środowiska uruchomieniowego wyjaśnia zarządzanie zależnościami w kontenerach. W przypadku systemu Red Hat Enterprise Linux może być wymagana dodatkowa konfiguracja.
Aby zapewnić optymalną wydajność i jakość podczas konwersji HTML do PDF, postępuj zgodnie z tymi sprawdzonymi praktykami. Rozważ wdrożenie przetwarzania asynchronicznego w celu lepszego wykorzystania zasobów w scenariuszach o dużym natężeniu ruchu. Przewodnik po przetwarzaniu równoległym przedstawia techniki równoczesnego generowania plików PDF.
Zawsze najpierw przetestuj renderowanie HTML w przeglądarce, aby sprawdzić styl i układ przed wygenerowaniem plików PDF. W miarę możliwości należy używać bezwzględnych adresów URL dla zasobów zewnętrznych, ponieważ ścieżki względne mogą powodować problemy podczas konwersji. W przypadku złożonych stron z dużą ilością kodu JavaScript należy dodać opóźnienia renderowania, aby zapewnić ich pełne załadowanie. Rozważ wdrożenie buforowania często generowanych dokumentów w celu zmniejszenia obciążenia serwera. Więcej informacji na temat najlepszych praktyk dotyczących .NET Core można znaleźć w oficjalnej dokumentacji firmy Microsoft. Przewodnik po renderowaniu z dokładnością do piksela zapewnia optymalną jakość wyniku.
Podczas wdrażania do środowiska produkcyjnego skonfiguruj odpowiednie ścieżki do folderów tymczasowych i upewnij się, że w środowisku hostingowym zainstalowano niezbędne zależności, zwłaszcza w przypadku wdrożeń w systemie Linux. Należy unikać umieszczania skryptów i logiki konwersji w tym samym katalogu, aby zapobiec konfliktom. Zapoznaj się z naszym przewodnikiem dotyczącym rozwiązywania problemów w typowych scenariuszach wdrażania. Zawsze sprawdzaj, czy dane wejściowe nie są adresem URL, gdy zamierzasz przetwarzać bezpośrednią zawartość HTML, aby uniknąć nieoczekiwanych zachowań. Wstępny przewodnik po optymalizacji renderowania dotyczy typowych wąskich gardeł wydajności.
W scenariuszach wymagających wysokiej wydajności należy wdrożyć buforowanie połączeń i zarządzanie zasobami:
public class PdfGeneratorService : IDisposable
{
private readonly SemaphoreSlim _semaphore;
private readonly ILogger<PdfGeneratorService> _logger;
public PdfGeneratorService(ILogger<PdfGeneratorService> logger)
{
_logger = logger;
// Limit concurrent PDF generations
_semaphore = new SemaphoreSlim(Environment.ProcessorCount * 2);
}
public async Task<byte[]> GeneratePdfAsync(string html)
{
await _semaphore.WaitAsync();
try
{
using (var renderer = new ChromePdfRenderer())
{
var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));
return pdf.BinaryData;
}
}
finally
{
_semaphore.Release();
}
}
public void Dispose()
{
_semaphore?.Dispose();
}
}Public Class PdfGeneratorService
Implements IDisposable
Private ReadOnly _semaphore As SemaphoreSlim
Private ReadOnly _logger As ILogger(Of PdfGeneratorService)
Public Sub New(logger As ILogger(Of PdfGeneratorService))
_logger = logger
' Limit concurrent PDF generations
_semaphore = New SemaphoreSlim(Environment.ProcessorCount * 2)
End Sub
Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
Await _semaphore.WaitAsync()
Try
Using renderer = New ChromePdfRenderer()
Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf(html))
Return pdf.BinaryData
End Using
Finally
_semaphore.Release()
End Try
End Function
Public Sub Dispose() Implements IDisposable.Dispose
_semaphore?.Dispose()
End Sub
End ClassPrzewodnik po wielowątkowości zawiera zaawansowane wzorce współbieżności. Aby zapobiec wyciekom pamięci, należy wdrożyć odpowiednie wzorce usuwania obiektów.
Monitoruj wskaźniki wydajności za pomocą niestandardowego logowania:
// Configure logging for production monitoring
Installation.LoggingMode = IronPdf.Logging.LoggingModes.Custom;
Installation.CustomLogger = (level, message) =>
{
_logger.Log(
level == IronPdf.Logging.LogLevels.Error ? LogLevel.Error : LogLevel.Information,
"IronPDF: {Message}",
message
);
};' Configure logging for production monitoring
Installation.LoggingMode = IronPdf.Logging.LoggingModes.Custom
Installation.CustomLogger = Sub(level, message)
_logger.Log(
If(level = IronPdf.Logging.LogLevels.Error, LogLevel.Error, LogLevel.Information),
"IronPDF: {Message}",
message
)
End SubPrzewodnik po plikach dziennika Azure oraz zarządzanie dziennikami AWS wyjaśniają strategie rejestrowania zdarzeń specyficzne dla chmury. Wdrożenie integracji wsparcia inżynieryjnego w celu szybkiego rozwiązywania problemów.
W celu zwiększenia bezpieczeństwa należy zastosować szyfrowanie plików PDF oraz podpisy cyfrowe. Przewodnik dotyczący CVE porusza typowe kwestie związane z bezpieczeństwem. Należy rozważyć oczyszczanie plików PDF w przypadku treści przesłanych przez użytkowników.
Konwersja HTML do PDF w aplikacjach ASP.NET Core staje się prosta dzięki IronPDF. Renderowanie biblioteki oparte na przeglądarce Chrome zapewnia dokładną konwersję, oferując jednocześnie szerokie możliwości dostosowania do potrzeb użytkownika w celu profesjonalnego generowania dokumentów.
Niezależnie od tego, czy pracujesz z ciągami HTML, adresami URL czy pełnymi stronami internetowymi, IronPDF zachowuje dokładne formatowanie, styl CSS i zachowanie JavaScript. To narzędzie oparte na platformie .NET sprawnie obsługuje cały proces konwersji. Obsługa Docker oraz funkcje optymalizacji wydajności sprawiają, że biblioteka idealnie nadaje się do nowoczesnych wdrożeń kontenerowych i architektur mikrousług.
Rozpocznij bezpłatny 30-dniowy okres próbny lub umów się na prezentację z naszym zespołem.
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ęczników.
IronPDF jest częścią IRONSUITE
10 produktów API .NET dla twoich dokumentów biurowych
Kiedy potrzebujesz, aby twój PDF wyglądał jak HTML, szybko.
