Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. IronPDF verwenden
  4. ASP.NET Core PDF-Viewer
IRONPDF NUTZEN

Wie man einen ASP.NET Core PDF-Viewer erstellt

Curtis Chau
Curtis Chau
Aktualisiert:

Ein ASP.NET Core PDF-Viewer sollte keine komplexen JavaScript-Bibliotheken oder Drittanbieter-Browser-Plugins erfordern. Moderne Webanwendungen benötigen eine zuverlässige Möglichkeit, PDF-Dateien direkt im Browser anzuzeigen, sei es für Rechnungen, Berichte oder interaktive PDF-Dokumente. IronPDF vereinfacht diesen Prozess, indem es die integrierten PDF-Viewer-Funktionen Ihres Browsers nutzt und gleichzeitig pixelgenaue PDFs auf der Serverseite generiert.

In diesem Artikel führen wir Sie durch die Erstellung und Anzeige von PDF-Dokumenten in Ihren ASP.NET Core-Projekten und zeigen, wie man PDF-Viewer-Anwendungen erstellt, die jedes PDF anzeigen können.

Was ist ein ASP.NET Core PDF Viewer?

Ein ASP.NET Core PDF-Viewer ermöglicht es Benutzern, PDF-Dokumente direkt innerhalb von Webanwendungen zu betrachten, ohne Dateien auf ihr Gerät herunterladen zu müssen. Anstatt mit JavaScript-basierten Dokumentbetrachterkomponenten zu kämpfen, verfolgt IronPDF einen erfrischend einfachen Ansatz: Es generiert hochwertige PDF-Dateien auf der Serverseite mit Chromes Rendering-Engine und liefert sie mit den richtigen Headern aus, sodass Browser PDF-Dateien automatisch inline anzeigen.

Dieser Server-seitige Ansatz bedeutet, dass Ihr ASP.NET Core PDF-Viewer in allen Browsern ohne zusätzliche Plugins wie Adobe Acrobat Reader konsistent funktioniert. Da IronPDF die gleiche Chrome-Engine verwendet, die Millionen von Browsern antreibt, werden Ihre PDF-Dokumente genau wie beabsichtigt gerendert und erhalten CSS-Stile, JavaScript-Interaktionen und komplexe Layouts. Die ASP.NET Core PDF-Integration übernimmt alles von der HTML- bis zur PDF-Konvertierung bis zur sicheren Dokumentbereitstellung mit langfristiger Unterstützung.

Wie installieren Sie IronPDF in Ihrer Webanwendung?

Die Installation von IronPDF in Ihrer .NET Core-Webanwendung erfordert nur einen Befehl des NuGet-Paketmanagers. Öffnen Sie Ihre Paketmanager-Konsole in Visual Studio und führen Sie aus:

Install-Package IronPdf

Konfigurieren Sie IronPDF nach der Installation in Ihrer Program.cs Datei, um Ihren Lizenzschlüssel einzurichten:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"; // Start with a free trial key
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"; // Start with a free trial key
Imports IronPdf

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY" ' Start with a free trial key
$vbLabelText   $csharpLabel

Diese einfache Einrichtung gibt Ihnen Zugriff auf die vollständige .NET Core PDF-Viewer-Funktionalität von IronPDF. Die Bibliothek übernimmt automatisch die Bereitstellung der Chrome-Engine und bietet eine saubere API zum Generieren und Anzeigen von PDF-Dateien in Ihren ASP.NET Core-Anwendungen.

Wie kann man einen einfachen PDF-Dokument-Viewer erstellen?

Die Erstellung Ihres ersten ASP.NET Core PDF-Viewers erfordert nur minimalen Code. Hier ist ein Controller, der HTML-Inhalte in ein anzeigbares PDF-Dokument konvertiert:

using IronPdf;
using Microsoft.AspNetCore.Mvc;

public class PdfController : Controller
{
    public IActionResult ViewDocument()
    {
        var renderer = new ChromePdfRenderer();

        // Create PDF from HTML string
        var html = @"
            <html>
                <body style='font-family: Arial; padding: 20px;'>
                    <h1>Invoice #2024-001</h1>
                    <p>This PDF document is displayed directly in your browser.</p>
                    <table style='width: 100%; border-collapse: collapse;'>
                        <tr>
                            <td style='border: 1px solid #ddd; padding: 8px;'>Item</td>
                            <td style='border: 1px solid #ddd; padding: 8px;'>Price</td>
                        </tr>
                        <tr>
                            <td style='border: 1px solid #ddd; padding: 8px;'>Service</td>
                            <td style='border: 1px solid #ddd; padding: 8px;'>$99.00</td>
                        </tr>
                    </table>
                </body>
            </html>";
        var pdf = renderer.RenderHtmlAsPdf(html);

        // Return PDF for inline viewing
        Response.Headers.Add("Content-Disposition", "inline; filename=invoice.pdf");
        return File(pdf.BinaryData, "application/pdf");
    }
}
using IronPdf;
using Microsoft.AspNetCore.Mvc;

public class PdfController : Controller
{
    public IActionResult ViewDocument()
    {
        var renderer = new ChromePdfRenderer();

        // Create PDF from HTML string
        var html = @"
            <html>
                <body style='font-family: Arial; padding: 20px;'>
                    <h1>Invoice #2024-001</h1>
                    <p>This PDF document is displayed directly in your browser.</p>
                    <table style='width: 100%; border-collapse: collapse;'>
                        <tr>
                            <td style='border: 1px solid #ddd; padding: 8px;'>Item</td>
                            <td style='border: 1px solid #ddd; padding: 8px;'>Price</td>
                        </tr>
                        <tr>
                            <td style='border: 1px solid #ddd; padding: 8px;'>Service</td>
                            <td style='border: 1px solid #ddd; padding: 8px;'>$99.00</td>
                        </tr>
                    </table>
                </body>
            </html>";
        var pdf = renderer.RenderHtmlAsPdf(html);

        // Return PDF for inline viewing
        Response.Headers.Add("Content-Disposition", "inline; filename=invoice.pdf");
        return File(pdf.BinaryData, "application/pdf");
    }
}
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc

Public Class PdfController
    Inherits Controller

    Public Function ViewDocument() As IActionResult
        Dim renderer = New ChromePdfRenderer()

        ' Create PDF from HTML string
        Dim html = "
            <html>
                <body style='font-family: Arial; padding: 20px;'>
                    <h1>Invoice #2024-001</h1>
                    <p>This PDF document is displayed directly in your browser.</p>
                    <table style='width: 100%; border-collapse: collapse;'>
                        <tr>
                            <td style='border: 1px solid #ddd; padding: 8px;'>Item</td>
                            <td style='border: 1px solid #ddd; padding: 8px;'>Price</td>
                        </tr>
                        <tr>
                            <td style='border: 1px solid #ddd; padding: 8px;'>Service</td>
                            <td style='border: 1px solid #ddd; padding: 8px;'>$99.00</td>
                        </tr>
                    </table>
                </body>
            </html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)

        ' Return PDF for inline viewing
        Response.Headers.Add("Content-Disposition", "inline; filename=invoice.pdf")
        Return File(pdf.BinaryData, "application/pdf")
    End Function
End Class
$vbLabelText   $csharpLabel

Die Klasse ChromePdfRenderer übernimmt die Konvertierungsverarbeitung und wandelt Ihr HTML in ein PDF-Dokument um. Durch die Einstellung des Headers Content-Disposition auf "inline" wird dem Browser mitgeteilt, dass die PDF-Datei angezeigt und nicht heruntergeladen werden soll. Dadurch entsteht ein nahtloses PDF-Viewer-Erlebnis, bei dem Benutzer PDF-Dateien direkt in ihrer Webanwendung anzeigen können.

PDF-Dokument in Browser-Viewer ausgeben

So erstellen Sie einen ASP.NET Core PDF-Viewer: Abbildung 1 – PDF in unserem Browser-PDF-Viewer

Wie zeigt man PDF-Dateien aus verschiedenen Quellen an?

Ihr ASP.NET Core PDF-Viewer kann PDF-Dateien aus verschiedenen Paketquellen generieren. Hier erfahren Sie, wie Sie eine URL in ein anzeigbares PDF konvertieren:

public IActionResult ViewFromUrl(string websiteUrl)
{
    var renderer = new ChromePdfRenderer();

    // Configure rendering options
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.WaitFor.RenderDelay = 2000; // Wait for content to load
    var pdf = renderer.RenderUrlAsPdf(websiteUrl);
    Response.Headers.Add("Content-Disposition", "inline");
    return File(pdf.BinaryData, "application/pdf");
}
public IActionResult ViewFromUrl(string websiteUrl)
{
    var renderer = new ChromePdfRenderer();

    // Configure rendering options
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.WaitFor.RenderDelay = 2000; // Wait for content to load
    var pdf = renderer.RenderUrlAsPdf(websiteUrl);
    Response.Headers.Add("Content-Disposition", "inline");
    return File(pdf.BinaryData, "application/pdf");
}
Imports IronPdf

Public Function ViewFromUrl(websiteUrl As String) As IActionResult
    Dim renderer As New ChromePdfRenderer()

    ' Configure rendering options
    renderer.RenderingOptions.EnableJavaScript = True
    renderer.RenderingOptions.WaitFor.RenderDelay = 2000 ' Wait for content to load
    Dim pdf = renderer.RenderUrlAsPdf(websiteUrl)
    Response.Headers.Add("Content-Disposition", "inline")
    Return File(pdf.BinaryData, "application/pdf")
End Function
$vbLabelText   $csharpLabel

Ausgabe

So erstellen Sie einen ASP.NET Core PDF-Viewer: Abbildung 2 – PDF, das von einer URL gerendert und in unserem PDF-Viewer-Programm angezeigt wird

Für bereits auf dem Server gespeicherte PDF-Dateien können Sie diese einfach laden und anzeigen. Dieser Beispielcode zeigt, wie Sie mit Dateien in Ihrem Ordner wwwroot arbeiten können:

public IActionResult ViewExistingPdf(string fileName)
{
    // Load PDF from wwwroot folder
    var pdfPath = Path.Combine(_webHostEnvironment.WebRootPath, "documents", fileName);
    var pdf = PdfDocument.FromFile(pdfPath);   
    // Optional: Add modifications like watermarks
    pdf.ApplyWatermark("<h2 style='color: red; opacity: 0.5;'>CONFIDENTIAL</h2>");
    return File(pdf.BinaryData, "application/pdf");
}
public IActionResult ViewExistingPdf(string fileName)
{
    // Load PDF from wwwroot folder
    var pdfPath = Path.Combine(_webHostEnvironment.WebRootPath, "documents", fileName);
    var pdf = PdfDocument.FromFile(pdfPath);   
    // Optional: Add modifications like watermarks
    pdf.ApplyWatermark("<h2 style='color: red; opacity: 0.5;'>CONFIDENTIAL</h2>");
    return File(pdf.BinaryData, "application/pdf");
}
Public Function ViewExistingPdf(fileName As String) As IActionResult
    ' Load PDF from wwwroot folder
    Dim pdfPath = Path.Combine(_webHostEnvironment.WebRootPath, "documents", fileName)
    Dim pdf = PdfDocument.FromFile(pdfPath)
    ' Optional: Add modifications like watermarks
    pdf.ApplyWatermark("<h2 style='color: red; opacity: 0.5;'>CONFIDENTIAL</h2>")
    Return File(pdf.BinaryData, "application/pdf")
End Function
$vbLabelText   $csharpLabel

So erstellen Sie einen ASP.NET Core PDF-Viewer: Abbildung 3 – Anzeigen einer vorhandenen PDF-Datei (mit unserem hinzugefügten Wasserzeichen)

Diese Flexibilität bedeutet, dass Ihr PDF-Viewer sowohl dynamisch generierte Inhalte als auch vorhandene PDF-Dokumente verarbeiten kann, die in Ihrem wwwroot Ordner oder Ihrer Datenbank gespeichert sind. Die Komponente integriert sich nahtlos in Ihre ASP.NET Core-Architektur.

Wie kann man erweiterte PDF-Viewer-Funktionen hinzufügen?

IronPDF verwandelt Ihren einfachen PDF-Viewer in einen leistungsstarken Dokument-Viewer mit erweiterten Funktionen. Das Hinzufügen von Formularen zu Ihren PDF-Dateien ermöglicht interaktive Funktionen, die Benutzer direkt ausfüllen können:

public IActionResult CreateFormPdf()
{
    var html = @"
        <html>
            <body>
                <h2>Application Form</h2>
                <form>
                    Name: 
                    <br><br>
                    Email: 
                    <br><br>
                    <input type='checkbox'> I agree to terms
                </form>
            </body>
        </html>";
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CreatePdfFormsFromHtml = true; // Enable form fields
    var pdf = renderer.RenderHtmlAsPdf(html);
    return File(pdf.BinaryData, "application/pdf");
}
public IActionResult CreateFormPdf()
{
    var html = @"
        <html>
            <body>
                <h2>Application Form</h2>
                <form>
                    Name: 
                    <br><br>
                    Email: 
                    <br><br>
                    <input type='checkbox'> I agree to terms
                </form>
            </body>
        </html>";
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CreatePdfFormsFromHtml = true; // Enable form fields
    var pdf = renderer.RenderHtmlAsPdf(html);
    return File(pdf.BinaryData, "application/pdf");
}
Public Function CreateFormPdf() As IActionResult
    Dim html As String = "
        <html>
            <body>
                <h2>Application Form</h2>
                <form>
                    Name: 
                    <br><br>
                    Email: 
                    <br><br>
                    <input type='checkbox'> I agree to terms
                </form>
            </body>
        </html>"
    Dim renderer As New ChromePdfRenderer()
    renderer.RenderingOptions.CreatePdfFormsFromHtml = True ' Enable form fields
    Dim pdf = renderer.RenderHtmlAsPdf(html)
    Return File(pdf.BinaryData, "application/pdf")
End Function
$vbLabelText   $csharpLabel

Ausgabe mit ausfüllbarem Formular

So erstellen Sie einen ASP.NET Core PDF-Viewer: Abbildung 4

Wenn Benutzer dieses PDF in ihrem Browser öffnen, können sie die Formulare direkt ausfüllen, ohne externe Tools zu benötigen. Sie können PDF-Dateien auch bearbeiten, indem Sie Kopf- und Fußzeilen, Seitennummern oder digitale Signaturen hinzufügen. Der Tag-Helfer-Ansatz macht es einfach, diese Funktionen hinzuzufügen:

// Add headers and page numbers
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align: center;'>Company Report</div>",
    MaxHeight = 25
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align: center;'>Page {page} of {total-pages}</div>",
    MaxHeight = 25
};
// Add headers and page numbers
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align: center;'>Company Report</div>",
    MaxHeight = 25
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align: center;'>Page {page} of {total-pages}</div>",
    MaxHeight = 25
};
Imports System

' Add headers and page numbers
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
    .HtmlFragment = "<div style='text-align: center;'>Company Report</div>",
    .MaxHeight = 25
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
    .HtmlFragment = "<div style='text-align: center;'>Page {page} of {total-pages}</div>",
    .MaxHeight = 25
}
$vbLabelText   $csharpLabel

Diese Funktionen verwandeln Ihren ASP.NET PDF-Viewer in eine umfassende Lösung für das Dokumentenmanagement und unterstützen alles vom einfachen Anzeigen bis hin zu komplexen Bearbeitungsvorgängen, einschließlich Textauswahl und Druckfunktionalität. Sie können sogar mit anderen Formaten wie Excel, Word, DOCX-Dateien und PowerPoint durch die Konvertierungsfähigkeiten von IronPDF arbeiten.

Abschluss

Die Erstellung eines ASP.NET Core PDF-Viewers mit IronPDF beseitigt die Komplexität JavaScript-basierter Lösungen und bietet professionelles PDF-Dokumentenmanagement. Durch die Nutzung der nativen Fähigkeiten des Browsers und der Rendering-Engine von Chrome können Sie PDF-Dateien mit nur wenigen Codezeilen erstellen, anzeigen und verwalten - ohne Standardkonfigurationen oder komplexe Setups.

Die Kombination aus Serverseitengenerierung und Browser-basierter Anzeige bietet die perfekte Balance aus Unterstützung, Leistung und Benutzererfahrung für Ihre Webanwendungen. Ob Sie PDF-Dateien anzeigen, Formulare verarbeiten, bestehende Dokumente bearbeiten oder PDFs drucken müssen, die unkomplizierte API von IronPDF macht die Implementierung einfach. Die Bibliothek wird regelmäßig aktualisiert, um die Kompatibilität mit den neuesten .NET-Frameworks und Windows-Umgebungen sicherzustellen.

Bereit, Ihren eigenen PDF-Viewer in Ihrem ASP.NET Core-Projekt zu erstellen? Beginnen Sie mit einer kostenlosen Testversion, um den richtigen Plan zu finden. Brauchen Sie Hilfe beim Einstieg? Schauen Sie sich dieses detaillierte Tutorial an oder durchsuchen Sie die vollständige Dokumentation für weitere Beispiele.

Häufig gestellte Fragen

Was ist der Zweck eines ASP.NET Core PDF-Viewers?

Ein ASP.NET Core PDF-Viewer ermöglicht es Ihnen, PDF-Dateien direkt im Browser anzuzeigen, sodass Benutzer Dokumente wie Rechnungen, Berichte oder interaktive PDFs ohne externe Plugins einfach anzeigen können.

Wie vereinfacht IronPDF die Erstellung eines PDF-Viewers in ASP.NET Core?

IronPDF vereinfacht den Prozess, indem es die integrierten PDF-Viewer-Fähigkeiten des Browsers nutzt und pixelgenaue PDFs auf der Serverseite erstellt, wodurch die Notwendigkeit komplexer JavaScript-Bibliotheken oder Drittanbieter-Plugins entfällt.

Kann IronPDF interaktive PDF-Dokumente verwalten?

Ja, IronPDF kann interaktive PDF-Dokumente verwalten, sodass Benutzer Formulare ausfüllen und direkt im Browser mit PDF-Inhalten interagieren können.

Was sind die Vorteile der Verwendung von IronPDF für die Anzeige von PDFs in Webanwendungen?

IronPDF bietet eine zuverlässige, effiziente Möglichkeit, PDFs in Webanwendungen anzuzeigen, mit Funktionen wie serverseitiger PDF-Erstellung und nahtloser Integration mit ASP.NET Core-Anwendungen.

Ist es notwendig, Drittanbieter-Browser-Plugins mit IronPDF zu verwenden?

Nein, IronPDF nutzt die integrierten PDF-Viewer-Fähigkeiten des Browsers, sodass keine Drittanbieter-Browser-Plugins erforderlich sind, um PDF-Dateien anzuzeigen.

Welche Arten von PDF-Dokumenten können mit einem ASP.NET Core PDF-Viewer angezeigt werden?

Ein ASP.NET Core PDF-Viewer kann verschiedene Arten von PDF-Dokumenten wie Rechnungen, Berichte und interaktive Formulare direkt im Browser anzeigen.

Unterstützt IronPDF die serverseitige PDF-Erstellung?

Ja, IronPDF unterstützt die serverseitige PDF-Erstellung und sorgt dafür, dass Dokumente vor der Anzeige im Browser genau und effizient gerendert werden.

Wie stellt IronPDF sicher, dass PDF-Darstellungen pixelgenau sind?

IronPDF sorgt für pixelgenaue PDF-Darstellung durch die Verwendung fortschrittlicher Algorithmen und Techniken zur getreuen Reproduktion des auf der Serverseite erstellten Erscheinungsbildes von Dokumenten.

Welche Programmiersprache wird verwendet, um mit IronPDF einen ASP.NET Core PDF-Viewer zu erstellen?

Der ASP.NET Core PDF-Viewer wird mit C# und dem ASP.NET Core-Framework erstellt, wobei IronPDF zur PDF-Verarbeitung und -Anzeige verwendet wird.

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