Jak dynamicznie generować PDF-y w C#
Wyświetlanie dokumentów PDF w kontrolkach panelowych ASP.NET jest częstym wymaganiem w systemach zarządzania dokumentami, przeglądarkach raportów i wyświetłącząch faktur. IronPDF rozwiązuje ten problem dzięki renderowaniu po stronie serwera, które eliminuje zależności po stronie klienta i działa spójnie we wszystkich przeglądarkach i na wszystkich platformach.
Gdy trzeba osadzić pliki PDF w aplikacji internetowej ASP.NET Core, standardowe podejście polegające na korzystaniu z wtyczek przeglądarki lub bibliotek po stronie klienta powoduje niestabilność. Ograniczenia wtyczek w środowiskach Enterprise, niespójne działanie przeglądarek i słaba obsługa urządzeń mobilnych negatywnie wpływają na komfort użytkowania. Podejście po stronie serwera eliminuje wszystkie te problemy.
IronPDF obsługuje generowanie i dostarczanie plików PDF całkowicie na serwerze, dzięki czemu przeglądarka otrzymuje standardowy strumień bajtów PDF o prawidłowym typie MIME — nie są wymagane żadne wtyczki ani rozwiązania dostosowane do konkretnej przeglądarki.
Jak działa renderowanie plików PDF po stronie serwera w ASP.NET?
IronPDF przenosi renderowanie PDF całkowicie na serwer, używając silnika Headless Chrome. Twój kontroler generuje lub pobiera dokument PDF, konwertuje go na tablicę bajtów i przesyła do przeglądarki za pomocą nagłówka inline Content-Disposition. Wbudowany przeglądarka PDF następnie wyświetla dokument wewnątrz osadzonego <iframe> w panelu.
Ta fundamentalna Shift eliminuje tradycyjne problemy:
- Na komputerze klienta nie jest wymagany program Adobe Reader ani rozszerzenie przeglądarki
- Spójne wyświetlanie niezależnie od systemu operacyjnego użytkownika lub wersji przeglądarki
- Pełna programowa kontrola nad treścią, układem i stylem dokumentu
- Działa w środowiskach Enterprise, w których polityki IT blokują instalację wtyczek
Silnik renderujący biblioteki w przeglądarce Chrome generuje obraz o idealnej rozdzielczości na podstawie HTML, adresów URL i surowych źródeł treści. Kontrolujesz każdy aspekt wydruku — rozmiar papieru, marginesy, nagłówki, stopki i typ mediów CSS — zanim plik PDF trafi do klienta.
IronPDF obsługuje również wdrażanie wielopłatformowe na serwerach z systemami Windows, Linux i macOS, dzięki czemu nadaje się do aplikacji ASP.NET hostowanych w chmurze, działających na platformach Azure lub AWS, a także w środowiskach kontenerowych wykorzystujących Docker.
Jak skonfigurować pakiet NuGet?
Otwórz program Visual Studio, kliknij prawym przyciskiem myszy swój projekt w Eksploratorze rozwiązań i wybierz opcję Zarządzaj pakietami NuGet. Wyszukaj IronPdf i zainstaluj. Alternatywnie, uruchom to polecenie w konsoli menedżera pakietów:
Install-Package IronPdf
Możesz również użyć .NET CLI z dotnet add package IronPdf. Po zainstalowaniu dodaj using IronPdf; na górze swojej klasy kontrolera lub usługi, aby uzyskać dostęp do przestrzeni nazw biblioteki.
Aby optymalnie dostarczać PDF, skonfiguruj swoje Program.cs, aby obsługiwały statyczne pliki i ustaw routing:
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
builder.Services.AddRazorPages();
var app = builder.Build();
app.UseStaticFiles();
app.UseRouting();
app.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
builder.Services.AddRazorPages();
var app = builder.Build();
app.UseStaticFiles();
app.UseRouting();
app.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();Imports Microsoft.AspNetCore.Builder
Imports Microsoft.Extensions.DependencyInjection
Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllersWithViews()
builder.Services.AddRazorPages()
Dim app = builder.Build()
app.UseStaticFiles()
app.UseRouting()
app.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}")
app.Run()Rejestracja AddControllersWithViews() umożliwia zarówno punkty końcowe API, jak i renderowanie widoków - oba są niezbędne, gdy chcesz serwować treści PDF poprzez dedykowane akcje kontrolera i wyświetlać je wewnątrz paneli widoku Razor. Pełne informacje dotyczące konfiguracji można znaleźć w dokumentacji API IronPDF.
Jak wyświetlić plik PDF bezpośrednio w panelu?
Podstawowy wzorzec jest prosty: akcja kontrolera generuje PDF, konwertuje go na bajty, ustawia nagłówek Content-Disposition na inline i zwraca wynik File. Widok Razor posiada wskazanie <iframe> do tego punktu końcowego.
Oto kompletna implementacja kontrolera:
[ApiController]
[Route("api/[controller]")]
public class PdfPanelController : ControllerBase
{
[HttpGet("display/{documentId}")]
public IActionResult DisplayPdfInPanel(string documentId)
{
var renderer = new ChromePdfRenderer();
string filename = $"document_{documentId}.pdf";
var htmlContent = $@"
<html>
<head>
<style>
body {{font-family: Arial, sans-serif; margin: 40px;}}
h1 {{color: #333;}}
.content {{line-height: 1.6;}}
</style>
</head>
<body>
<h1>Document #{documentId}</h1>
<div class='content'>
<p>This PDF is generated dynamically and displayed inline in your panel.</p>
<p>Generated at: {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>
</div>
</body>
</html>";
using var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
byte[] pdfBytes = pdfDocument.BinaryData;
Response.Headers.Append("Content-Disposition", $"inline; filename={filename}");
return File(pdfBytes, "application/pdf");
}
}[ApiController]
[Route("api/[controller]")]
public class PdfPanelController : ControllerBase
{
[HttpGet("display/{documentId}")]
public IActionResult DisplayPdfInPanel(string documentId)
{
var renderer = new ChromePdfRenderer();
string filename = $"document_{documentId}.pdf";
var htmlContent = $@"
<html>
<head>
<style>
body {{font-family: Arial, sans-serif; margin: 40px;}}
h1 {{color: #333;}}
.content {{line-height: 1.6;}}
</style>
</head>
<body>
<h1>Document #{documentId}</h1>
<div class='content'>
<p>This PDF is generated dynamically and displayed inline in your panel.</p>
<p>Generated at: {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>
</div>
</body>
</html>";
using var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
byte[] pdfBytes = pdfDocument.BinaryData;
Response.Headers.Append("Content-Disposition", $"inline; filename={filename}");
return File(pdfBytes, "application/pdf");
}
}Imports Microsoft.AspNetCore.Mvc
Imports System
<ApiController>
<Route("api/[controller]")>
Public Class PdfPanelController
Inherits ControllerBase
<HttpGet("display/{documentId}")>
Public Function DisplayPdfInPanel(documentId As String) As IActionResult
Dim renderer = New ChromePdfRenderer()
Dim filename As String = $"document_{documentId}.pdf"
Dim htmlContent As String = $"
<html>
<head>
<style>
body {{font-family: Arial, sans-serif; margin: 40px;}}
h1 {{color: #333;}}
.content {{line-height: 1.6;}}
</style>
</head>
<body>
<h1>Document #{documentId}</h1>
<div class='content'>
<p>This PDF is generated dynamically and displayed inline in your panel.</p>
<p>Generated at: {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>
</div>
</body>
</html>"
Using pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
Dim pdfBytes As Byte() = pdfDocument.BinaryData
Response.Headers.Append("Content-Disposition", $"inline; filename={filename}")
Return File(pdfBytes, "application/pdf")
End Using
End Function
End ClassKlasa ChromePdfRenderer jest głównym punktem wejścia dla renderowania po stronie serwera. Akceptuje treść HTML, konwertuje ją za pomocą przeglądarki Headless Chrome i zwraca obiekt PdfDocument. Właściwość BinaryData udostępnia surowe bajty do przesyłania strumieniowego.
Ustawienie Content-Disposition na inline jest kluczowym krokiem dla wyświetlania w panelu. Bez tego przeglądarka wyświetla monit o pobieranie zamiast renderować wewnątrz <iframe>. Możesz również dodać nagłówki i stopki do każdej strony lub kontrolować orientację strony i niestandardowe marginesy za pomocą RenderingOptions.
Aby osadzić ten punkt końcowy w panelu Razor, utwórz <iframe> wskazujący na trasę kontrolera:
@page
@model IndexModel
<div class="container mt-4">
<div class="card">
<div class="card-header">
<h3>PDF Display Panel</h3>
</div>
<div class="card-body">
<div class="pdf-panel" style="height: 600px;">
<iframe src="/api/PdfPanel/display/12345"
width="100%"
height="100%"
frameborder="0">
</iframe>
</div>
</div>
</div>
</div>@page
@model IndexModel
<div class="container mt-4">
<div class="card">
<div class="card-header">
<h3>PDF Display Panel</h3>
</div>
<div class="card-body">
<div class="pdf-panel" style="height: 600px;">
<iframe src="/api/PdfPanel/display/12345"
width="100%"
height="100%"
frameborder="0">
</iframe>
</div>
</div>
</div>
</div>The provided code is a Razor page markup, which is not directly translatable to VB.NET as it is not C# code. Razor pages are used in ASP.NET Core for creating dynamic web pages and are written in a combination of HTML and C#.
If you need to convert the C# logic within a Razor page to VB.NET, you would typically focus on the code-behind file or any C# code embedded within the Razor markup. However, the provided snippet contains only HTML and Razor directives without any C# logic to convert.
If you have a specific C# code-behind logic or embedded C# code within a Razor page that you need to convert to VB.NET, please provide that portion, and I can assist with the conversion.<iframe> żąda PDF z punktu końcowego twojego kontrolera. W tym momencie zadanie przejmuje wbudowana przeglądarka plików PDF, wyświetlając dokument na całej szerokości i wysokości panelu bez żadnych bibliotek ani wtyczek po stronie klienta.
Jak wygląda wygenerowany plik PDF?
Jak dynamicznie ładować pliki PDF za pomocą AJAX?
Statyczne źródła <iframe> dobrze działają dla ustalonych treści, ale wiele aplikacji musi ładować PDFy na podstawie działań użytkowników - kliknięcia rekordu w siatce danych, przesłania formularza lub wybierania typu raportu. Podejście oparte na AJAX pozwala obsługiwać te scenariusze bez konieczności ponownego ładowania całej strony.
Akcja kontrolera przyjmuje treść żądania i zwraca plik PDF jako ciąg znaków w formacie base64:
[HttpPost("generate")]
public async Task<IActionResult> GenerateDynamicPdf([FromBody] PdfRequestModel request)
{
try
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 20;
renderer.RenderingOptions.MarginBottom = 20;
renderer.RenderingOptions.MarginLeft = 20;
renderer.RenderingOptions.MarginRight = 20;
var htmlBuilder = new StringBuilder();
htmlBuilder.Append("<html><body>");
htmlBuilder.Append($"<h2>{request.Title}</h2>");
htmlBuilder.Append($"<div>{request.Content}</div>");
if (request.IncludeData)
{
htmlBuilder.Append("<table border='1' style='width:100%;'>");
foreach (var item in request.DataItems)
{
htmlBuilder.Append($"<tr><td>{item.Key}</td><td>{item.Value}</td></tr>");
}
htmlBuilder.Append("</table>");
}
htmlBuilder.Append("</body></html>");
var pdfDocument = await Task.Run(() =>
renderer.RenderHtmlAsPdf(htmlBuilder.ToString()));
var base64Pdf = Convert.ToBase64String(pdfDocument.BinaryData);
return Ok(new { success = true, pdfData = base64Pdf });
}
catch (Exception ex)
{
return BadRequest(new { success = false, error = ex.Message });
}
}[HttpPost("generate")]
public async Task<IActionResult> GenerateDynamicPdf([FromBody] PdfRequestModel request)
{
try
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 20;
renderer.RenderingOptions.MarginBottom = 20;
renderer.RenderingOptions.MarginLeft = 20;
renderer.RenderingOptions.MarginRight = 20;
var htmlBuilder = new StringBuilder();
htmlBuilder.Append("<html><body>");
htmlBuilder.Append($"<h2>{request.Title}</h2>");
htmlBuilder.Append($"<div>{request.Content}</div>");
if (request.IncludeData)
{
htmlBuilder.Append("<table border='1' style='width:100%;'>");
foreach (var item in request.DataItems)
{
htmlBuilder.Append($"<tr><td>{item.Key}</td><td>{item.Value}</td></tr>");
}
htmlBuilder.Append("</table>");
}
htmlBuilder.Append("</body></html>");
var pdfDocument = await Task.Run(() =>
renderer.RenderHtmlAsPdf(htmlBuilder.ToString()));
var base64Pdf = Convert.ToBase64String(pdfDocument.BinaryData);
return Ok(new { success = true, pdfData = base64Pdf });
}
catch (Exception ex)
{
return BadRequest(new { success = false, error = ex.Message });
}
}Imports System.Text
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc
<HttpPost("generate")>
Public Async Function GenerateDynamicPdf(<FromBody> request As PdfRequestModel) As Task(Of IActionResult)
Try
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 20
renderer.RenderingOptions.MarginBottom = 20
renderer.RenderingOptions.MarginLeft = 20
renderer.RenderingOptions.MarginRight = 20
Dim htmlBuilder = New StringBuilder()
htmlBuilder.Append("<html><body>")
htmlBuilder.Append($"<h2>{request.Title}</h2>")
htmlBuilder.Append($"<div>{request.Content}</div>")
If request.IncludeData Then
htmlBuilder.Append("<table border='1' style='width:100%;'>")
For Each item In request.DataItems
htmlBuilder.Append($"<tr><td>{item.Key}</td><td>{item.Value}</td></tr>")
Next
htmlBuilder.Append("</table>")
End If
htmlBuilder.Append("</body></html>")
Dim pdfDocument = Await Task.Run(Function() renderer.RenderHtmlAsPdf(htmlBuilder.ToString()))
Dim base64Pdf = Convert.ToBase64String(pdfDocument.BinaryData)
Return Ok(New With {Key .success = True, Key .pdfData = base64Pdf})
Catch ex As Exception
Return BadRequest(New With {Key .success = False, Key .error = ex.Message})
End Try
End FunctionBlok RenderingOptions pozwala skonfigurować rozmiar papieru, marginesy i typ mediów CSS przed renderowaniem. Zgodnie z dokumentacją Microsoftu dotyczącą .NET Core, wzorce asynchroniczne są niezbędne do utrzymania responsywnych interfejsów pod obciążeniem. Opakowanie synchronicznego wywołania renderowania w Task.Run utrzymuje wolny wątek żądania, podczas gdy silnik Chrome przetwarza HTML.
Odpowiedź base64 pozwala klientowi JavaScript zaktualizować źródło <iframe> bez przeładowania strony:
fetch('/api/PdfPanel/generate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(requestData)
})
.then(response => response.json())
.then(result => {
if (result.success) {
const iframe = document.getElementById('pdf-frame');
iframe.src = 'data:application/pdf;base64,' + result.pdfData;
}
});fetch('/api/PdfPanel/generate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(requestData)
})
.then(response => response.json())
.then(result => {
if (result.success) {
const iframe = document.getElementById('pdf-frame');
iframe.src = 'data:application/pdf;base64,' + result.pdfData;
}
});Ten wzorzec dobrze działa zarówno dla Razor Pages, jak i widoków MVC. Dla zaawansowanych zastosowań IronPDF również wspiera renderowanie asynchroniczne natywnie, więc można używać RenderHtmlAsPdfAsync bezpośrednio zamiast Task.Run.
Jak radzicie sobie z różnymi typami plików źródłowych PDF?
IronPDF może generować pliki PDF z trzech głównych źródeł: ciągów znaków HTML, lokalnych plików HTML oraz zewnętrznych adresów URL. Każde z nich nadaje się do innych scenariuszy.
Jak konwertować szablony HTML na pliki PDF?
Generowanie oparte na szablonach jest najczęstszym wzorcem w Enterprise aplikacjach ASP.NET. Utrzymujesz szablony HTML z tokenami zastępczymi, wstawiasz dane w czasie wykonywania i renderujesz wynik:
[HttpGet("from-html")]
public IActionResult GenerateFromHtmlString(string reportType)
{
var renderer = new ChromePdfRenderer();
var htmlTemplate = GetHtmlTemplate(reportType);
var userName = User?.Identity?.Name ?? "Unknown";
var processedHtml = htmlTemplate
.Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
.Replace("{{USER}}", userName)
.Replace("{{REPORT_TYPE}}", reportType);
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
using var pdf = renderer.RenderHtmlAsPdf(processedHtml);
pdf.SaveAs(Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", $"{reportType}.pdf"));
return File(pdf.BinaryData, "application/pdf");
}
private string GetHtmlTemplate(string reportType)
{
return @"
<html>
<head><title>{{REPORT_TYPE}} Report</title></head>
<body>
<h1>{{REPORT_TYPE}} Report</h1>
<p>Date: {{DATE}}</p>
<p>User: {{USER}}</p>
<div>Report content goes here.</div>
</body>
</html>";
}[HttpGet("from-html")]
public IActionResult GenerateFromHtmlString(string reportType)
{
var renderer = new ChromePdfRenderer();
var htmlTemplate = GetHtmlTemplate(reportType);
var userName = User?.Identity?.Name ?? "Unknown";
var processedHtml = htmlTemplate
.Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
.Replace("{{USER}}", userName)
.Replace("{{REPORT_TYPE}}", reportType);
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
using var pdf = renderer.RenderHtmlAsPdf(processedHtml);
pdf.SaveAs(Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", $"{reportType}.pdf"));
return File(pdf.BinaryData, "application/pdf");
}
private string GetHtmlTemplate(string reportType)
{
return @"
<html>
<head><title>{{REPORT_TYPE}} Report</title></head>
<body>
<h1>{{REPORT_TYPE}} Report</h1>
<p>Date: {{DATE}}</p>
<p>User: {{USER}}</p>
<div>Report content goes here.</div>
</body>
</html>";
}Imports System
Imports Microsoft.AspNetCore.Mvc
Imports IronPdf
Imports System.IO
<HttpGet("from-html")>
Public Function GenerateFromHtmlString(reportType As String) As IActionResult
Dim renderer As New ChromePdfRenderer()
Dim htmlTemplate As String = GetHtmlTemplate(reportType)
Dim userName As String = If(User?.Identity?.Name, "Unknown")
Dim processedHtml As String = htmlTemplate _
.Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd")) _
.Replace("{{USER}}", userName) _
.Replace("{{REPORT_TYPE}}", reportType)
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
Using pdf = renderer.RenderHtmlAsPdf(processedHtml)
pdf.SaveAs(Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", $"{reportType}.pdf"))
Return File(pdf.BinaryData, "application/pdf")
End Using
End Function
Private Function GetHtmlTemplate(reportType As String) As String
Return "
<html>
<head><title>{{REPORT_TYPE}} Report</title></head>
<body>
<h1>{{REPORT_TYPE}} Report</h1>
<p>Date: {{DATE}}</p>
<p>User: {{USER}}</p>
<div>Report content goes here.</div>
</body>
</html>"
End FunctionCssMediaType.Print zapewnia, że PDF używa CSS specyficznych dla druku, które zazwyczaj usuwają paski nawigacyjne, paski boczne i inne elementy tylko dla ekranu. Dzięki temu uzyskuje się bardziej przejrzysty wynik, gdy szablony HTML są współdzielone między widokami internetowymi a generowaniem plików PDF. Można również zastosować niestandardowe znaki wodne lub obrazy tła w celu budowania marki. W przypadku złożonych układów funkcja kontroli podziału stron pozwala dokładnie określić, gdzie zaczynają się nowe strony.
Jak wygląda plik PDF wygenerowany z szablonu HTML?
Jak generować pliki PDF z zewnętrznych adresów URL?
W celu przechwytywania zewnętrznych stron internetowych — analizy konkurencji, dokumentów regulacyjnych lub treści z usług stron trzecich — IronPDF może renderować dowolny publicznie dostępny adres URL:
[HttpGet("from-url")]
public async Task<IActionResult> GenerateFromUrl(string encodedUrl)
{
var url = HttpUtility.UrlDecode(encodedUrl);
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.ViewPortWidth = 1920;
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(2000);
using var pdf = await renderer.RenderUrlAsPdfAsync(url);
Response.Headers.Append("Content-Disposition", "inline; filename=webpage.pdf");
return File(pdf.BinaryData, "application/pdf");
}[HttpGet("from-url")]
public async Task<IActionResult> GenerateFromUrl(string encodedUrl)
{
var url = HttpUtility.UrlDecode(encodedUrl);
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.ViewPortWidth = 1920;
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(2000);
using var pdf = await renderer.RenderUrlAsPdfAsync(url);
Response.Headers.Append("Content-Disposition", "inline; filename=webpage.pdf");
return File(pdf.BinaryData, "application/pdf");
}Imports System.Web
Imports Microsoft.AspNetCore.Mvc
<HttpGet("from-url")>
Public Async Function GenerateFromUrl(encodedUrl As String) As Task(Of IActionResult)
Dim url = HttpUtility.UrlDecode(encodedUrl)
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.ViewPortWidth = 1920
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.RenderDelay(2000)
Using pdf = Await renderer.RenderUrlAsPdfAsync(url)
Response.Headers.Append("Content-Disposition", "inline; filename=webpage.pdf")
Return File(pdf.BinaryData, "application/pdf")
End Using
End FunctionUstawienie ViewPortWidth określa, jak szeroko bezgłowy przeglądarka renderuje stronę przed konwersją do PDF. Okno wyświetlania o szerokości 1920 pikseli pozwala uchwycić nowoczesne, responsywne układy w rozdzielczości pulpitu. Opóźnienie renderowania daje aplikacjom jednostronicowym, intensywnie wykorzystującym JavaScript, czas na zakończenie inicjalizacji przed wykonaniem zrzutu ekranu.
W przypadku bardziej zaawansowanych scenariuszy przechwytywania IronPDF obsługuje kontrolę wykonywania kodu JavaScript, przekazywanie plików cookie dla stron wymagających uwierzytelnienia oraz regulację powiększenia okna wyświetlania.
Jak zarządzasz pamięcią i wydajnością?
Generowanie PDF jest zasobożerne. Każde wywołanie ChromePdfRenderer tworzy proces Headless Chrome, a każdy obiekt PdfDocument trzyma renderowane bajty w pamięci. Właściwe usuwanie zapobiega wyciekom zasobów i pozwala utrzymać przewidywalne zużycie pamięci pod obciążeniem.
Zawsze używaj instrukcji using ze PdfDocument:
public IActionResult OptimizedPdfGeneration()
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = false;
var processedHtml = GetHtmlTemplate("report")
.Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
.Replace("{{USER}}", "Test")
.Replace("{{REPORT_TYPE}}", "Report");
using var pdf = renderer.RenderHtmlAsPdf(processedHtml);
byte[] pdfBytes = pdf.BinaryData;
pdf.SaveAs("output.pdf");
return File(pdfBytes, "application/pdf");
}public IActionResult OptimizedPdfGeneration()
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = false;
var processedHtml = GetHtmlTemplate("report")
.Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
.Replace("{{USER}}", "Test")
.Replace("{{REPORT_TYPE}}", "Report");
using var pdf = renderer.RenderHtmlAsPdf(processedHtml);
byte[] pdfBytes = pdf.BinaryData;
pdf.SaveAs("output.pdf");
return File(pdfBytes, "application/pdf");
}Imports System
Imports Microsoft.AspNetCore.Mvc
Public Class PdfController
Inherits Controller
Public Function OptimizedPdfGeneration() As IActionResult
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.CreatePdfFormsFromHtml = False
Dim processedHtml = GetHtmlTemplate("report") _
.Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd")) _
.Replace("{{USER}}", "Test") _
.Replace("{{REPORT_TYPE}}", "Report")
Using pdf = renderer.RenderHtmlAsPdf(processedHtml)
Dim pdfBytes As Byte() = pdf.BinaryData
pdf.SaveAs("output.pdf")
Return File(pdfBytes, "application/pdf")
End Using
End Function
Private Function GetHtmlTemplate(templateName As String) As String
' Placeholder for the actual implementation
Return String.Empty
End Function
End ClassInstrukcja using zapewnia, że obiekt PdfDocument jest natychmiast usuwany po wyciągnięciu tablicy bajtów, nawet jeśli wystąpi wyjątek poniżej. W przypadku aplikacji, które często generują pliki PDF, warto rozważyć następujące dodatkowe strategie:
- Buforowanie: Przechowuj często wywoływane pliki PDF w pamięci podręcznej lub na dysku. Użyj
IMemoryCachedo buforowania tablicy bajtów zakodowanej kluczem identyfikatora dokumentu i czasem. - Przesyłanie strumieniowe: W przypadku bardzo dużych dokumentów należy używać strumieni pamięci PDF zamiast tablic bajtów, aby uniknąć alokacji dużych, ciągłych bloków pamięci.
- Liniaryzacja: Włącz liniaryzowane (szybkie wyświetlanie stron) wyjście, aby przeglądarki mogły rozpocząć renderowanie przed pobraniem całego pliku.
- Kompresja: Zastosuj kompresję plików PDF, aby zmniejszyć rozmiar plików podczas udostępniania dokumentów przez ograniczone połączenia sieciowe.
Przewodnik dotyczący wydajności IronPDF obejmuje dodatkowe strategie optymalizacji dla scenariuszy wymagających dużej przepustowości.
Co daje zoptymalizowany plik PDF?
Jak zapewnić bezpieczeństwo i kompatybilność z różnymi przeglądarkami?
Przed wdrożeniem wyświetlacza panelowego PDF do produkcji należy zwrócić uwagę zarówno na bezpieczeństwo, jak i niezawodność.
Walidacja danych wejściowych: Zawsze oczyszczaj treści dynamiczne przed wstawieniem ich do szablonów HTML. Nieoczyszczone dane wprowadzane przez użytkownika i renderowane przez silnik Chrome mogą narazić serwer na ataki SSRF i XSS. Należy korzystać z uznanych bibliotek kodowania HTML lub ograniczyć akceptowane znaki do bezpiecznej listy dozwolonych znaków.
Kontrola dostępu: Chroń swoje punkty końcowe PDF za pomocą oprogramowania pośredniczącego do uwierzytelniania i autoryzacji. URL, jak /api/PdfPanel/display/12345, który zwraca dokument bez sprawdzenia tożsamości dzwoniącego, jest ryzykiem ujawnienia danych. Zastosuj atrybuty [Authorize] i sprawdź, czy uwierzytelniony użytkownik ma prawo dostępu do żądanego identyfikatora dokumentu.
Konfiguracja typu MIME: Zawsze zwracaj application/pdf jako typ treści. Przeglądarki, które otrzymają niepoprawny typ MIME, mogą wywołać okno dialogowe pobierania lub odmówić renderowania online. Zweryfikuj mapowania typów MIME swojej aplikacji, jeśli również serwujesz statyczne pliki PDF z wwwroot.
Wyświetlanie inline między przeglądarkami: Nowoczesne przeglądarki - Chrome, Firefox, Edge i Safari - wszystkie obsługują online wyświetlanie PDF za pomocą nagłówka Content-Disposition: inline. Specyfikacja W3C Content Security Policy zawiera wytyczne dotyczące dyrektyw frame-ancestors, jeśli panele osadzają pliki PDF z różnych źródeł. Renderowanie po stronie serwera w IronPDF eliminuje większość niespójności w renderowaniu przeglądarek, ponieważ generowanie plików PDF odbywa się niezależnie od klienta.
Obsługa błędów: Otocz generowanie plików PDF blokami try-catch i zwracaj sensowne kody statusu HTTP. Odpowiedź 500 bez treści jest trudna do zdiagnozowania. Zwróć uporządkowany obiekt błędu, aby kod po stronie klienta mógł wyświetlić przyjazną dla użytkownika wiadomość zamiast uszkodzonego <iframe>.
W celu zapewnienia bezpieczeństwa dokumentów IronPDF obsługuje ochronę hasłem i uprawnienia, podpisy cyfrowe oraz zgodność z formatem PDF/A dla potrzeb archiwizacji.
Jakie są Twoje kolejne kroki?
Masz teraz działający wzorzec dla wyświetlania PDF w panelach ASP.NET: zainstaluj IronPDF, utwórz akcję kontrolera, która generuje PDF i zwraca go z Content-Disposition: inline, i osadź punkt końcowy w <iframe> wewnątrz swojego panelu Razor. Dzięki temu wzorzec AJAX pozwala na dynamiczne ładowanie dokumentów w odpowiedzi na działania użytkownika bez konieczności ponownego ładowania strony.
Rozpocznij bezpłatny okres próbny IronPDF, aby przetestować te wzorce we własnym projekcie — nie jest wymagana karta kredytowa. Wersja próbna zapewnia pełny dostęp do wszystkich funkcji, w tym renderowania HTML do PDF, przechwytywania adresów URL oraz zaawansowanej edycji plików PDF.
Gdy podstawowa wersja będzie już działać, rozważ następujące naturalne rozszerzenia:
- Łączenie lub dzielenie plików PDF w ramach procesów tworzenia dokumentów
- Tworzenie formularzy PDF do wypełnienia na podstawie formularzy HTML
- Dodaj podpisy cyfrowe w celu uwierzytelnienia dokumentów
- Edytuj istniejące pliki PDF, aby dodawać pieczątki, adnotacje lub redagować treść
- Konwersja HTML do PDF z pełną obsługą CSS i JavaScript dla złożonych układów raportów
Dokumentacja IronPDF szczegółowo omawia każdą z tych funkcji, zawierając kompletne przykłady kodu i informacje dotyczące konfiguracji.
Często Zadawane Pytania
Jaki jest cel wyswietlania PDF w panelach ASP.NET?
Wyswietlanie PDF w panelach ASP.NET pozwala programistom na integracje dokumentów PDF bezpośrednio z aplikacjami webowymi, tworząc spojne doswiadczenie użytkownika w zarzadzaniu dokumentami, przeglądaniu raportow lub wyswietlaniu faktur.
Jak IronPDF może pomoc w wyswietlaniu PDF w ASP.NET?
IronPDF dostarcza narzędzia, ktore umożliwiaja programistom łatwe renderowanie i wyswietlanie dokumentów PDF w panelach ASP.NET, zapewniając plynna integracje i spojny interfejs użytkownika.
Jakie sa korzysci z używania IronPDF do wyswietlania PDF w aplikacjach ASP.NET?
Uzycie IronPDF ułatwia integracje PDF, skraca czas rozwoju i zwieksza funkcjonalność aplikacji ASP.NET, zapewniając wysokiej jakosci renderowanie PDF w kontrolkach UI.
Czy IronPDF może być uzyty do budowy systemów zarządzania dokumentami w ASP.NET?
Tak, IronPDF jest idealny do budowy systemów zarządzania dokumentami, poniewaz wspiera bezproblemowe wyswietlanie PDF w panelach ASP.NET, zwiększając zdolnosc do zarządzania i przeglądania dokumentów bezpośrednio w sieci.
Czy IronPDF jest kompatybilny z ASP.NET Core do wyswietlania PDF?
IronPDF jest w pelni kompatybilny z ASP.NET Core, co umożliwia programistom wyswietlanie dokumentów PDF w aplikacjach webowych z użyciem kontrolek panelowych, zapewniając nowoczesna integracje webowa.
Rozpocznij za DARMO
Rozpocznij za DARMO
Zarezerwuj darmowe Demo na żywo
Nie wymaga karty kredytowej ani tworzenia konta
