Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. IronPDF nutzen
  4. PDF Viewer in Asp .NET Web Application
IRONPDF NUTZEN

PDF-Viewer in ASP.NET Core: PDFs inline mit C# anzeigen

Curtis Chau
Curtis Chau
Aktualisiert:

Die Integration eines PDF-Viewers in eine ASP.NET Core Anwendung ist einfacher als die meisten Entwickler erwarten. Durch die serverseitige Generierung von PDFs und deren Rückgabe mit dem korrekten MIME-Typ können Dokumente direkt in jedem modernen Browser angezeigt werden – ohne Plugins, ohne dass Adobe Acrobat Reader erforderlich ist. IronPDF übernimmt das Rendering über seine Chrome-basierte Engine und wandelt HTML, CSS und JavaScript in hochauflösende PDFs um, die direkt im integrierten Viewer des Browsers angezeigt werden.

Dieses Tutorial führt Sie durch alle wichtigen Szenarien: Anzeigen von aus HTML-Zeichenketten generierten PDFs, Rendern von Live-URLs, Konvertieren von Razor Ansichten, Streamen großer Dateien und die Integration all dessen in einen ASP.NET Core MVC-Controller. Die Codebeispiele sind auf .NET 10 ausgerichtet und verwenden gegebenenfalls Anweisungen auf oberster Ebene.

Wie funktioniert die browserbasierte PDF-Anzeige in ASP.NET?

Moderne Browser werden mit einem integrierten PDF-Viewer ausgeliefert. Wenn ein Server mit dem Header Content-Type: application/pdf antwortet, rendert der Browser das Dokument direkt im Browser, anstatt einen Dateidownload auszulösen. Der Schlüssel liegt in der Kombination dieses Headers mit Content-Disposition: inline.

Serverseitig besteht Ihre Aufgabe darin, eine gültige PDF-Binärdatei zu erzeugen und diese über FileResult zurückzugeben. Der Browser übernimmt Seitennavigation, Zoom, Textauswahl, Suche, Drucken und Herunterladen ohne zusätzlichen UI-Code Ihrerseits.

IronPDF fügt sich nahtlos in dieses Muster ein. Seine Klasse ChromePdfRenderer wandelt HTML (oder eine Live-URL) in ein PDF-Binärformat um, und dieses Binärformat wird direkt an den ASP.NET-Helper File() übergeben. Das Ergebnis ist ein vollwertiger Dokumentenbetrachter, der auf Chrome, Firefox, Edge und Safari funktioniert.

Moderne Browser implementieren die W3C-PDF-Rendering-Spezifikation über ihre nativen Viewer-Engines, was bedeutet, dass jedes konforme PDF, das Ihr Server zurückgibt, ohne zusätzliche Konfiguration korrekt angezeigt wird. Die Ausgabe von IronPDF ist vollständig standardkonform, sodass Sie sich auf eine konsistente Darstellung über verschiedene Browserversionen hinweg verlassen können.

Für containerisierte Bereitstellungen stellt IronPDF offizielle Docker-Images bereit, die die Chromium-Abhängigkeiten vorkonfigurieren, sodass Sie Chrome nicht manuell auf jedem Knoten installieren müssen. Sowohl Linux- als auch Windows-Container werden unterstützt. Falls Sie die PDF-Generierung unabhängig skalieren müssen, ermöglicht Ihnen das IronPDF Engine Docker-Image, den Rendering-Prozess als separaten Microservice auszuführen.

Wie installiert man IronPDF in einem ASP.NET Core -Projekt?

Öffnen Sie Ihr ASP.NET Core Projekt in Visual Studio und installieren Sie anschließend IronPDF über die NuGet -Paket-Manager-Konsole:

Install-Package IronPdf
Install-Package IronPdf
SHELL

Oder verwenden Sie die .NET-CLI:

dotnet add package IronPdf
dotnet add package IronPdf
SHELL

Fügen Sie nach der Installation Ihren Lizenzschlüssel zu Program.cs hinzu, bevor Sie eine IronPDF -API aufrufen:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Bei der Bereitstellung in Azure sollten Sie den Lizenzschlüssel im Azure Key Vault oder in der App-Konfiguration speichern, anstatt ihn fest zu codieren. Für AWS Lambda-Bereitstellungen verwenden Sie Umgebungsvariablen, die in Ihren Lambda-Funktionseinstellungen konfiguriert sind.

Das ist die gesamte Einrichtung. IronPDF erkennt und konfiguriert Chromium unter Windows automatisch zur Laufzeit. Bei Linux konsultieren Sie bitte die Linux-Einrichtungsanleitung, um die wenigen benötigten Systempakete zu ermitteln.

Sie können mit einer kostenlosen Testversion beginnen , um den vollen Funktionsumfang zu testen, bevor Sie sich für eine Lizenzstufe für den Produktiveinsatz entscheiden.

Wie generiert und zeigt man ein PDF aus einem HTML-String an?

Am schnellsten lässt sich ein PDF einem Benutzer anzeigen, indem man einen HTML-String rendert und diesen direkt im HTML-Code zurückgibt. Erstellen Sie einen Controller namens PdfController und fügen Sie eine Aktion wie diese hinzu:

using IronPdf;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();

var app = builder.Build();
app.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();

public class PdfController : Controller
{
    private readonly ChromePdfRenderer _renderer;

    public PdfController()
    {
        _renderer = new ChromePdfRenderer();
        _renderer.RenderingOptions.WaitFor.RenderDelay(100);
        _renderer.RenderingOptions.Timeout = 30;
    }

    public IActionResult DisplayFromHtml()
    {
        string html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 40px; }
                    h1   { color: #2c3e50; }
                    p    { line-height: 1.7; color: #444; }
                </style>
            </head>
            <body>
                <h1>Sample PDF Document</h1>
                <p>This PDF was generated using IronPDF in an ASP.NET Core application.</p>
            </body>
            </html>";

        PdfDocument pdf = _renderer.RenderHtmlAsPdf(html);

        Response.Headers.Append("Content-Disposition", "inline; filename=document.pdf");
        return File(pdf.BinaryData, "application/pdf");
    }
}
using IronPdf;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();

var app = builder.Build();
app.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();

public class PdfController : Controller
{
    private readonly ChromePdfRenderer _renderer;

    public PdfController()
    {
        _renderer = new ChromePdfRenderer();
        _renderer.RenderingOptions.WaitFor.RenderDelay(100);
        _renderer.RenderingOptions.Timeout = 30;
    }

    public IActionResult DisplayFromHtml()
    {
        string html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 40px; }
                    h1   { color: #2c3e50; }
                    p    { line-height: 1.7; color: #444; }
                </style>
            </head>
            <body>
                <h1>Sample PDF Document</h1>
                <p>This PDF was generated using IronPDF in an ASP.NET Core application.</p>
            </body>
            </html>";

        PdfDocument pdf = _renderer.RenderHtmlAsPdf(html);

        Response.Headers.Append("Content-Disposition", "inline; filename=document.pdf");
        return File(pdf.BinaryData, "application/pdf");
    }
}
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc

Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllersWithViews()

Dim app = builder.Build()
app.MapControllerRoute(name:="default", pattern:="{controller=Home}/{action=Index}/{id?}")
app.Run()

Public Class PdfController
    Inherits Controller

    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New()
        _renderer = New ChromePdfRenderer()
        _renderer.RenderingOptions.WaitFor.RenderDelay(100)
        _renderer.RenderingOptions.Timeout = 30
    End Sub

    Public Function DisplayFromHtml() As IActionResult
        Dim html As String = "
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 40px; }
                    h1   { color: #2c3e50; }
                    p    { line-height: 1.7; color: #444; }
                </style>
            </head>
            <body>
                <h1>Sample PDF Document</h1>
                <p>This PDF was generated using IronPDF in an ASP.NET Core application.</p>
            </body>
            </html>"

        Dim pdf As PdfDocument = _renderer.RenderHtmlAsPdf(html)

        Response.Headers.Append("Content-Disposition", "inline; filename=document.pdf")
        Return File(pdf.BinaryData, "application/pdf")
    End Function
End Class
$vbLabelText   $csharpLabel

Wie sieht die gerenderte PDF-Datei im Browser aus?

Browser zeigt ein PDF-Dokument mit dem Titel

ChromePdfRenderer verwendet intern Chromium, sodass CSS Grid, Flexbox, Webfonts und moderne CSS-Funktionen korrekt gerendert werden. Durch die Einstellung von Content-Disposition auf inline wird dem Browser mitgeteilt, die Datei anzuzeigen, anstatt sie zu speichern. Wenn Sie diesen Wert in attachment ändern, fordert der Browser den Benutzer stattdessen zum Herunterladen auf.

Bei Dokumenten mit komplexen Layouts können Sie die Ausgabe durch Rendering-Optionen wie benutzerdefinierte Papierformate, Ränder und den CSS-Medientyp für den Druck feinabstimmen. Die WaitFor-API ist besonders nützlich in containerisierten Umgebungen, in denen Netzwerklatenz das Laden externer Ressourcen verzögern kann.

Für einen detaillierteren Überblick über die HTML-Konvertierungsoptionen siehe den Leitfaden "HTML-String zu PDF" .

Wie rendert man PDF-Dateien aus URLs und Razor Ansichten?

IronPDF kann jede Live-Webseite als PDF erfassen – ideal zum Archivieren von Webinhalten oder zum Generieren von Berichten aus bestehenden Seiten. Die ASP.NET Core -Dokumentation beschreibt, wie Controller-Aktionen Ergebnisse zurückgeben, was dem hier verwendeten Muster entspricht.

public IActionResult RenderFromUrl(string url = "https://en.wikipedia.org/wiki/Main_Page")
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
    renderer.RenderingOptions.WaitFor.NetworkIdle();

    PdfDocument pdf = renderer.RenderUrlAsPdf(url);

    Response.Headers.Append("Content-Disposition", "inline; filename=webpage.pdf");
    Response.Headers.Append("Cache-Control", "public, max-age=3600");
    return File(pdf.BinaryData, "application/pdf");
}
public IActionResult RenderFromUrl(string url = "https://en.wikipedia.org/wiki/Main_Page")
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
    renderer.RenderingOptions.WaitFor.NetworkIdle();

    PdfDocument pdf = renderer.RenderUrlAsPdf(url);

    Response.Headers.Append("Content-Disposition", "inline; filename=webpage.pdf");
    Response.Headers.Append("Cache-Control", "public, max-age=3600");
    return File(pdf.BinaryData, "application/pdf");
}
Public Function RenderFromUrl(Optional url As String = "https://en.wikipedia.org/wiki/Main_Page") As IActionResult
    Dim renderer As New ChromePdfRenderer()
    renderer.RenderingOptions.EnableJavaScript = True
    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
    renderer.RenderingOptions.WaitFor.NetworkIdle()

    Dim pdf As PdfDocument = renderer.RenderUrlAsPdf(url)

    Response.Headers.Append("Content-Disposition", "inline; filename=webpage.pdf")
    Response.Headers.Append("Cache-Control", "public, max-age=3600")
    Return File(pdf.BinaryData, "application/pdf")
End Function
$vbLabelText   $csharpLabel

Wie wird die URL-basierte PDF-Darstellung angezeigt?

Screenshot eines PDF-Viewers, der die Wikipedia-Startseite anzeigt, gerendert in einer ASP.NET Webanwendung mit IronPDF. Der Hauptinhalt der Seite und die Navigationselemente sind mit vollständigem CSS-Styling erhalten.

Wenn Sie eine Razor Ansicht konvertieren müssen – wie beispielsweise eine Rechnungs- oder Kontoauszugsvorlage – rendern Sie die Ansicht zunächst in eine HTML-Zeichenfolge und übergeben diese Zeichenfolge dann an IronPDF. Dadurch bleiben Ihre Vorlagen sowohl für Web- als auch für PDF-Ausgaben wiederverwendbar:

public async Task<IActionResult> ViewToPdf()
{
    var model = new InvoiceModel
    {
        InvoiceNumber = 1001,
        InvoiceDate   = DateTime.Now,
        CustomerName  = "Acme Corp.",
        Items = new List<ItemModel>
        {
            new ItemModel { Description = "Product A", Quantity = 2, UnitPrice = 50.00m },
            new ItemModel { Description = "Service B", Quantity = 1, UnitPrice = 150.00m }
        }
    };
    model.TotalAmount = model.Items.Sum(i => i.LineTotal);

    string htmlContent = await RenderViewToStringAsync("Invoice", model);

    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.MarginTop    = 40;
    renderer.RenderingOptions.MarginBottom = 40;

    string baseUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host}";
    PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent, baseUrl);

    return File(pdf.BinaryData, "application/pdf");
}

private async Task<string> RenderViewToStringAsync(string viewName, object model)
{
    var actionContext = new ActionContext(
        HttpContext, RouteData, ControllerContext.ActionDescriptor);

    var viewEngine      = HttpContext.RequestServices.GetRequiredService<IRazorViewEngine>();
    var tempDataFactory = HttpContext.RequestServices.GetRequiredService<ITempDataDictionaryFactory>();
    var tempData        = tempDataFactory.GetTempData(HttpContext);

    ViewData.Model = model;

    var viewResult = viewEngine.FindView(actionContext, viewName, isMainPage: false);
    if (!viewResult.Success)
    {
        string searched = string.Join(
            Environment.NewLine,
            viewResult.SearchedLocations ?? Array.Empty<string>());
        throw new InvalidOperationException(
            $"Could not find view '{viewName}'. Searched:{Environment.NewLine}{searched}");
    }

    await using var writer      = new StringWriter();
    var             viewContext = new ViewContext(
        actionContext, viewResult.View, ViewData, tempData,
        writer, new HtmlHelperOptions());

    await viewResult.View.RenderAsync(viewContext);
    return writer.ToString();
}
public async Task<IActionResult> ViewToPdf()
{
    var model = new InvoiceModel
    {
        InvoiceNumber = 1001,
        InvoiceDate   = DateTime.Now,
        CustomerName  = "Acme Corp.",
        Items = new List<ItemModel>
        {
            new ItemModel { Description = "Product A", Quantity = 2, UnitPrice = 50.00m },
            new ItemModel { Description = "Service B", Quantity = 1, UnitPrice = 150.00m }
        }
    };
    model.TotalAmount = model.Items.Sum(i => i.LineTotal);

    string htmlContent = await RenderViewToStringAsync("Invoice", model);

    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.MarginTop    = 40;
    renderer.RenderingOptions.MarginBottom = 40;

    string baseUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host}";
    PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent, baseUrl);

    return File(pdf.BinaryData, "application/pdf");
}

private async Task<string> RenderViewToStringAsync(string viewName, object model)
{
    var actionContext = new ActionContext(
        HttpContext, RouteData, ControllerContext.ActionDescriptor);

    var viewEngine      = HttpContext.RequestServices.GetRequiredService<IRazorViewEngine>();
    var tempDataFactory = HttpContext.RequestServices.GetRequiredService<ITempDataDictionaryFactory>();
    var tempData        = tempDataFactory.GetTempData(HttpContext);

    ViewData.Model = model;

    var viewResult = viewEngine.FindView(actionContext, viewName, isMainPage: false);
    if (!viewResult.Success)
    {
        string searched = string.Join(
            Environment.NewLine,
            viewResult.SearchedLocations ?? Array.Empty<string>());
        throw new InvalidOperationException(
            $"Could not find view '{viewName}'. Searched:{Environment.NewLine}{searched}");
    }

    await using var writer      = new StringWriter();
    var             viewContext = new ViewContext(
        actionContext, viewResult.View, ViewData, tempData,
        writer, new HtmlHelperOptions());

    await viewResult.View.RenderAsync(viewContext);
    return writer.ToString();
}
Imports System
Imports System.Collections.Generic
Imports System.Linq
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.AspNetCore.Mvc.ViewEngines
Imports Microsoft.AspNetCore.Mvc.Rendering
Imports Microsoft.AspNetCore.Mvc.ViewFeatures
Imports Microsoft.Extensions.DependencyInjection
Imports IronPdf

Public Class YourController
    Inherits Controller

    Public Async Function ViewToPdf() As Task(Of IActionResult)
        Dim model As New InvoiceModel With {
            .InvoiceNumber = 1001,
            .InvoiceDate = DateTime.Now,
            .CustomerName = "Acme Corp.",
            .Items = New List(Of ItemModel) From {
                New ItemModel With {.Description = "Product A", .Quantity = 2, .UnitPrice = 50.0D},
                New ItemModel With {.Description = "Service B", .Quantity = 1, .UnitPrice = 150.0D}
            }
        }
        model.TotalAmount = model.Items.Sum(Function(i) i.LineTotal)

        Dim htmlContent As String = Await RenderViewToStringAsync("Invoice", model)

        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.MarginTop = 40
        renderer.RenderingOptions.MarginBottom = 40

        Dim baseUrl As String = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host}"
        Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlContent, baseUrl)

        Return File(pdf.BinaryData, "application/pdf")
    End Function

    Private Async Function RenderViewToStringAsync(viewName As String, model As Object) As Task(Of String)
        Dim actionContext As New ActionContext(HttpContext, RouteData, ControllerContext.ActionDescriptor)

        Dim viewEngine As IRazorViewEngine = HttpContext.RequestServices.GetRequiredService(Of IRazorViewEngine)()
        Dim tempDataFactory As ITempDataDictionaryFactory = HttpContext.RequestServices.GetRequiredService(Of ITempDataDictionaryFactory)()
        Dim tempData As ITempDataDictionary = tempDataFactory.GetTempData(HttpContext)

        ViewData.Model = model

        Dim viewResult As ViewEngineResult = viewEngine.FindView(actionContext, viewName, isMainPage:=False)
        If Not viewResult.Success Then
            Dim searched As String = String.Join(Environment.NewLine, viewResult.SearchedLocations ?? Array.Empty(Of String)())
            Throw New InvalidOperationException($"Could not find view '{viewName}'. Searched:{Environment.NewLine}{searched}")
        End If

        Await Using writer As New StringWriter()
            Dim viewContext As New ViewContext(actionContext, viewResult.View, ViewData, tempData, writer, New HtmlHelperOptions())

            Await viewResult.View.RenderAsync(viewContext)
            Return writer.ToString()
        End Using
    End Function
End Class

Public Class InvoiceModel
    Public Property InvoiceNumber As Integer
    Public Property InvoiceDate As DateTime
    Public Property CustomerName As String
    Public Property Items As List(Of ItemModel)
    Public Property TotalAmount As Decimal
End Class

Public Class ItemModel
    Public Property Description As String
    Public Property Quantity As Integer
    Public Property UnitPrice As Decimal

    Public ReadOnly Property LineTotal As Decimal
        Get
            Return Quantity * UnitPrice
        End Get
    End Property
End Class
$vbLabelText   $csharpLabel

Welche Ergebnisse liefert die Razor View-PDF-Generierung?

PDF invoice displayed in a web browser showing Invoice #1001 for Acme Corp with two line items totaling $250.00, demonstrating successful Razor view to PDF conversion

Der Parameter baseUrl ist relevant, wenn Ihre Razor Ansicht auf relative CSS- oder Bildpfade verweist. Durch die Übergabe der aktuellen Host-URL kann IronPDF diese Pfade korrekt auflösen. Eine vollständige Schritt-für-Schritt-Anleitung inklusive Blazor Anwendungsmustern finden Sie im Razor -zu-PDF-Tutorial .

Wie verarbeitet man große PDF-Dateien beim Streaming?

Bei Dokumenten, die mehrere Megabyte groß sein können, reduziert Streaming die maximale Speicherauslastung und beginnt früher mit der Auslieferung der Bytes an den Client. Verwenden Sie FileStreamResult anstelle von File() bei einem rohen Byte-Array:

public async Task<IActionResult> StreamLargePdf()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CreatePdfFormsFromHtml = false;

    PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync(
        "<h1>Large Document</h1><p>Full content here...</p>");

    pdf.CompressImages(80);

    var stream = new MemoryStream(pdf.BinaryData);

    Response.Headers.Append("Content-Length", pdf.BinaryData.Length.ToString());
    Response.Headers.Append("Accept-Ranges",  "bytes");

    return new FileStreamResult(stream, "application/pdf");
}
public async Task<IActionResult> StreamLargePdf()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CreatePdfFormsFromHtml = false;

    PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync(
        "<h1>Large Document</h1><p>Full content here...</p>");

    pdf.CompressImages(80);

    var stream = new MemoryStream(pdf.BinaryData);

    Response.Headers.Append("Content-Length", pdf.BinaryData.Length.ToString());
    Response.Headers.Append("Accept-Ranges",  "bytes");

    return new FileStreamResult(stream, "application/pdf");
}
Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

Public Class YourController
    Inherits Controller

    Public Async Function StreamLargePdf() As Task(Of IActionResult)
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.CreatePdfFormsFromHtml = False

        Dim pdf As PdfDocument = Await renderer.RenderHtmlAsPdfAsync("<h1>Large Document</h1><p>Full content here...</p>")

        pdf.CompressImages(80)

        Dim stream As New MemoryStream(pdf.BinaryData)

        Response.Headers.Append("Content-Length", pdf.BinaryData.Length.ToString())
        Response.Headers.Append("Accept-Ranges", "bytes")

        Return New FileStreamResult(stream, "application/pdf")
    End Function
End Class
$vbLabelText   $csharpLabel

CompressImages(80) reduziert die JPEG-Qualität auf 80 %, wodurch die Dateigröße für bildreiche Dokumente deutlich verringert wird, ohne dass ein sichtbarer Qualitätsverlust auftritt. Die Einstellung Accept-Ranges: bytes signalisiert dem Browser, dass er Bytebereichsblöcke anfordern kann, wodurch ein schnelleres Suchen in großen PDFs ermöglicht wird, ohne dass die gesamte Datei vorher heruntergeladen werden muss.

Die PDF/A-Spezifikation der ISO definiert die Anforderungen an PDFs in Archivqualität. Wenn Ihre Anwendung Dokumente für die Langzeitarchivierung erstellen muss, stellt der PDF/A-Konformitätsmodus von IronPDF sicher, dass die Ausgabe diesen Standards entspricht, was insbesondere für regulatorische oder juristische Arbeitsabläufe relevant ist.

Bei älteren ASP.NET Web Forms-Projekten ist das Vorgehen etwas anders, da Sie direkt in die HTTP-Antwort schreiben:

protected void btnGeneratePdf_Click(object sender, EventArgs e)
{
    using var renderer = new ChromePdfRenderer();
    PdfDocument pdf    = renderer.RenderHtmlAsPdf("<h1>Web Form PDF</h1>");
    Response.ContentType = "application/pdf";
    Response.BinaryWrite(pdf.BinaryData);
    Response.End();
}
protected void btnGeneratePdf_Click(object sender, EventArgs e)
{
    using var renderer = new ChromePdfRenderer();
    PdfDocument pdf    = renderer.RenderHtmlAsPdf("<h1>Web Form PDF</h1>");
    Response.ContentType = "application/pdf";
    Response.BinaryWrite(pdf.BinaryData);
    Response.End();
}
Protected Sub btnGeneratePdf_Click(sender As Object, e As EventArgs)
    Using renderer As New ChromePdfRenderer()
        Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>Web Form PDF</h1>")
        Response.ContentType = "application/pdf"
        Response.BinaryWrite(pdf.BinaryData)
        Response.End()
    End Using
End Sub
$vbLabelText   $csharpLabel

Bei Arbeitslasten, die viele PDFs gleichzeitig generieren, sollten Sie den IronPDF Async API-Leitfaden und die Referenz zur Leistungsoptimierung konsultieren, um Einstellungen zu finden, die den Speicherbedarf in Szenarien mit hohem Durchsatz reduzieren.

Welche Funktionen bietet ein browserbasierter Viewer Ihren Nutzern?

Wenn ein Browser ein PDF direkt im Browser anzeigt, wird automatisch ein vollwertiger Viewer geöffnet. Ihre Benutzer erhalten eine Textauswahl zum Kopieren von Inhalten, eine integrierte Suchleiste zum Auffinden bestimmter Wörter oder Zahlen, Drucksteuerung und die Möglichkeit zum Herunterladen mit einem Klick – und das alles ohne dass Sie Frontend-Code schreiben müssen.

Über die grundlegende Anzeige hinaus unterstützt IronPDF eine breite Palette von Dokumentfunktionen, die Einfluss darauf haben, was Benutzer im Viewer sehen:

Die folgende Tabelle fasst die in der Bibliothek verfügbaren primären Konvertierungsmethoden zusammen und gibt an, wann welche Methodee anzuwenden ist:

IronPDF Konvertierungsmethoden und empfohlene Anwendungsfälle
Methode Eingang Am besten für
`RenderHtmlAsPdf` HTML-Zeichenkette Vorlagen für Dokumente, Rechnungen, Berichte
`RenderUrlAsPdf` URL Webseitenarchivierung, Live-Inhalts-Snapshots
`RenderHtmlAsPdf` + Razor Gerenderte HTML-Ansicht Wiederverwendung vorhandener MVC-Vorlagen als PDFs
`RenderHtmlFileAsPdf` Lokale HTML-Datei Statische Vorlagen werden auf der Festplatte gespeichert

Für containerisierte Bereitstellungen bietet IronPDF auch Unterstützung für die Remote-Engine , sodass Sie die PDF-Generierung als dedizierten Microservice ausführen können. Informationen zu den für ressourcenbeschränkte Umgebungen optimierten Einstellungen finden Sie im Leitfaden zur Speicheroptimierung .

Eine vollständige Übersicht der Funktionen finden Sie auf der IronPDF -Funktionsseite .

Welche Formatierungs- und Bearbeitungsoptionen unterstützt IronPDF ?

IronPDF bietet weit mehr als nur einfaches Rendering. Sie können jedem Dokument mit den folgenden Optionen Struktur und Branding verleihen.

Zu den Steuerungsmöglichkeiten für das Seitenlayout gehören benutzerdefinierte Papierformate, Ausrichtungseinstellungen und die Konfiguration der Seitenränder. Die Typografieunterstützung umfasst das vollständige Webfont-Rendering über CSS @font-face Deklarationen, was bedeutet, dass Dokumente exakt mit Ihren Markenschriften übereinstimmen. Sie können Bilder auch in PDF-Seiten einbetten und deren Größe ändern, wodurch Sie die volle Kontrolle über die visuelle Qualität haben.

Für die Dokumentenbearbeitung bietet IronPDF die Möglichkeit, bestehende PDFs zusammenzuführen oder zu teilen, einzelne Seiten hinzuzufügen oder zu entfernen sowie Text und Bilder programmatisch zu extrahieren. Die JavaScript Ausführung vor der Datenerfassung unterstützt dynamische Diagramme und Datenvisualisierungen – nützlich beim Generieren von Berichten, die auf clientseitigen Rendering-Bibliotheken wie Chart.js oder D3.js basieren.

Dank dieser Funktionen können Sie direkt aus Ihrer Anwendung heraus professionelle, druckfertige Dokumente erstellen, ohne dass eine separate Dokumentenverarbeitungsschicht erforderlich ist.

Wenn Sie vom Benutzer hochgeladene PDFs akzeptieren und diese zusammen mit generierten PDFs anzeigen müssen, kann IronPDF bestehende PDF-Binärdateien genauso einfach lesen wie neue erstellen. Eine Datei mit PdfDocument.FromFile() wird geladen und ihr BinaryData wird über denselben File()-Helper zurückgegeben.

Eine detaillierte Anleitung zum Bearbeiten, Kommentieren und Ändern bestehender Dokumente finden Sie im C#-Tutorial zum Bearbeiten von PDFs .

Wie schneidet IronPDF im Vergleich zu alternativen Ansätzen ab?

Die beiden häufigsten Alternativen zu einem serverseitigen IronPDF -Ansatz sind die Einbettung einer clientseitigen PDF-Viewer-Bibliothek (wie z. B. PDF.js , dem Open-Source-Viewer von Mozilla) und die Weiterleitung der Benutzer an ein separates Dokumentenmanagementsystem.

Clientseitige Viewer wie PDF.js eignen sich gut für einfache Anzeigefälle, erfordern aber, dass das Viewer- JavaScript Bundle bereitgestellt, CORS für externe PDFs behandelt und die Browserkompatibilität selbst verwaltet wird. Die serverseitige Generierung mit IronPDF hält die PDF-Pipeline vollständig auf dem .NET Stack, vereinfacht die Sicherheitsrichtlinien und vermeidet Komplexitäten durch Cross-Origin-Anfragen.

Ein dediziertes Dokumentenmanagementsystem verursacht zusätzlichen operativen Aufwand, den die meisten Webanwendungen nicht benötigen. Für Teams, die bereits ASP.NET Core verwenden, ist das Generieren und Streamen von PDFs direkt aus dem Controller der einfachste Weg.

Was sind Ihre nächsten Schritte?

Das Anzeigen von PDFs in einer ASP.NET Core -Webanwendung erfordert nur wenige Codezeilen. Generieren Sie das PDF mit ChromePdfRenderer, setzen Sie Content-Disposition: inline und geben Sie FileResult zurück -- der integrierte Viewer des Browsers kümmert sich um alles Weitere.

Für Produktionsumgebungen sollten Sie die folgenden Schritte zur Vorbereitung Ihrer Einrichtung beachten:

Sind Sie bereit, die PDF-Anzeige in Ihr Projekt zu integrieren? Starten Sie mit einer kostenlosen Testversion und führen Sie die oben genannten Beispiele in wenigen Minuten aus. Wenn Sie bereit für den Einsatz sind, prüfen Sie die Lizenzoptionen , die zu Ihrer Teamgröße und Ihrem Nutzungsverhalten passen. Um verwandte Konvertierungen zu erkunden, schauen Sie sich in der Anleitungsbibliothek an, wie IronPDF DOCX zu PDF , Bild zu PDF und andere Formate verarbeitet.

Starten Sie jetzt mit IronPDF.
green arrow pointer

Häufig gestellte Fragen

Wie kann ich einen PDF-Viewer in einer ASP.NET-Webanwendung erstellen?

Mit IronPDF können Sie einen PDF-Viewer in einer ASP.NET-Webanwendung erstellen. Damit können Sie PDF-Dokumente direkt in Ihrer Anwendung anzeigen und ein nahtloses Anzeigeerlebnis bieten, ohne externe Tools wie Adobe Acrobat Reader zu benötigen.

Welche Vorteile bietet IronPDF für die PDF-Anzeige in ASP.NET?

IronPDF bietet eine reibungslose und integrierte PDF-Anzeige in ASP.NET-Anwendungen. Es ermöglicht die Inline-Anzeige von Dokumenten, unterstützt verschiedene Dateitypen und macht PDF-Viewer von Drittanbietern überflüssig, was die Benutzerfreundlichkeit erhöht.

Kann ich interaktive PDF-Formulare in meiner ASP.NET-Webanwendung anzeigen?

Ja, mit IronPDF können Sie interaktive PDF-Formulare in Ihrer ASP.NET-Webanwendung anzeigen. Es unterstützt das Rendering von Formularfeldern und interaktiven Elementen, so dass Benutzer direkt im Browser mit den Dokumenten interagieren können.

Ist es möglich, Rechnungen und Berichte mit IronPDF in ASP.NET darzustellen?

IronPDF eignet sich hervorragend für die Anzeige von Rechnungen, Berichten und anderen Dokumenttypen in ASP.NET-Anwendungen. Es stellt sicher, dass Ihre Dokumente innerhalb der Webanwendung genau und effizient gerendert werden.

Benötige ich Adobe Acrobat Reader, um PDFs in ASP.NET-Anwendungen mit IronPDF anzuzeigen?

Nein, Sie benötigen keinen Adobe Acrobat Reader, um PDFs in ASP.NET-Anwendungen anzuzeigen, wenn Sie IronPDF verwenden. Mit IronPDF können Sie PDFs direkt im Browser ohne Abhängigkeiten von Drittanbietern darstellen und anzeigen.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an