Generowanie PDF w ASP.NET MVC: Przewodnik iTextSharp vs. IronPDF
Full Comparison
Looking for a detailed feature-by-feature breakdown? See how IronPDF stacks up against Itext on pricing, HTML support, and licensing.
IronPDF zapewnia doskonałą konwersję HTML do PDF z pełną obsługą CSS3 i JavaScript przy użyciu renderowania Chrome. Natomiast iTextSharp oferuje programowe tworzenie plików PDF, ale ma trudności z konwersją nowoczesnego kodu HTML, co sprawia, że IronPDF jest lepszym wyborem dla aplikacji ASP.NET MVC, które wymagają plików PDF zgodnych ze standardami internetowymi.
Tworzenie dokumentów PDF w aplikacjach ASP.NET MVC jest powszechnym wymogiem przy generowaniu raportów, faktur i treści do pobrania. Chociaż iTextSharp od lat cieszy się popularnością, IronPDF stanowi nowoczesną alternatywę z doskonałymi możliwościami renderowania HTML. W tym artykule omówiono oba podejścia, aby pomóc Ci podjąć świadomą decyzję dotyczącą Twoich potrzeb w zakresie generowania plików PDF w środowisku .NET.
Obie biblioteki rozwiązują ten sam podstawowy problem — generowanie plików PDF w kontekście sieciowym .NET — ale stosują zasadniczo różne podejścia. iTextSharp tworzy pliki PDF programowo za pomocą modelu obiektowego, podczas gdy IronPDF konwertuje HTML na PDF przy użyciu pełnego silnika renderującego Chrome. Zrozumienie tej różnicy architektonicznej jest kluczem do wyboru odpowiedniego narzędzia. Framework ASP.NET MVC firmy Microsoft obsługuje oba wzorce integracji, a każdą z bibliotek można podłączyć do standardowego potoku kontroler-akcja.
Jak zainstalować każdą z bibliotek?
Przed napisaniem jakiegokolwiek kodu należy dodać każdą bibliotekę do swojego projektu. NuGet jest standardowym menedżerem pakietów dla platformy .NET i sprawnie obsługuje oba rodzaje instalacji. W przypadku iTextSharp zainstaluj starszą wersję pakietu za pośrednictwem NuGet:
dotnet add package iTextSharpdotnet add package iTextSharpW przypadku IronPDF należy również zainstalować go za pośrednictwem NuGet:
dotnet add package IronPdfdotnet add package IronPdfIronPDF zawiera silnik renderujący Chrome w pakiecie, więc nie jest wymagana dodatkowa instalacja przeglądarki na serwerze. Biblioteka od razu po instalacji obsługuje systemy Windows, Linux, macOS oraz środowiska kontenerowe. Po instalacji dodaj klucz licencyjny IronPDF podczas uruchamiania aplikacji.
Jak wygenerować plik PDF za pomocą iTextSharp w MVC?
Aby generować pliki PDF przy użyciu iTextSharp w aplikacji ASP.NET MVC, najpierw zainstaluj bibliotekę za pośrednictwem NuGet. Biblioteka iTextSharp zapewnia niskopoziomową kontrolę nad tworzeniem plików PDF poprzez klasę Document i model obiektowy.
Poniższy kod przedstawia gotową do wdrożenia implementację tworzenia plików PDF za pomocą iTextSharp w kontrolerze MVC:
// Production-ready iTextSharp implementation with proper resource disposal
public class ReportController : Controller
{
private readonly ILogger<ReportController> _logger;
public ReportController(ILogger<ReportController> logger)
{
_logger = logger;
}
public ActionResult GeneratePDF()
{
try
{
using var memoryStream = new MemoryStream();
using var document = new Document(PageSize.A4, 50, 50, 25, 25);
using var writer = PdfWriter.GetInstance(document, memoryStream);
document.Open();
document.AddTitle("Generated Report");
document.AddCreationDate();
var titleFont = FontFactory.GetFont(FontFactory.HELVETICA_BOLD, 16);
document.Add(new Paragraph("Hello World", titleFont));
document.Add(new Paragraph("This is a PDF document created with iTextSharp"));
var table = new PdfPTable(3);
table.AddCell("Header 1");
table.AddCell("Header 2");
table.AddCell("Header 3");
document.Add(table);
document.Close();
var pdfBytes = memoryStream.ToArray();
Response.Headers.Add("Content-Disposition", "inline; filename=report.pdf");
_logger.LogInformation("PDF generated: {Size} bytes", pdfBytes.Length);
return File(pdfBytes, "application/pdf");
}
catch (Exception ex)
{
_logger.LogError(ex, "Error generating PDF");
return StatusCode(500, "Error generating PDF document");
}
}
}// Production-ready iTextSharp implementation with proper resource disposal
public class ReportController : Controller
{
private readonly ILogger<ReportController> _logger;
public ReportController(ILogger<ReportController> logger)
{
_logger = logger;
}
public ActionResult GeneratePDF()
{
try
{
using var memoryStream = new MemoryStream();
using var document = new Document(PageSize.A4, 50, 50, 25, 25);
using var writer = PdfWriter.GetInstance(document, memoryStream);
document.Open();
document.AddTitle("Generated Report");
document.AddCreationDate();
var titleFont = FontFactory.GetFont(FontFactory.HELVETICA_BOLD, 16);
document.Add(new Paragraph("Hello World", titleFont));
document.Add(new Paragraph("This is a PDF document created with iTextSharp"));
var table = new PdfPTable(3);
table.AddCell("Header 1");
table.AddCell("Header 2");
table.AddCell("Header 3");
document.Add(table);
document.Close();
var pdfBytes = memoryStream.ToArray();
Response.Headers.Add("Content-Disposition", "inline; filename=report.pdf");
_logger.LogInformation("PDF generated: {Size} bytes", pdfBytes.Length);
return File(pdfBytes, "application/pdf");
}
catch (Exception ex)
{
_logger.LogError(ex, "Error generating PDF");
return StatusCode(500, "Error generating PDF document");
}
}
}Imports System
Imports System.IO
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.Extensions.Logging
Imports iTextSharp.text
Imports iTextSharp.text.pdf
Public Class ReportController
Inherits Controller
Private ReadOnly _logger As ILogger(Of ReportController)
Public Sub New(logger As ILogger(Of ReportController))
_logger = logger
End Sub
Public Function GeneratePDF() As ActionResult
Try
Using memoryStream As New MemoryStream()
Using document As New Document(PageSize.A4, 50, 50, 25, 25)
Using writer As PdfWriter = PdfWriter.GetInstance(document, memoryStream)
document.Open()
document.AddTitle("Generated Report")
document.AddCreationDate()
Dim titleFont As Font = FontFactory.GetFont(FontFactory.HELVETICA_BOLD, 16)
document.Add(New Paragraph("Hello World", titleFont))
document.Add(New Paragraph("This is a PDF document created with iTextSharp"))
Dim table As New PdfPTable(3)
table.AddCell("Header 1")
table.AddCell("Header 2")
table.AddCell("Header 3")
document.Add(table)
document.Close()
Dim pdfBytes As Byte() = memoryStream.ToArray()
Response.Headers.Add("Content-Disposition", "inline; filename=report.pdf")
_logger.LogInformation("PDF generated: {Size} bytes", pdfBytes.Length)
Return File(pdfBytes, "application/pdf")
End Using
End Using
End Using
Catch ex As Exception
_logger.LogError(ex, "Error generating PDF")
Return StatusCode(500, "Error generating PDF document")
End Try
End Function
End ClassJak wygląda wynik działania iTextSharp?
Ten kod ilustruje podstawowe podejście: utwórz instancję Document, dołącz PdfWriter do strumienia, dodaj zawartość za pomocą obiektów elementów i zwróć plik poprzez wynik akcji. Implementacja obsługuje wzorce usuwania zasobów niezbędne w systemach produkcyjnych. W bardziej zaawansowanych scenariuszach można skonfigurować niestandardowe rozmiary papieru, zarządzać orientacją stron lub dodawać numery stron.
Podejście programowe zapewnia precyzyjną kontrolę nad każdym elementem na stronie. Ta precyzja jest przydatna podczas generowania dokumentów o stałym układzie, takich jak faktury, certyfikaty lub formularze, których struktura jest zawsze taka sama. Staje się to jednak utrudnieniem, gdy treść jest dynamiczna lub oparta na szablonie HTML.
Jakie wyzwania wiążą się z konwersją HTML do PDF przy użyciu biblioteki iTextSharp?
Chociaż iTextSharp doskonale sprawdza się w programowym tworzeniu plików PDF, konwersja HTML do PDF stanowi poważne wyzwanie. Wycofana klasa HTMLWorker i jej zamiennik XMLWorker mają ograniczoną obsługę CSS i nie radzą sobie z nowoczesnymi treściami internetowymi, szczególnie w przypadku responsywnego CSS i treści renderowanych przez JavaScript.
// HTML conversion with iTextSharp -- note the CSS limitations
public class HtmlToPdfController : Controller
{
private readonly ILogger<HtmlToPdfController> _logger;
public HtmlToPdfController(ILogger<HtmlToPdfController> logger)
{
_logger = logger;
}
public async Task<ActionResult> ConvertHtmlAsync(string htmlContent)
{
if (string.IsNullOrWhiteSpace(htmlContent))
return BadRequest("HTML content is required");
return await Task.Run(() =>
{
using var stream = new MemoryStream();
using var document = new Document(PageSize.A4);
using var writer = PdfWriter.GetInstance(document, stream);
document.Open();
var cssResolver = XMLWorkerHelper.GetInstance().GetDefaultCssResolver(true);
var fontProvider = new XMLWorkerFontProvider();
var cssAppliers = new CssAppliersImpl(fontProvider);
var htmlContext = new HtmlPipelineContext(cssAppliers);
htmlContext.SetTagFactory(Tags.GetHtmlTagProcessorFactory());
// Pipeline with limited CSS3 support
var pdf = new PdfWriterPipeline(document, writer);
var html = new HtmlPipeline(htmlContext, pdf);
var css = new CssResolverPipeline(cssResolver, html);
var worker = new XMLWorker(css, true);
var parser = new XMLParser(worker);
using var stringReader = new StringReader(htmlContent);
parser.Parse(stringReader);
document.Close();
return File(stream.ToArray(), "application/pdf", "converted.pdf");
});
}
}// HTML conversion with iTextSharp -- note the CSS limitations
public class HtmlToPdfController : Controller
{
private readonly ILogger<HtmlToPdfController> _logger;
public HtmlToPdfController(ILogger<HtmlToPdfController> logger)
{
_logger = logger;
}
public async Task<ActionResult> ConvertHtmlAsync(string htmlContent)
{
if (string.IsNullOrWhiteSpace(htmlContent))
return BadRequest("HTML content is required");
return await Task.Run(() =>
{
using var stream = new MemoryStream();
using var document = new Document(PageSize.A4);
using var writer = PdfWriter.GetInstance(document, stream);
document.Open();
var cssResolver = XMLWorkerHelper.GetInstance().GetDefaultCssResolver(true);
var fontProvider = new XMLWorkerFontProvider();
var cssAppliers = new CssAppliersImpl(fontProvider);
var htmlContext = new HtmlPipelineContext(cssAppliers);
htmlContext.SetTagFactory(Tags.GetHtmlTagProcessorFactory());
// Pipeline with limited CSS3 support
var pdf = new PdfWriterPipeline(document, writer);
var html = new HtmlPipeline(htmlContext, pdf);
var css = new CssResolverPipeline(cssResolver, html);
var worker = new XMLWorker(css, true);
var parser = new XMLParser(worker);
using var stringReader = new StringReader(htmlContent);
parser.Parse(stringReader);
document.Close();
return File(stream.ToArray(), "application/pdf", "converted.pdf");
});
}
}Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports System.Web.Mvc
Imports iTextSharp.text
Imports iTextSharp.text.pdf
Imports iTextSharp.tool.xml
Imports iTextSharp.tool.xml.pipeline.css
Imports iTextSharp.tool.xml.pipeline.html
Imports iTextSharp.tool.xml.pipeline.end
Imports Microsoft.Extensions.Logging
' HTML conversion with iTextSharp -- note the CSS limitations
Public Class HtmlToPdfController
Inherits Controller
Private ReadOnly _logger As ILogger(Of HtmlToPdfController)
Public Sub New(logger As ILogger(Of HtmlToPdfController))
_logger = logger
End Sub
Public Async Function ConvertHtmlAsync(htmlContent As String) As Task(Of ActionResult)
If String.IsNullOrWhiteSpace(htmlContent) Then
Return BadRequest("HTML content is required")
End If
Return Await Task.Run(Function()
Using stream As New MemoryStream()
Using document As New Document(PageSize.A4)
Using writer = PdfWriter.GetInstance(document, stream)
document.Open()
Dim cssResolver = XMLWorkerHelper.GetInstance().GetDefaultCssResolver(True)
Dim fontProvider = New XMLWorkerFontProvider()
Dim cssAppliers = New CssAppliersImpl(fontProvider)
Dim htmlContext = New HtmlPipelineContext(cssAppliers)
htmlContext.SetTagFactory(Tags.GetHtmlTagProcessorFactory())
' Pipeline with limited CSS3 support
Dim pdf = New PdfWriterPipeline(document, writer)
Dim html = New HtmlPipeline(htmlContext, pdf)
Dim css = New CssResolverPipeline(cssResolver, html)
Dim worker = New XMLWorker(css, True)
Dim parser = New XMLParser(worker)
Using stringReader As New StringReader(htmlContent)
parser.Parse(stringReader)
End Using
document.Close()
End Using
End Using
End Using
Return File(stream.ToArray(), "application/pdf", "converted.pdf")
End Function)
End Function
End ClassJak dobrze iTextSharp radzi sobie z renderowaniem HTML?
Ograniczenia stają się widoczne podczas pracy z układami Bootstrap, treściami renderowanymi przez JavaScript lub złożonymi stylami CSS3. Typowe problemy to brakujące czcionki internetowe, nieprawidłowe układy responsywne oraz brak obsługi typów mediów CSS. Ponadto iTextSharp ma trudności z obsługą znaków międzynarodowych i grafiki SVG podczas konwersji treści HTML.
Ograniczenia te nie mają charakteru wyłącznie kosmetycznego. Gdy faktura lub raport przeznaczony dla klienta wyświetla się nieprawidłowo, ponieważ nie pojawia się kolor tła lub siatka się zawala, plik PDF traci swój sens. Dla zespołów zajmujących się utrzymaniem szablonów HTML odtworzenie tego samego układu w modelu obiektowym iTextSharp oznacza konieczność utrzymywania dwóch wersji każdego projektu dokumentu. To powielanie zwiększa koszty i powoduje rozbieżności między widokiem w przeglądarce a plikiem PDF.
Jak generować pliki PDF z HTML przy użyciu silnika Chrome?
IronPDF zmienia sposób generowania plików PDF dzięki wykorzystaniu silnika renderującego Chrome, zapewniając idealną konwersję HTML do PDF. Zainstaluj pakiet IronPDF NuGet, aby rozpocząć pracę w uproszczony sposób w swoim projekcie Visual Studio.
using IronPdf;
// Configure IronPDF in Program.cs (top-level statements, .NET 10)
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSingleton<ChromePdfRenderer>(_ =>
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.MarginTop = 10;
renderer.RenderingOptions.MarginBottom = 10;
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
return renderer;
});
builder.Services.AddMemoryCache();
builder.Services.AddControllersWithViews();
var app = builder.Build();
app.MapControllers();
app.Run();using IronPdf;
// Configure IronPDF in Program.cs (top-level statements, .NET 10)
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSingleton<ChromePdfRenderer>(_ =>
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.MarginTop = 10;
renderer.RenderingOptions.MarginBottom = 10;
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
return renderer;
});
builder.Services.AddMemoryCache();
builder.Services.AddControllersWithViews();
var app = builder.Build();
app.MapControllers();
app.Run();Imports IronPdf
' Configure IronPDF in Program.vb (top-level statements, .NET 10)
Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddSingleton(Function(_)
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.MarginTop = 10
renderer.RenderingOptions.MarginBottom = 10
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
Return renderer
End Function)
builder.Services.AddMemoryCache()
builder.Services.AddControllersWithViews()
Dim app = builder.Build()
app.MapControllers()
app.Run()Jakiej jakości możesz oczekiwać od Chrome Rendering?
ChromePdfRenderer obsługuje złożone układy bez konieczności stosowania ręcznych obejść. Obsługuje CSS Grid, Flexbox, czcionki internetowe z Google Fonts oraz wykresy JavaScript. Biblioteka zarządza również opóźnieniami renderowania treści dynamicznych i obsługuje konfigurację okna wyświetlania dla stron responsywnych. Pełne opcje konfiguracji można znaleźć w opisie opcji renderowania.
Jak przekonwertować widok Razor do formatu PDF w ASP.NET MVC?
IronPDF wyróżnia się możliwościami renderowania widoku dzięki silnikowi Razor Engine. Możesz konwertować całe widoki Razor bezpośrednio do formatu PDF z pełną obsługą ViewBag, ViewData i powiązania modeli. Poniższy przykład renderuje widok faktury po stronie serwera i zwraca go jako plik PDF do pobrania:
// Production-ready Razor view to PDF
public class InvoiceController : Controller
{
private readonly ChromePdfRenderer _pdfRenderer;
private readonly IInvoiceService _invoiceService;
private readonly IRazorViewToStringRenderer _razorRenderer;
public InvoiceController(
ChromePdfRenderer pdfRenderer,
IInvoiceService invoiceService,
IRazorViewToStringRenderer razorRenderer)
{
_pdfRenderer = pdfRenderer;
_invoiceService = invoiceService;
_razorRenderer = razorRenderer;
}
[HttpGet]
public async Task<IActionResult> DownloadInvoiceAsync(int id)
{
var invoice = await _invoiceService.GetInvoiceAsync(id);
if (invoice == null) return NotFound();
var htmlContent = await _razorRenderer.RenderViewToStringAsync(
"Invoice/InvoiceTemplate", invoice);
var renderOptions = new ChromePdfRenderOptions
{
PaperSize = PdfPaperSize.A4,
MarginTop = 20,
MarginBottom = 20,
PrintHtmlBackgrounds = true,
CreatePdfFormsFromHtml = true
};
var pdf = await Task.Run(() =>
_pdfRenderer.RenderHtmlAsPdf(htmlContent, renderOptions));
pdf.MetaData.Title = $"Invoice-{invoice.InvoiceNumber}";
pdf.MetaData.Subject = $"Invoice for {invoice.CustomerName}";
var fileName = $"Invoice-{invoice.InvoiceNumber}-{DateTime.UtcNow:yyyyMMdd}.pdf";
return File(pdf.BinaryData, "application/pdf", fileName);
}
}// Production-ready Razor view to PDF
public class InvoiceController : Controller
{
private readonly ChromePdfRenderer _pdfRenderer;
private readonly IInvoiceService _invoiceService;
private readonly IRazorViewToStringRenderer _razorRenderer;
public InvoiceController(
ChromePdfRenderer pdfRenderer,
IInvoiceService invoiceService,
IRazorViewToStringRenderer razorRenderer)
{
_pdfRenderer = pdfRenderer;
_invoiceService = invoiceService;
_razorRenderer = razorRenderer;
}
[HttpGet]
public async Task<IActionResult> DownloadInvoiceAsync(int id)
{
var invoice = await _invoiceService.GetInvoiceAsync(id);
if (invoice == null) return NotFound();
var htmlContent = await _razorRenderer.RenderViewToStringAsync(
"Invoice/InvoiceTemplate", invoice);
var renderOptions = new ChromePdfRenderOptions
{
PaperSize = PdfPaperSize.A4,
MarginTop = 20,
MarginBottom = 20,
PrintHtmlBackgrounds = true,
CreatePdfFormsFromHtml = true
};
var pdf = await Task.Run(() =>
_pdfRenderer.RenderHtmlAsPdf(htmlContent, renderOptions));
pdf.MetaData.Title = $"Invoice-{invoice.InvoiceNumber}";
pdf.MetaData.Subject = $"Invoice for {invoice.CustomerName}";
var fileName = $"Invoice-{invoice.InvoiceNumber}-{DateTime.UtcNow:yyyyMMdd}.pdf";
return File(pdf.BinaryData, "application/pdf", fileName);
}
}Imports System
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc
' Production-ready Razor view to PDF
Public Class InvoiceController
Inherits Controller
Private ReadOnly _pdfRenderer As ChromePdfRenderer
Private ReadOnly _invoiceService As IInvoiceService
Private ReadOnly _razorRenderer As IRazorViewToStringRenderer
Public Sub New(pdfRenderer As ChromePdfRenderer, invoiceService As IInvoiceService, razorRenderer As IRazorViewToStringRenderer)
_pdfRenderer = pdfRenderer
_invoiceService = invoiceService
_razorRenderer = razorRenderer
End Sub
<HttpGet>
Public Async Function DownloadInvoiceAsync(id As Integer) As Task(Of IActionResult)
Dim invoice = Await _invoiceService.GetInvoiceAsync(id)
If invoice Is Nothing Then Return NotFound()
Dim htmlContent = Await _razorRenderer.RenderViewToStringAsync("Invoice/InvoiceTemplate", invoice)
Dim renderOptions As New ChromePdfRenderOptions With {
.PaperSize = PdfPaperSize.A4,
.MarginTop = 20,
.MarginBottom = 20,
.PrintHtmlBackgrounds = True,
.CreatePdfFormsFromHtml = True
}
Dim pdf = Await Task.Run(Function() _pdfRenderer.RenderHtmlAsPdf(htmlContent, renderOptions))
pdf.MetaData.Title = $"Invoice-{invoice.InvoiceNumber}"
pdf.MetaData.Subject = $"Invoice for {invoice.CustomerName}"
Dim fileName = $"Invoice-{invoice.InvoiceNumber}-{DateTime.UtcNow:yyyyMMdd}.pdf"
Return File(pdf.BinaryData, "application/pdf", fileName)
End Function
End ClassJak konwersja widoku Razor wypada w porównaniu z ręcznym tworzeniem?
Porównaj to z podejściem iTextSharp, które wymaga ręcznego budowania struktury dokumentu w kodzie. Każdy nagłówek, komórka tabeli, wybór czcionki i dostosowanie odstępów musi być wyrażone jako obiekt C#. Nie ma szablonu HTML, który można by wyświetlić w przeglądarce; Każda zmiana wymaga cyklu kompilacji i sprawdzenia w odniesieniu do pliku PDF.
Integracja IronPDF z Razor pozwala na ponowne wykorzystanie istniejących widoków Razor, plików HTML lub ciągów HTML do generowania plików PDF. Można również pracować z plikami ZIP w formacie HTML lub wdrożyć konfiguracje podstawowych adresów URL do ładowania zasobów. Poradnik dotyczący konwersji CSHTML do PDF zawiera szczegółowy opis całego procesu renderowania Razor, w tym konfiguracji wstrzykiwania zależności.
Jak radzisz sobie z pobieraniem plików i strumieniowaniem w celu utworzenia pliku PDF?
Obie biblioteki obsługują różne metody generowania plików PDF w aplikacjach internetowych. IronPDF oferuje dodatkowe funkcje, takie jak kompresja plików PDF, linearyzacja w celu szybkiego przeglądania w sieci oraz rasteryzacja do obrazów. Poniższy kontroler strumieniowania pokazuje, jak obsługiwać duże pliki PDF z wykorzystaniem buforowania i obsługi żądań zakresowych:
// Streaming controller for large PDFs
public class StreamingPdfController : Controller
{
private readonly ChromePdfRenderer _ironPdfRenderer;
private readonly IMemoryCache _cache;
public StreamingPdfController(ChromePdfRenderer ironPdfRenderer, IMemoryCache cache)
{
_ironPdfRenderer = ironPdfRenderer;
_cache = cache;
}
[HttpGet]
public async Task<IActionResult> StreamLargePdf(string reportId)
{
var cacheKey = $"pdf_stream_{reportId}";
if (_cache.TryGetValue<byte[]>(cacheKey, out var cachedPdf))
return File(cachedPdf, "application/pdf", $"report_{reportId}.pdf");
Response.ContentType = "application/pdf";
Response.Headers.Add("Content-Disposition",
$"attachment; filename=large_report_{reportId}.pdf");
await using var stream = Response.BodyWriter.AsStream();
var html = await GenerateLargeHtmlReport(reportId);
var pdf = _ironPdfRenderer.RenderHtmlAsPdf(html);
pdf.SaveAs(stream);
if (pdf.BinaryData.Length < 10_000_000)
_cache.Set(cacheKey, pdf.BinaryData, TimeSpan.FromMinutes(30));
return new EmptyResult();
}
[HttpGet]
public IActionResult DownloadWithRangeSupport(string documentId)
{
var pdfBytes = GetPdfBytes(documentId);
return File(pdfBytes, "application/pdf",
$"document_{documentId}.pdf", enableRangeProcessing: true);
}
}// Streaming controller for large PDFs
public class StreamingPdfController : Controller
{
private readonly ChromePdfRenderer _ironPdfRenderer;
private readonly IMemoryCache _cache;
public StreamingPdfController(ChromePdfRenderer ironPdfRenderer, IMemoryCache cache)
{
_ironPdfRenderer = ironPdfRenderer;
_cache = cache;
}
[HttpGet]
public async Task<IActionResult> StreamLargePdf(string reportId)
{
var cacheKey = $"pdf_stream_{reportId}";
if (_cache.TryGetValue<byte[]>(cacheKey, out var cachedPdf))
return File(cachedPdf, "application/pdf", $"report_{reportId}.pdf");
Response.ContentType = "application/pdf";
Response.Headers.Add("Content-Disposition",
$"attachment; filename=large_report_{reportId}.pdf");
await using var stream = Response.BodyWriter.AsStream();
var html = await GenerateLargeHtmlReport(reportId);
var pdf = _ironPdfRenderer.RenderHtmlAsPdf(html);
pdf.SaveAs(stream);
if (pdf.BinaryData.Length < 10_000_000)
_cache.Set(cacheKey, pdf.BinaryData, TimeSpan.FromMinutes(30));
return new EmptyResult();
}
[HttpGet]
public IActionResult DownloadWithRangeSupport(string documentId)
{
var pdfBytes = GetPdfBytes(documentId);
return File(pdfBytes, "application/pdf",
$"document_{documentId}.pdf", enableRangeProcessing: true);
}
}Imports System
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.Extensions.Caching.Memory
' Streaming controller for large PDFs
Public Class StreamingPdfController
Inherits Controller
Private ReadOnly _ironPdfRenderer As ChromePdfRenderer
Private ReadOnly _cache As IMemoryCache
Public Sub New(ironPdfRenderer As ChromePdfRenderer, cache As IMemoryCache)
_ironPdfRenderer = ironPdfRenderer
_cache = cache
End Sub
<HttpGet>
Public Async Function StreamLargePdf(reportId As String) As Task(Of IActionResult)
Dim cacheKey = $"pdf_stream_{reportId}"
Dim cachedPdf As Byte() = Nothing
If _cache.TryGetValue(cacheKey, cachedPdf) Then
Return File(cachedPdf, "application/pdf", $"report_{reportId}.pdf")
End If
Response.ContentType = "application/pdf"
Response.Headers.Add("Content-Disposition", $"attachment; filename=large_report_{reportId}.pdf")
Await Using stream = Response.BodyWriter.AsStream()
Dim html = Await GenerateLargeHtmlReport(reportId)
Dim pdf = _ironPdfRenderer.RenderHtmlAsPdf(html)
pdf.SaveAs(stream)
If pdf.BinaryData.Length < 10000000 Then
_cache.Set(cacheKey, pdf.BinaryData, TimeSpan.FromMinutes(30))
End If
End Using
Return New EmptyResult()
End Function
<HttpGet>
Public Function DownloadWithRangeSupport(documentId As String) As IActionResult
Dim pdfBytes = GetPdfBytes(documentId)
Return File(pdfBytes, "application/pdf", $"document_{documentId}.pdf", enableRangeProcessing:=True)
End Function
End ClassW zaawansowanych scenariuszach IronPDF obsługuje równoległe generowanie plików PDF, przetwarzanie wielowątkowe oraz operacje wsadowe. Możesz wdrożyć niestandardowe logowanie, obsługiwać uwierzytelnianie sieciowe, pracować z plikami cookie oraz dodawać nagłówki żądań HTTP w celu bezpiecznego generowania dokumentów.
Jak wypadają te dwie biblioteki w bezpośrednim porównaniu?
Poniższa tabela podsumowuje kluczowe różnice między iTextSharp a IronPDF for .NET w projektach ASP.NET MVC:
| Funkcja | iTextSharp | IronPDF |
|---|---|---|
| Renderowanie HTML do PDF | Ograniczone (XMLWorker, brak nowoczesnego CSS3) | Pełny silnik Chrome (CSS3, JS, Flexbox) |
| Obsługa Razor / CSHTML | Brak natywnej obsługi | Wbudowane renderowanie widoków Razor |
| Bezpieczeństwo wątków | Wymaga ręcznego zablokowania | Domyślnie bezpieczne dla wątków |
| Async API | Brak natywnej obsługi asynchroniczności | Pełna obsługa asynchroniczna |
| Linux / Docker | Obsługiwane | Obsługiwane |
| Rodzaj licencji | AGPL (open source) lub komercyjne | Wersja komercyjna z bezpłatną wersją próbną |
| Podpisy cyfrowe | Tak | Tak |
| Formularze PDF | Tak (ręcznie) | Tak (z elementów formularza HTML) |
iTextSharp oferuje szczegółową kontrolę nad programowym tworzeniem plików PDF, co czyni go praktycznym rozwiązaniem, gdy struktura dokumentu jest prosta i stała. IronPDF to lepszy wybór, gdy chcesz przekonwertować szablony HTML lub widoki Razor na profesjonalne dokumenty PDF z precyzyjnym renderowaniem, pełną obsługą CSS3 i możliwością wykonywania kodu JavaScript.
W przypadku produkcyjnych aplikacji ASP.NET IronPDF zapewnia doskonałą obsługę asynchroniczną oraz integrację z nowoczesnymi wzorcami .NET, w tym wstrzykiwaniem zależności i potokami oprogramowania pośredniczącego. Możliwość renderowania widoków Razor, obsługa podpisów cyfrowych oraz obsługa złożonych układów sprawiają, że jest to preferowany wybór dla aplikacji Enterprise. Biblioteka obsługuje również aplikacje Blazor Server oraz zgodność z formatem PDF/A dla dokumentów archiwalnych.
A co z licencjami i kwestiami związanymi z projektem?
Biblioteka iTextSharp korzysta z licencji AGPL w swojej wersji open source, co wymaga, aby kod aplikacji również był open source. Licencje komercyjne na projekty własnościowe są dostępne w iText Group. Ta kwestia licencyjna jest szczególnie ważna w przypadku produktów SaaS lub wewnętrznych narzędzi korporacyjnych, w których nie można publikować kodu źródłowego.
IronPDF stosuje model licencji komercyjnej z bezpłatną wersją próbną do celów programistycznych i testowych. Licencje są dostosowane do środowiska wdrożeniowego: programista, pojedynczy serwer lub nieograniczone opcje wdrożenia. Wdrażając którekolwiek z tych rozwiązań, należy wziąć pod uwagę scenariusze wdrożeniowe, w tym środowiska Docker, Azure i Linux.
Kwestie związane z wydajnością w scenariuszach o dużym natężeniu ruchu obejmują wdrażanie operacji asynchronicznych, właściwe zarządzanie pamięcią oraz strategie buforowania. Silnik Chrome firmy IronPDF zapewnia doskonałą wydajność przy renderowaniu złożonego kodu HTML, natomiast iTextSharp może być bardziej wydajny w przypadku prostego programowego generowania plików PDF bez udziału kodu HTML. W przypadku aplikacji generujących setki plików PDF na minutę, testy porównawcze w warunkach realistycznego obciążenia są najbardziej wiarygodnym wskaźnikiem tego, która biblioteka najlepiej pasuje do Twojej infrastruktury.
Migracja z iTextSharp do IronPDF jest prosta w przypadku większości projektów MVC. Główną zmianą jest zastąpienie kodu służącego do ręcznego tworzenia dokumentów szablonem HTML renderowanym przez silnik Chrome. IronPDF zapewnia obszerną dokumentację, przykłady kodu oraz wsparcie inżynieryjne, aby przejście przebiegło płynnie.
Jakie są Twoje kolejne kroki?
W przypadku nowych projektów wymagających konwersji HTML do PDF z obsługą nowoczesnych standardów internetowych, IronPDF oferuje wyraźną przewagę dzięki renderowaniu opartemu na przeglądarce Chrome. Starsze projekty, które już wykorzystują iTextSharp do podstawowego tworzenia plików PDF, mogą kontynuować dotychczasową implementację, chyba że wymagana będzie dokładność renderowania HTML.
Zacznij od bezpłatnej wersji próbnej IronPDF i przetestuj ją bezpośrednio z istniejącymi widokami Razor lub szablonami HTML. Zapoznaj się z pełną dokumentacją i Dokumentacją API, aby przekonać się, jak szybko przebiega integracja. Jeśli masz pytania dotyczące migracji istniejącego projektu opartego na iTextSharp lub potrzebujesz wskazówek dotyczących obsługi strumienia pamięci PDF i zgodności z PDF/A, zespół wsparcia technicznego chętnie Ci pomoże.
Aby uzyskać szerszy obraz porównania IronPDF z rodziną produktów iText, zapoznaj się ze specjalną stroną porównawczą iText vs. IronPDF.
Często Zadawane Pytania
Jaka jest główna zaleta używania IronPDF nad iTextSharp do generowania PDF w ASP.NET MVC?
IronPDF oferuje lepsze możliwości renderowania HTML w porównaniu do iTextSharp, co ułatwia generowanie wysokiej jakości PDF z treści webowych.
Czy mogę używać IronPDF do generowania faktur w aplikacji ASP.NET MVC?
Tak, IronPDF jest odpowiedni do generowania faktur i innych dokumentów PDF w aplikacjach ASP.NET MVC dzięki funkcjom konwersji HTML do PDF.
Jak wdrożenie IronPDF porównuje się do iTextSharp pod względem łatwości użycia?
IronPDF uważany jest zazwyczaj za łatwiejszy do wdrożenia niż iTextSharp, szczególnie dla deweloperów chcących szybko zintegrować funkcje generowania PDF bez obszernego ustawiania.
Czy IronPDF obsługuje konwersję złożonych stron webowych do PDF w ASP.NET MVC?
Tak, IronPDF doskonale radzi sobie z konwersją złożonych stron webowych do PDF, dzięki zaawansowanemu mechanizmowi renderowania HTML, który dokładnie odwzorowuje treść webową.
Czy IronPDF jest dobrym wyborem do generowania treści do pobrania z aplikacji ASP.NET MVC?
IronPDF jest doskonałym wyborem do generowania treści do pobrania z uwagi na zdolność do tworzenia wysokiej jakości PDF z szerokiego zakresu treści webowych.
Jakie scenariusze są idealne do użycia IronPDF w generowaniu PDF?
IronPDF jest idealny do scenariuszy wymagających wysokiej jakości konwersji HTML na PDF, takich jak generowanie raportów, faktur lub dokumentów do pobrania z treści webowych.
Czy IronPDF oferuje lepsze wsparcie dla nowoczesnych technologii webowych w porównaniu do iTextSharp?
Tak, IronPDF jest zaprojektowany do pracy z nowoczesnymi technologiami webowymi, zapewniając lepszą kompatybilność i dokładność w renderowaniu w porównaniu do iTextSharp.
Jak IronPDF obsługuje obrazy i CSS podczas generowania PDF?
IronPDF obsługuje obrazy i CSS z wysoką zgodnością, zapewniając, że wynikowy PDF dokładnie odpowiada oryginalnej treści HTML, włączając w to złożone układy i style.
Czy IronPDF można łatwo zintegrować z istniejącymi projektami ASP.NET MVC?
Tak, IronPDF można łatwo zintegrować z istniejącymi projektami ASP.NET MVC, oferując przejrzyste API dla deweloperów do wdrożenia funkcji generowania PDF.
Jakie są główne zastosowania IronPDF w aplikacjach ASP.NET MVC?
Główne zastosowania IronPDF w aplikacjach ASP.NET MVC to generowanie raportów, faktur i innych dokumentów, gdzie kluczowa jest dokładna konwersja HTML na PDF.
Rozpocznij za DARMO
Rozpocznij za DARMO
Zarezerwuj darmowe Demo na żywo
Nie wymaga karty kredytowej ani tworzenia konta
