Bester PDF-Reader für iPhone (Vergleich von kostenlosen und kostenpflichtigen Tools)
Full Comparison
Looking for a detailed feature-by-feature breakdown? See how IronPDF stacks up against Itext on pricing, HTML support, and licensing.
IronPDF bietet eine hervorragende HTML-zu-PDF-Konvertierung mit vollständiger CSS3- und JavaScript Unterstützung unter Verwendung von Chrome-Rendering. Im Gegensatz dazu bietet iText eine programmatische PDF-Erstellung, kämpft jedoch mit moderner HTML-Konvertierung, was IronPDF zur besseren Wahl für ASP.NET MVC-Anwendungen macht, die webstandardkonforme PDFs erfordern.
Die Erstellung von PDF-Dokumenten in ASP.NET MVC-Anwendungen ist eine häufige Anforderung für die Erstellung von Berichten, Rechnungen und herunterladbaren Inhalten. Während iText über Jahre hinweg eine beliebte Wahl war, bietet IronPDF eine moderne Alternative mit überlegenen HTML-Rendering-Fähigkeiten. Dieser Artikel untersucht beide Ansätze, um Ihnen zu helfen, eine fundierte Entscheidung für Ihre Anforderungen an die PDF-Generierung mit .NET zu treffen.
Beide Bibliotheken lösen das gleiche Kernproblem – die Generierung von PDFs im .NET Webkontext – verfolgen dabei aber grundlegend unterschiedliche Ansätze. iText erstellt PDFs programmatisch durch ein Objektmodell, während IronPDF HTML zu PDF unter Verwendung einer vollständigen Chrome-Rendering-Engine umwandelt. Dieses Verständnis des architektonischen Unterschieds ist der Schlüssel zur Auswahl des richtigen Werkzeugs. Das ASP.NET MVC-Framework von Microsoft unterstützt beide Integrationsmuster, und jede der beiden Bibliotheken kann in die Standard-Controller-Aktions-Pipeline eingebunden werden.
Wie installiert man die einzelnen Bibliotheken?
Bevor Sie mit dem Programmieren beginnen, müssen Sie jede Bibliothek in Ihr Projekt einbinden. NuGet ist der Standard-Paketmanager for .NET und handhabt beide Installationsarten problemlos. Für iText installieren Sie das Legacy-Paket über NuGet:
dotnet add package iTextSharpdotnet add package iTextSharpIronPDF muss zusätzlich über NuGet installiert werden:
dotnet add package IronPdf
IronPDF integriert die Chrome-Rendering-Engine in das Paket, sodass keine zusätzliche Browserinstallation auf Ihrem Server erforderlich ist. Die Bibliothek unterstützt Windows, Linux, macOS und Containerumgebungen standardmäßig. Nach der Installation fügen Sie Ihren IronPDF -Lizenzschlüssel beim Start der Anwendung hinzu.
Wie erzeugt man PDF mit iText in MVC?
Um PDF-Dateien mit iText in Ihrer ASP.NET MVC-Anwendung zu erzeugen, installieren Sie zuerst die Bibliothek über NuGet. Die iText-Bibliothek bietet niedrigstufige Kontrolle über die PDF-Erstellung über ihre Document-Klasse und das Objektmodell.
Der folgende Code zeigt eine produktionsreife Implementierung zur Erstellung von PDFs mit iText in einem MVC-Controller:
// 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 ClassWie sieht der iText-Ausgang aus?
Dieser Code demonstriert den grundlegenden Ansatz: Erstellen Sie eine Document-Instanz, verbinden Sie eine PdfWriter mit einem Stream, fügen Sie Inhalte über Elementobjekte hinzu und geben Sie die Datei über ein Action-Result zurück. Die Implementierung berücksichtigt Ressourcenentsorgungsmuster, die für Produktionssysteme unerlässlich sind. Für komplexere Anwendungsfälle können Sie benutzerdefinierte Papierformate konfigurieren, die Seitenausrichtung verwalten oder Seitenzahlen hinzufügen.
Der programmatische Ansatz ermöglicht Ihnen die detaillierte Kontrolle über jedes einzelne Element auf der Seite. Diese Präzision ist nützlich beim Erstellen von Dokumenten mit festem Layout, wie z. B. Rechnungen, Zertifikaten oder Formularen, deren Struktur immer gleich ist. Es wird jedoch zur Belastung, sobald der Inhalt dynamisch ist oder durch eine HTML-Vorlage gesteuert wird.
Welche Herausforderungen gibt es bei der HTML-zu-PDF-Konvertierung mit der iText-Bibliothek?
Obwohl iText bei der programmatischen PDF-Erstellung glänzt, stellt die Umwandlung von HTML zu PDF erhebliche Herausforderungen dar. Die veraltete HTMLWorker-Klasse und ihr Ersatz XMLWorker haben eingeschränkte CSS-Unterstützung und Schwierigkeiten mit modernem Webinhalt, insbesondere bei der Arbeit mit responsive CSS und JavaScript-gerenderten Inhalten.
// 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 ClassWie gut beherrscht iText HTML-Rendering?
Die Grenzen werden bei der Arbeit mit Bootstrap-Layouts, JavaScript-gerenderten Inhalten oder komplexem CSS3-Styling deutlich. Häufige Probleme umfassen fehlende Web-Schriftarten, fehlerhafte responsive Layouts und fehlende Unterstützung für CSS Medientypen. Darüber hinaus kämpft iText mit internationalen Sprachzeichen und SVG-Grafiken bei der Konvertierung von HTML-Inhalten.
Diese Einschränkungen sind nicht nur kosmetischer Natur. Wenn eine Rechnung oder ein Bericht, der für den Kunden bestimmt ist, falsch dargestellt wird, weil eine Hintergrundfarbe fehlt oder ein Raster zusammenbricht, verliert die PDF-Datei ihren Zweck. Für Teams, die HTML-Vorlagen pflegen, bedeutet das Wiederaufbau desselben Layouts im iText-Objektmodell, dass zwei Versionen jedes Dokumentendesigns gepflegt werden müssen. Diese Duplizierung verursacht zusätzliche Kosten und führt zu Abweichungen zwischen der Webansicht und der PDF-Ausgabe.
Wie generiert man PDFs aus HTML mithilfe der Chrome-Engine?
IronPDF wandelt die PDF-Generierung mit Hilfe einer Chrome-Rendering-Engine um und gewährleistet so eine pixelgenaue Konvertierung von HTML in PDF. Installieren Sie das IronPDF NuGet Paket, um mit einem vereinfachten Ansatz in Ihrem Visual Studio-Projekt zu beginnen.
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()Welche Qualität können Sie von Chrome-Rendering erwarten?
Der ChromePdfRenderer behandelt komplexe Layouts ohne manuelle Workarounds. Es unterstützt CSS Grid, Flexbox, Webfonts von Google Fonts und JavaScript Diagramme. Die Bibliothek verwaltet außerdem Rendering-Verzögerungen für dynamische Inhalte und unterstützt die Viewport-Konfiguration für responsive Seiten. Die vollständigen Konfigurationsoptionen finden Sie in der Referenz zu den Rendering-Optionen .
Wie konvertiert man eine Razor Ansicht in ASP.NET MVC in ein PDF?
IronPDF zeichnet sich durch seine Razor Engine-Ansichtsdarstellungsfunktionen aus. Sie können ganze Razor Ansichten direkt in PDF konvertieren, wobei ViewBag, ViewData und Modellbindung vollständig unterstützt werden. Das folgende Beispiel rendert eine Rechnungsansicht serverseitig und gibt sie als herunterladbare PDF-Datei zurück:
// 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 ClassWie vergleicht sich die Razor View-Konvertierung mit der manuellen Erstellung?
Vergleichen Sie dies mit dem Ansatz von iText, bei dem das Dokumentenstruktur manuell im Code aufgebaut werden muss. Jede Überschrift, Tabellenzelle, Schriftart und Abstandseinstellung muss als C#-Objekt ausgedrückt werden. Es gibt keine HTML-Vorlage, die im Browser durchlaufen werden könnte; Jede Änderung erfordert einen Kompilierungs- und Prüfzyklus anhand der PDF-Ausgabe.
Die Razor Integration von IronPDF ermöglicht die Wiederverwendung vorhandener Razor Ansichten, HTML-Dateien oder HTML-Zeichenketten zur PDF-Generierung. Sie können auch mit HTML-ZIP-Dateien arbeiten oder Basis-URL-Konfigurationen für das Laden von Assets implementieren. Die Anleitung zur Konvertierung von CSHTML in PDF beschreibt das gesamte Razor -Rendering-Muster einschließlich der Einrichtung der Abhängigkeitsinjektion.
Wie handhabt man Dateidownloads und Streaming zur Erstellung einer PDF-Datei?
Beide Bibliotheken unterstützen verschiedene Ausgabemethoden für PDF-Dateien in Webanwendungen. IronPDF bietet zusätzliche Funktionen wie PDF-Komprimierung, Linearisierung für schnelle Webanzeige und Rasterisierung von Bildern. Der untenstehende Streaming-Controller demonstriert, wie große PDFs mit Unterstützung für Caching und Bereichsanforderungen verarbeitet werden können:
// 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 ClassFür fortgeschrittene Anwendungsfälle unterstützt IronPDF die parallele PDF-Generierung, die Verarbeitung mit mehreren Threads und Stapelverarbeitungen . Sie können benutzerdefinierte Protokollierung implementieren, die Netzwerkauthentifizierung handhaben, mit Cookies arbeiten und HTTP-Anforderungsheader für die sichere Dokumentenerstellung hinzufügen.
Wie schneiden die beiden Bibliotheken im direkten Vergleich ab?
Die Tabelle unten fasst die wichtigsten Unterschiede zwischen iText und IronPDF für ASP.NET MVC Projekte zusammen:
| Merkmal | iText | IronPDF |
|---|---|---|
| HTML-zu-PDF-Rendering | Eingeschränkt (XMLWorker, kein modernes CSS3) | Vollständige Chrome-Engine (CSS3, JS, Flexbox) |
| Razor /CSHTML-Unterstützung | Keine native Unterstützung | Integrierte Razor -Ansichtsdarstellung |
| Threadsicherheit | Erfordert manuelle Verriegelung | Standardmäßig threadsicher |
| Asynchrone API | Keine native asynchrone Funktion | Vollständige Unterstützung für asynchrone Synchronisierung |
| Linux / Docker | Unterstützt | Unterstützt |
| Lizenztyp | AGPL (Open Source) oder kommerziell | Kommerziell mit kostenloser Testversion |
| Digitale Signaturen | Ja | Ja |
| PDF-Formulare | Ja (manuell) | Ja (aus HTML-Formularelementen) |
iText bietet detaillierte Kontrolle für programmatische PDF-Erstellung, was es zu einer brauchbaren Option macht, wenn die Dokumentenstruktur einfach und festgelegt ist. IronPDF ist die bessere Wahl, wenn Sie HTML-Vorlagen oder Razor Ansichten in Professional PDF-Dokumente mit präziser Darstellung , vollständiger CSS3-Unterstützung und JavaScript Ausführung konvertieren müssen.
Für produktive ASP.NET Anwendungen bietet IronPDF überlegene Unterstützung für asynchrone Prozesse und eine hervorragende Integration mit modernen .NET Mustern, einschließlich Dependency Injection und Middleware-Pipelines. Dank seiner Fähigkeit, Razor Ansichten darzustellen, digitale Signaturen zu unterstützen und komplexe Layouts zu verarbeiten, ist es die bevorzugte Wahl für Enterprise . Die Bibliothek unterstützt außerdem Blazor Server-Anwendungen und PDF/A-Konformität für Archivdokumente.
Was ist mit der Lizenzierung und dem Projekt zu beachten?
Die iText-Bibliothek verwendet eine AGPL-Lizenz für ihre Open-Source-Version, die erfordert, dass auch Ihr Anwendungscode Open-Source ist. Kommerzielle Lizenzen für proprietäre Projekte sind von der iText Group erhältlich. Diese Lizenzüberlegung ist besonders wichtig für SaaS-Produkte oder interne Enterprise , bei denen der Quellcode nicht veröffentlicht werden darf.
IronPDF verwendet ein kommerzielles Lizenzmodell mit einer kostenlosen Testphase für Entwicklung und Tests. Die Lizenzen skalieren je nach Bereitstellungsumgebung: Entwickler-, Einzelserver- oder unbegrenzte Bereitstellungsoptionen. Bei der Implementierung beider Lösungen sollten Bereitstellungsszenarien wie Docker-, Azure- und Linux-Umgebungen berücksichtigt werden.
Bei Szenarien mit hohem Datenverkehr sollten zur Leistungsoptimierung asynchrone Operationen, ein angemessenes Speichermanagement und Caching-Strategien eingesetzt werden. IronPDFs Chrome-Engine bietet überlegene Leistung für komplexe HTML-Renderings, während iText effizienter sein kann für einfache programmatische PDF-Erstellung ohne HTML. Bei Anwendungen, die Hunderte von PDFs pro Minute generieren, ist ein Benchmark unter realistischer Last der zuverlässigste Weg, um die passende Bibliothek für Ihre Infrastruktur zu finden.
Die Migration von iText zu IronPDF ist für die meisten MVC-Projekte simpel. Die wichtigste Änderung besteht darin, den manuellen Code zur Dokumentenerstellung durch eine HTML-Vorlage zu ersetzen, die von der Chrome-Engine gerendert wird. IronPDF bietet umfassende Dokumentation , Codebeispiele und technischen Support , um einen reibungslosen Übergang zu gewährleisten.
Was sind Ihre nächsten Schritte?
Für neue Projekte, die eine HTML-zu-PDF-Konvertierung mit Unterstützung moderner Webstandards erfordern, bietet IronPDF mit seinem Chrome-basierten Rendering einen klaren Vorteil. Legacy-Projekte, die iText bereits für grundlegende PDF-Erstellung verwenden, können weiterhin ihre bestehende Implementierung verwenden, es sei denn, HTML-Rendering-Genauigkeit wird zur Anforderung.
Beginnen Sie mit der kostenlosen Testversion von IronPDF und testen Sie es direkt mit Ihren bestehenden Razor Ansichten oder HTML-Vorlagen. In der vollständigen Dokumentation und der API-Referenz erfahren Sie, wie schnell die Integration vonstatten geht. Wenn Sie Fragen zur Migration eines bestehenden iText-basierten Projekts haben oder Anleitungen zur PDF-Speicherstromverwaltung und PDF/A-Konformität benötigen, steht das Support-Team zur Verfügung, um zu helfen.
Einen umfassenderen Überblick darüber, wie sich IronPDF im Vergleich zur iText-Produktfamilie schlägt, finden Sie auf der speziellen Vergleichsseite iText vs. IronPDF .
Häufig gestellte Fragen
Was ist der Hauptvorteil der Verwendung von IronPDF gegenüber iTextSharp für die PDF-Erzeugung in ASP.NET MVC?
IronPDF bietet im Vergleich zu iTextSharp überlegene HTML-Rendering-Funktionen, die es einfacher machen, hochwertige PDFs aus Webinhalten zu generieren.
Kann ich IronPDF verwenden, um Rechnungen in einer ASP.NET MVC-Anwendung zu erstellen?
Ja, IronPDF eignet sich gut zur Erstellung von Rechnungen und anderen PDF-Dokumenten in ASP.NET MVC-Anwendungen aufgrund seiner HTML-zu-PDF-Konvertierungsfunktionen.
Wie ist die Implementierung von IronPDF im Vergleich zu iTextSharp in Bezug auf die Benutzerfreundlichkeit?
IronPDF wird im Allgemeinen als einfacher zu implementieren angesehen als iTextSharp, insbesondere für Entwickler, die schnell und ohne umfangreiche Einrichtung PDF-Erzeugungsfunktionen integrieren möchten.
Unterstützt IronPDF die Konvertierung komplexer Webseiten in PDF in ASP.NET MVC?
IronPDF ist dank seiner fortschrittlichen HTML-Rendering-Engine, die den Webinhalt genau wiedergibt, hervorragend für die Konvertierung komplexer Webseiten in PDF geeignet.
Ist IronPDF eine gute Wahl für die Generierung herunterladbarer Inhalte aus einer ASP.NET MVC-Anwendung?
IronPDF eignet sich hervorragend für die Erstellung von herunterladbaren Inhalten, da es in der Lage ist, aus einer Vielzahl von Webinhalten hochwertige PDFs zu erstellen.
Welche Szenarien eignen sich für den Einsatz von IronPDF bei der PDF-Erstellung?
IronPDF ist ideal für Szenarien, die eine qualitativ hochwertige HTML-zu-PDF-Konvertierung erfordern, wie z. B. die Erstellung von Berichten, Rechnungen oder herunterladbaren Dokumenten aus Webinhalten.
Bietet IronPDF im Vergleich zu iTextSharp eine bessere Unterstützung für moderne Webtechnologien?
Ja, IronPDF ist darauf ausgelegt, mit modernen Webtechnologien zu arbeiten und bietet im Vergleich zu iTextSharp eine bessere Kompatibilität und Rendering-Genauigkeit.
Wie behandelt IronPDF Bilder und CSS bei der Erstellung von PDFs?
IronPDF verarbeitet Bilder und CSS mit hoher Wiedergabetreue und stellt sicher, dass die resultierende PDF-Datei dem ursprünglichen HTML-Inhalt genau entspricht, einschließlich komplexer Layouts und Stile.
Kann IronPDF problemlos in bestehende ASP.NET MVC-Projekte integriert werden?
Ja, IronPDF kann problemlos in bestehende ASP.NET MVC-Projekte integriert werden und bietet Entwicklern eine unkomplizierte API zur Implementierung von PDF-Generierungsfunktionen.
Was sind die wichtigsten Anwendungsfälle für den Einsatz von IronPDF in ASP.NET MVC-Anwendungen?
Die Hauptanwendungsfälle für IronPDF in ASP.NET MVC-Anwendungen sind die Erstellung von Berichten, Rechnungen und anderen Dokumenten, bei denen eine genaue HTML-zu-PDF-Konvertierung entscheidend ist.
Kostenlos loslegen
Kostenlos loslegen
Kostenlose Live-Demo buchen
