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

Wie man mit IronPDF einen PDF-Viewer in einer ASP.NET-Webanwendung erstellt

Curtis Chau
Curtis Chau
Aktualisiert:

IronPDF ermöglicht die nahtlose PDF-Anzeige in ASP.NET Core-Anwendungen durch die Generierung serverseitiger PDFs, die direkt in den integrierten Viewern der Browser angezeigt werden. Es sind keine Plugins oder externen Abhängigkeiten erforderlich – konfigurieren Sie einfach die Antwortheader und überlassen Sie die HTML-zu-PDF-Konvertierung der Chrome-basierten Rendering-Engine von IronPDF.

Das Erstellen von Webanwendungen, die PDF-Dokumente anzeigen, ist unkompliziert. Egal ob Rechnungen, Berichte oder interaktive Formulare – die Nutzer erwarten ein reibungsloses Dokumentenanzeigeerlebnis direkt im Browser – ohne die Notwendigkeit von Adobe Acrobat Reader oder zusätzlichen Tools von Drittanbietern.

IronPDF macht dies bemerkenswert einfach. Mit dieser regelmäßig aktualisierten .NET-Bibliothek können Sie PDF-Dateien innerhalb Ihres ASP.NET Core-Projekts mit nur wenigen Codezeilen erstellen, rendern und anzeigen. Lassen Sie uns nun genauer betrachten, wie Sie ein professionelles PDF-Viewer-Steuerelement implementieren können, das alles von der einfachen HTML-Konvertierung bis hin zu komplexen Razor-Ansichten abdeckt.

Wie funktioniert die browserbasierte PDF-Anzeige?

Die gute Nachricht ist, dass moderne Browser bereits über einen integrierten PDF-Viewer verfügen. Wenn Ihr Server eine PDF-Datei mit dem korrekten MIME-Typ ( application/pdf ) sendet, zeigt der Browser sie automatisch direkt im Browser an. Das bedeutet, dass Sie keine externen Plugins oder komplexe clientseitige JavaScript-Bibliotheken benötigen, um PDF-Dokumente anzuzeigen .

Der Schlüssel liegt in der Erstellung qualitativ hochwertiger PDF-Dokumente und der Konfiguration der korrekten Antwortheader . IronPDF übernimmt die rechenintensive Arbeit auf der Serverseite und nutzt seine Chrome-Rendering-Engine , um pixelgenaue PDF-Seiten aus HTML, CSS und JavaScript zu erstellen. Das Ergebnis? Ihre Benutzer erhalten ein natives Dokumentenanzeigeerlebnis mit Funktionen wie Textauswahl , Suche, Drucken und Herunterladen – alles ohne zusätzliche UI-Konfiguration. Sie können den Inhalt leicht einbetten und anzeigen.

Dieser Ansatz funktioniert nahtlos in allen .NET-Anwendungen , egal ob Sie mit ASP.NET Core MVC , Razor-Ansichten oder sogar älteren Webordnerprojekten arbeiten. Für containerisierte Bereitstellungen bietet IronPDF hervorragende Docker-Unterstützung mit minimalen Abhängigkeiten und ist daher ideal für Microservices-Architekturen geeignet.

Wie installiert und konfiguriert man das PDF Viewer Control?

Die ersten Schritte mit IronPDF in Visual Studio sind nur wenige. Öffnen Sie Ihr ASP.NET Core-Projekt und installieren Sie das NuGet-Paket :

Install-Package IronPdf

Für containerisierte Umgebungen stellt IronPDF offizielle Docker-Images bereit und unterstützt sowohl Linux- als auch Windows-Container . Die Bibliothek kümmert sich automatisch um Chrome-Abhängigkeiten und Schriftartinstallationen, wodurch die Komplexität der Bereitstellung minimiert wird.

Fügen Sie als Nächstes Ihre Lizenzschlüsselkonfiguration in Program.cs hinzu:

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

Bei Azure-Bereitstellungen können Sie den Lizenzschlüssel im Azure Key Vault oder in Umgebungsvariablen speichern. IronPDF unterstützt außerdem AWS Lambda und andere Cloud-Plattformen mit optimierten Leistungseinstellungen .

Das ist die gesamte Konfiguration, die Sie für die vollständige Integration von IronPDF in Ihre .NET-Anwendungen benötigen. Weitere Konfigurationsoptionen für fortgeschrittene Szenarien wie Azure-Bereitstellung oder Docker-Container finden Sie in der Dokumentation von IronPDF . Sie können mit einer kostenlosen Testversion beginnen , um alle Funktionen zu erkunden, bevor Sie sich festlegen.

Wie generiert und zeigt man PDF-Dokumente aus HTML?

Der einfachste Weg, einen PDF-Viewer in Ihrer ASP.NET Core-Webanwendung zu erstellen, besteht darin , HTML-Strings direkt zu konvertieren . Hier ist ein vollständiges Controller-Beispiel mit Health-Check-Endpunkt für die Container-Orchestrierung:

using IronPdf;
using Microsoft.AspNetCore.Mvc;

public class PdfController : Controller
{
    private readonly ChromePdfRenderer _renderer;

    public PdfController()
    {
        _renderer = new ChromePdfRenderer();
        // Configure for container environments
        _renderer.RenderingOptions.WaitFor.RenderDelay = 100; // ms
        _renderer.RenderingOptions.Timeout = 30000; // 30 seconds
    }

    public IActionResult DisplayFromHtml()
    {
        // Create PDF from HTML with CSS styling
        var html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; }
                </style>
            </head>
            <body>
                <h1>Sample PDF Document</h1>
                <p class='content'>This PDF was generated using IronPDF in ASP.NET Core.</p>
            </body>
            </html>";
        var pdf = _renderer.RenderHtmlAsPdf(html);
        // Display PDF inline in browser
        Response.Headers.Add("Content-Disposition", "inline; filename=document.pdf");
        return File(pdf.BinaryData, "application/pdf");
    }

    // Health check endpoint for Kubernetes readiness probe
    [HttpGet("health")]
    public IActionResult Health()
    {
        try
        {
            var test = _renderer.RenderHtmlAsPdf("<p>Health check</p>");
            return Ok(new { status = "healthy", engine = "ready" });
        }
        catch
        {
            return StatusCode(503, new { status = "unhealthy" });
        }
    }
}
using IronPdf;
using Microsoft.AspNetCore.Mvc;

public class PdfController : Controller
{
    private readonly ChromePdfRenderer _renderer;

    public PdfController()
    {
        _renderer = new ChromePdfRenderer();
        // Configure for container environments
        _renderer.RenderingOptions.WaitFor.RenderDelay = 100; // ms
        _renderer.RenderingOptions.Timeout = 30000; // 30 seconds
    }

    public IActionResult DisplayFromHtml()
    {
        // Create PDF from HTML with CSS styling
        var html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; }
                </style>
            </head>
            <body>
                <h1>Sample PDF Document</h1>
                <p class='content'>This PDF was generated using IronPDF in ASP.NET Core.</p>
            </body>
            </html>";
        var pdf = _renderer.RenderHtmlAsPdf(html);
        // Display PDF inline in browser
        Response.Headers.Add("Content-Disposition", "inline; filename=document.pdf");
        return File(pdf.BinaryData, "application/pdf");
    }

    // Health check endpoint for Kubernetes readiness probe
    [HttpGet("health")]
    public IActionResult Health()
    {
        try
        {
            var test = _renderer.RenderHtmlAsPdf("<p>Health check</p>");
            return Ok(new { status = "healthy", engine = "ready" });
        }
        catch
        {
            return StatusCode(503, new { status = "unhealthy" });
        }
    }
}
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc

Public Class PdfController
    Inherits Controller

    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New()
        _renderer = New ChromePdfRenderer()
        ' Configure for container environments
        _renderer.RenderingOptions.WaitFor.RenderDelay = 100 ' ms
        _renderer.RenderingOptions.Timeout = 30000 ' 30 seconds
    End Sub

    Public Function DisplayFromHtml() As IActionResult
        ' Create PDF from HTML with CSS styling
        Dim html As String = "
            <html>
            <head>
                <style>
                    body { font-family: Arial; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; }
                </style>
            </head>
            <body>
                <h1>Sample PDF Document</h1>
                <p class='content'>This PDF was generated using IronPDF in ASP.NET Core.</p>
            </body>
            </html>"
        Dim pdf = _renderer.RenderHtmlAsPdf(html)
        ' Display PDF inline in browser
        Response.Headers.Add("Content-Disposition", "inline; filename=document.pdf")
        Return File(pdf.BinaryData, "application/pdf")
    End Function

    ' Health check endpoint for Kubernetes readiness probe
    <HttpGet("health")>
    Public Function Health() As IActionResult
        Try
            Dim test = _renderer.RenderHtmlAsPdf("<p>Health check</p>")
            Return Ok(New With {Key .status = "healthy", Key .engine = "ready"})
        Catch
            Return StatusCode(503, New With {Key .status = "unhealthy"})
        End Try
    End Function
End Class
$vbLabelText   $csharpLabel

Wie sieht die generierte PDF-Datei im Browser aus?

Ein Browser zeigt ein PDF-Dokument mit dem Titel "Beispiel-PDF-Dokument" und dem Text "Dieses PDF wurde mit IronPDF in ASP.NET Core generiert" an, das unter localhost:7254/Pdf/DisplayFromHtml angezeigt wird.

Die ChromePdfRenderer Klasse verwendet Chromium für eine präzise Darstellung und gewährleistet so, dass Ihr CSS , JavaScript und Ihre Bilder genau wie gewünscht angezeigt werden. Die Einstellung Content-Disposition auf inline weist den Browser an, die PDF-Datei anzuzeigen, anstatt sie herunterzuladen.

So entsteht eine nahtlose Darstellung, die es den Nutzern ermöglicht, das Dokument direkt in Ihrer Web-UI aufzurufen. Bei Dokumenten mit komplexen Layouts können Sie Rendering-Einstellungen wie Breite und Höhe innerhalb des HTML-Codes oder mithilfe von RenderingOptions festlegen. Die WaitFor-Optionen gewährleisten ein korrektes Rendering in containerisierten Umgebungen, in denen Netzwerklatenz das Laden von Assets beeinträchtigen könnte.

Weitere Optionen zur HTML-Konvertierung finden Sie im Leitfaden zur Umwandlung von HTML-Strings in PDFs sowie in den Tipps zur Leistungsoptimierung .

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

IronPDF kann auch Live-Webseiten in PDF-Dokumente umwandeln . Dies eignet sich perfekt zum Generieren von Berichten oder zum Archivieren von Webinhalten in verteilten Systemen:

public IActionResult RenderFromUrl(string url = "___PROTECTED_URL_92___")
{
    var renderer = new ChromePdfRenderer();
    // Configure for production environments
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
    renderer.RenderingOptions.WaitFor.NetworkIdle = 2000; // Wait for network idle
    renderer.RenderingOptions.PaperFit.UseChromeDefaultRendering = false; // Consistent across environments

    var pdf = renderer.RenderUrlAsPdf(url);
    Response.Headers.Add("Content-Disposition", "inline; filename=webpage.pdf");
    // Add caching headers for CDN distribution
    Response.Headers.Add("Cache-Control", "public, max-age=3600");
    return File(pdf.BinaryData, "application/pdf");
}
public IActionResult RenderFromUrl(string url = "___PROTECTED_URL_92___")
{
    var renderer = new ChromePdfRenderer();
    // Configure for production environments
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
    renderer.RenderingOptions.WaitFor.NetworkIdle = 2000; // Wait for network idle
    renderer.RenderingOptions.PaperFit.UseChromeDefaultRendering = false; // Consistent across environments

    var pdf = renderer.RenderUrlAsPdf(url);
    Response.Headers.Add("Content-Disposition", "inline; filename=webpage.pdf");
    // Add caching headers for CDN distribution
    Response.Headers.Add("Cache-Control", "public, max-age=3600");
    return File(pdf.BinaryData, "application/pdf");
}
Public Function RenderFromUrl(Optional url As String = "___PROTECTED_URL_92___") As IActionResult
    Dim renderer = New ChromePdfRenderer()
    ' Configure for production environments
    renderer.RenderingOptions.EnableJavaScript = True
    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
    renderer.RenderingOptions.WaitFor.NetworkIdle = 2000 ' Wait for network idle
    renderer.RenderingOptions.PaperFit.UseChromeDefaultRendering = False ' Consistent across environments

    Dim pdf = renderer.RenderUrlAsPdf(url)
    Response.Headers.Add("Content-Disposition", "inline; filename=webpage.pdf")
    ' Add caching headers for CDN distribution
    Response.Headers.Add("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.

Um Razor-Ansichten in PDF zu konvertieren , benötigen Sie eine Hilfsmethode, die die Ansicht zunächst als HTML rendert. Dieser Ansatz ermöglicht es Ihnen, Ihre bestehenden Vorlagen sowohl für die Webdarstellung als auch für die PDF-Generierung wiederzuverwenden, was für die Konsistenz zwischen Microservices unerlässlich ist.

public async Task<IActionResult> ViewToPdf()
{
    var invoiceModel = 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 }
        }
    };
    invoiceModel.TotalAmount = invoiceModel.Items.Sum(i => i.LineTotal);
    // NOTE: RenderViewToStringAsync uses the Request services and ActionContext
    var htmlContent = await RenderViewToStringAsync("Invoice", invoiceModel);

    var renderer = new IronPdf.ChromePdfRenderer();
    // Optimize for memory-constrained containers
    renderer.RenderingOptions.UseMarginsOnHeaderAndFooter = UseMargins.All;
    renderer.RenderingOptions.MarginTop = renderer.RenderingOptions.MarginBottom = 40;

    var pdf = renderer.RenderHtmlAsPdf(htmlContent, baseUrl: HttpContext.Request.Scheme + "://" + HttpContext.Request.Host);

    // Add monitoring metrics
    _logger.LogInformation($"PDF generated: Size={pdf.BinaryData.Length} bytes, Pages={pdf.PageCount}");

    return File(pdf.BinaryData, "application/pdf");
}
private async Task<string> RenderViewToStringAsync(string viewName, object model)
{
    // Use the current HttpContext's service provider (guaranteed available during a request)
    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)
    {
        // Helpful error for debugging
        var searchedLocations = string.Join(Environment.NewLine, viewResult.SearchedLocations ?? Array.Empty<string>());
        throw new InvalidOperationException($"Couldn't find view '{viewName}'. Searched locations:{Environment.NewLine}{searchedLocations}");
    }
    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 invoiceModel = 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 }
        }
    };
    invoiceModel.TotalAmount = invoiceModel.Items.Sum(i => i.LineTotal);
    // NOTE: RenderViewToStringAsync uses the Request services and ActionContext
    var htmlContent = await RenderViewToStringAsync("Invoice", invoiceModel);

    var renderer = new IronPdf.ChromePdfRenderer();
    // Optimize for memory-constrained containers
    renderer.RenderingOptions.UseMarginsOnHeaderAndFooter = UseMargins.All;
    renderer.RenderingOptions.MarginTop = renderer.RenderingOptions.MarginBottom = 40;

    var pdf = renderer.RenderHtmlAsPdf(htmlContent, baseUrl: HttpContext.Request.Scheme + "://" + HttpContext.Request.Host);

    // Add monitoring metrics
    _logger.LogInformation($"PDF generated: Size={pdf.BinaryData.Length} bytes, Pages={pdf.PageCount}");

    return File(pdf.BinaryData, "application/pdf");
}
private async Task<string> RenderViewToStringAsync(string viewName, object model)
{
    // Use the current HttpContext's service provider (guaranteed available during a request)
    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)
    {
        // Helpful error for debugging
        var searchedLocations = string.Join(Environment.NewLine, viewResult.SearchedLocations ?? Array.Empty<string>());
        throw new InvalidOperationException($"Couldn't find view '{viewName}'. Searched locations:{Environment.NewLine}{searchedLocations}");
    }
    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.Extensions.DependencyInjection
Imports Microsoft.Extensions.Logging
Imports IronPdf

Public Class YourController
    Inherits Controller

    Private ReadOnly _logger As ILogger(Of YourController)

    Public Sub New(logger As ILogger(Of YourController))
        _logger = logger
    End Sub

    Public Async Function ViewToPdf() As Task(Of IActionResult)
        Dim invoiceModel 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}
            }
        }
        invoiceModel.TotalAmount = invoiceModel.Items.Sum(Function(i) i.LineTotal)
        ' NOTE: RenderViewToStringAsync uses the Request services and ActionContext
        Dim htmlContent As String = Await RenderViewToStringAsync("Invoice", invoiceModel)

        Dim renderer As New ChromePdfRenderer()
        ' Optimize for memory-constrained containers
        renderer.RenderingOptions.UseMarginsOnHeaderAndFooter = UseMargins.All
        renderer.RenderingOptions.MarginTop = 40
        renderer.RenderingOptions.MarginBottom = 40

        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent, baseUrl:=HttpContext.Request.Scheme & "://" & HttpContext.Request.Host)

        ' Add monitoring metrics
        _logger.LogInformation($"PDF generated: Size={pdf.BinaryData.Length} bytes, Pages={pdf.PageCount}")

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

    Private Async Function RenderViewToStringAsync(viewName As String, model As Object) As Task(Of String)
        ' Use the current HttpContext's service provider (guaranteed available during a request)
        Dim actionContext As New ActionContext(HttpContext, RouteData, ControllerContext.ActionDescriptor)
        Dim viewEngine = HttpContext.RequestServices.GetRequiredService(Of IRazorViewEngine)()
        Dim tempDataFactory = HttpContext.RequestServices.GetRequiredService(Of ITempDataDictionaryFactory)()
        Dim tempData = tempDataFactory.GetTempData(HttpContext)
        ViewData.Model = model
        Dim viewResult = viewEngine.FindView(actionContext, viewName, isMainPage:=False)
        If Not viewResult.Success Then
            ' Helpful error for debugging
            Dim searchedLocations = String.Join(Environment.NewLine, viewResult.SearchedLocations ?? Array.Empty(Of String)())
            Throw New InvalidOperationException($"Couldn't find view '{viewName}'. Searched locations:{Environment.NewLine}{searchedLocations}")
        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?

Die PDF-Rechnung Nr. 1001 für Acme Corp. mit zwei Positionen über insgesamt 250,00 $ wird in einem Webbrowser angezeigt und demonstriert die erfolgreiche Konvertierung von Razor View in PDF.

Diese Hilfsmethode stellt sicher, dass Sie einen sauberen Weg haben, um den Inhalt Ihrer Razor-Ansicht in eine HTML-Zeichenfolge zu rendern, die IronPDF dann konvertieren kann. Das Razor-zu-PDF-Tutorial beschreibt diesen Arbeitsablauf im Detail. Für Blazor-Anwendungen funktionieren ähnliche Ansätze beim Komponenten-Rendering.

Wie kann man große PDF-Dateien mit Streaming bearbeiten?

Bei der Verarbeitung großer PDF-Dokumente in Containerumgebungen verbessert Streaming die Leistung und reduziert den Speicherverbrauch. Die Verwendung eines MemoryStream ermöglicht es Ihnen, Dateien effizient bereitzustellen und gleichzeitig den Speicherbedarf gering zu halten:

public IActionResult StreamLargePdf()
{
    var renderer = new ChromePdfRenderer();
    // Configure for memory efficiency
    renderer.RenderingOptions.CreatePdfFormsFromHtml = false; // Reduce memory if forms not needed

    var pdf = renderer.RenderHtmlAsPdf("<h1>Large Document</h1><p>Content here...</p>");

    // Optional: Compress for reduced bandwidth
    pdf.CompressImages(80); // 80% quality

    var stream = new MemoryStream(pdf.BinaryData);

    // Set response headers for optimal streaming
    Response.Headers.Add("Content-Length", pdf.BinaryData.Length.ToString());
    Response.Headers.Add("Accept-Ranges", "bytes");

    return new FileStreamResult(stream, "application/pdf");
}

// Async version for better container performance
public async Task<IActionResult> StreamLargePdfAsync()
{
    var renderer = new ChromePdfRenderer();
    var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Large Document</h1><p>Content here...</p>");

    var stream = new MemoryStream(pdf.BinaryData);
    return new FileStreamResult(stream, "application/pdf");
}
public IActionResult StreamLargePdf()
{
    var renderer = new ChromePdfRenderer();
    // Configure for memory efficiency
    renderer.RenderingOptions.CreatePdfFormsFromHtml = false; // Reduce memory if forms not needed

    var pdf = renderer.RenderHtmlAsPdf("<h1>Large Document</h1><p>Content here...</p>");

    // Optional: Compress for reduced bandwidth
    pdf.CompressImages(80); // 80% quality

    var stream = new MemoryStream(pdf.BinaryData);

    // Set response headers for optimal streaming
    Response.Headers.Add("Content-Length", pdf.BinaryData.Length.ToString());
    Response.Headers.Add("Accept-Ranges", "bytes");

    return new FileStreamResult(stream, "application/pdf");
}

// Async version for better container performance
public async Task<IActionResult> StreamLargePdfAsync()
{
    var renderer = new ChromePdfRenderer();
    var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Large Document</h1><p>Content here...</p>");

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

Public Class PdfController
    Inherits Controller

    Public Function StreamLargePdf() As IActionResult
        Dim renderer As New ChromePdfRenderer()
        ' Configure for memory efficiency
        renderer.RenderingOptions.CreatePdfFormsFromHtml = False ' Reduce memory if forms not needed

        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Large Document</h1><p>Content here...</p>")

        ' Optional: Compress for reduced bandwidth
        pdf.CompressImages(80) ' 80% quality

        Dim stream As New MemoryStream(pdf.BinaryData)

        ' Set response headers for optimal streaming
        Response.Headers.Add("Content-Length", pdf.BinaryData.Length.ToString())
        Response.Headers.Add("Accept-Ranges", "bytes")

        Return New FileStreamResult(stream, "application/pdf")
    End Function

    ' Async version for better container performance
    Public Async Function StreamLargePdfAsync() As Task(Of IActionResult)
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = Await renderer.RenderHtmlAsPdfAsync("<h1>Large Document</h1><p>Content here...</p>")

        Dim stream As New MemoryStream(pdf.BinaryData)
        Return New FileStreamResult(stream, "application/pdf")
    End Function

End Class
$vbLabelText   $csharpLabel

Für ältere ASP.NET Web Forms- Projekte können Sie eine ähnliche Funktionalität mithilfe von Ereignisbehandlern mit entsprechender Ressourcenbereinigung implementieren:

protected void btnGeneratePdf_Click(object sender, EventArgs e)
{
    using (var renderer = new ChromePdfRenderer())
    {
        var 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())
    {
        var 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 = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Web Form PDF</h1>")
        Response.ContentType = "application/pdf"
        Response.BinaryWrite(pdf.BinaryData)
        Response.End()
    End Using
End Sub
$vbLabelText   $csharpLabel

Für Szenarien mit hohen Leistungsanforderungen sollten Sie beim Generieren mehrerer PDFs die Verwendung asynchroner Methoden und paralleler Verarbeitung in Betracht ziehen. Der IronPDF-Leistungsleitfaden bietet detaillierte Optimierungsstrategien.

Welche Funktionen unterstützt dieses PDF Viewer Control?

Durch die Nutzung des nativen PDF-Viewers des Browsers erhalten Ihre Benutzer automatisch eine Vielzahl von Funktionen: Textauswahl zum Kopieren von Inhalten, Suchfunktion zum Auffinden bestimmter Daten, Druckoptionen für physische Kopien und Download-Funktion für den Offline-Zugriff.

Dieser Ansatz eignet sich auch für Szenarien, in denen Benutzer ein bestehendes Dokument zum Anzeigen, Bearbeiten oder Zusammenführen hochladen müssen. Die serverseitige Verarbeitung von IronPDF übernimmt die Ausführung von JavaScript , das Rendern von CSS und die Formulare – einschließlich interaktiver Elemente, die Benutzer ausfüllen können.

Das Framework unterstützt die Integration von Tag-Helfern, benutzerdefinierte Seitengrößen , Kopf- und Fußzeilen , Wasserzeichen und sogar Bearbeitungsfunktionen . Für die Sicherheit bietet IronPDF Verschlüsselung , digitale Signaturen und PDF/A-Konformität für die Langzeitarchivierung.

Für containerisierte Bereitstellungen bietet IronPDF Folgendes:

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

Was sind die nächsten Schritte für die Umsetzung?

Die Erstellung eines PDF-Viewers in einer ASP.NET-Webanwendung ist mit IronPDF denkbar einfach. Durch die Kombination der leistungsstarken Rendering-Engine mit dem im Browser integrierten PDF-Viewer erhalten Sie eine professionelle Lösung für die Anzeige, Verarbeitung und Handhabung von PDF-Dateien in Ihren Webanwendungen. Egal ob Sie HTML , URLs oder Razor-Ansichten konvertieren, die Implementierung erfordert minimalen Code bei maximaler Funktionalität.

Für Produktionsumgebungen sollten Sie Folgendes beachten:

Sind Sie bereit, die PDF-Anzeige in Ihrem Projekt zu implementieren? Starten Sie mit einer kostenlosen Testversion von IronPDF und verändern Sie den Umgang mit Dokumenten in Ihrer .NET Core-Webanwendung. Für den produktiven Einsatz sollten Sie sich die Lizenzierungsoptionen ansehen, die den Anforderungen Ihres Teams entsprechen. Möchten Sie weitere Konvertierungsbeispiele sehen? Erfahren Sie in den hilfreichen Anleitungen, wie IronPDF die Konvertierung von DOCX in PDF , von Bildern in PDF und mehr handhabt.

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