메시지 아이콘
푸터 콘텐츠로 바로가기
  1. IronPDF
  2. IronPDF 블로그
  3. Ironpdf 사용
  4. ASP NET PDF 뷰어에서 PDF 표시
IRONPDF 사용

How to Display, Save, and Print PDFs in an ASP.NET Core Viewer

커티스 차우
커티스 차우
업데이트됨:

How to Display, Save, and Print PDFs in an ASP.NET Core Viewer

IronPDF enables seamless PDF viewing in ASP.NET Core applications by generating PDFs server-side and leveraging browsers' built-in PDF viewers, eliminating the need for plugins while supporting cross-platform deployment in Docker containers and cloud environments.

Displaying PDF documents directly in web browsers has become an essential requirement for modern ASP.NET Core web applications. Whether you're generating invoices, reports, or contracts, users expect seamless PDF viewing without needing to download files or install Adobe Acrobat Reader. This tutorial demonstrates how IronPDF simplifies PDF display, saving, and printing in your ASP.NET Core viewer through its powerful Chrome-based rendering engine.

How Do Browsers Handle PDF Viewing in ASP.NET Core?

Modern browsers include built-in PDF viewers that activate when they receive a PDF file with the correct MIME type (application/pdf). When your ASP.NET Core application returns a PDF document with appropriate headers, the browser automatically displays it inline. This eliminates the need for external plugins, Adobe Acrobat Reader, or complex JavaScript libraries. According to MDN Web Docs, proper header configuration is essential for controlling how browsers handle file downloads and displays.

IronPDF leverages this browser capability by generating high-quality PDFs server-side using its ChromePdfRenderer class. The renderer uses a complete Chrome engine under the hood, ensuring your documents display exactly as intended with full support for modern CSS, JavaScript, digital signatures, and web fonts. Unlike simple document viewers, IronPDF provides complete control over PDF processing and rendering.

What Tools Do You Need to Display/View PDF Files in ASP.NET Core?

Setting up IronPDF in your ASP.NET Core project takes just a few steps. First, create a new project in Visual Studio or via the command line. Open Visual Studio and select the ASP.NET Core Web Application project template:

dotnet new mvc -n PdfViewerApp
cd PdfViewerApp
dotnet new mvc -n PdfViewerApp
cd PdfViewerApp
SHELL

How Do You Install IronPDF in Your .NET Project?

Install IronPDF via NuGet Package Manager in your project:

Install-Package IronPdf

Or in Solution Explorer, right-click on your project and select "Manage NuGet Packages." Choose the appropriate package source and search for IronPDF.

That's all the setup required. IronPDF works seamlessly with ASP.NET Core 3.1 and later (long-term support versions), including .NET 6, 7, and 8. The library receives frequent updates to ensure compatibility with the latest frameworks. For detailed installation instructions, visit the IronPDF installation guide. The package includes all necessary components for PDF generation, editing, and processing. For Docker deployments, IronPDF provides optimized container images that minimize deployment complexity—a critical consideration for DevOps engineers managing containerized environments.

How Can You Display PDF Files in the Browser Using ASP.NET Core?

Creating and displaying PDFs in the browser requires just a few lines of code. Here's a complete controller action that generates a PDF from HTML and displays it inline:

using IronPdf;
using Microsoft.AspNetCore.Mvc;

public class PdfController : Controller
{
    public IActionResult ViewPdf()
    {
        var renderer = new ChromePdfRenderer();
        // Configure rendering options for the PDF viewer
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
        renderer.RenderingOptions.EnableJavaScript = true;
        // Generate PDF from HTML string
        var html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; width: 100%; }
                </style>
            </head>
            <body>
                <h1>Invoice #12345</h1>
                <div class='content'>
                    <p>Date: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
                    <p>Thank you for your business!</p>
                </div>
            </body>
            </html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        // Return PDF for inline viewing in the browser
        return File(pdf.BinaryData, "application/pdf");
    }
}
using IronPdf;
using Microsoft.AspNetCore.Mvc;

public class PdfController : Controller
{
    public IActionResult ViewPdf()
    {
        var renderer = new ChromePdfRenderer();
        // Configure rendering options for the PDF viewer
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
        renderer.RenderingOptions.EnableJavaScript = true;
        // Generate PDF from HTML string
        var html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; width: 100%; }
                </style>
            </head>
            <body>
                <h1>Invoice #12345</h1>
                <div class='content'>
                    <p>Date: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
                    <p>Thank you for your business!</p>
                </div>
            </body>
            </html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        // Return PDF for inline viewing in the browser
        return File(pdf.BinaryData, "application/pdf");
    }
}
$vbLabelText   $csharpLabel

The code creates a ChromePdfRenderer instance and configures it to include background colors and convert HTML forms to PDF forms. The RenderHtmlAsPdf method transforms the HTML string into a PDF. Returning the PDF with the application/pdf MIME type tells the browser to display it inline rather than downloading it. This server-side approach ensures consistent rendering across all browsers and platforms—essential for maintaining reliability in Azure deployments and AWS Lambda environments.

Output

PDF viewer interface showing a simple invoice document with invoice number 12345 dated 2025-10-30. The ASP.NET Core PDF viewer successfully displays a rendered invoice document with page navigation controls and zoom options in the toolbar.

For existing HTML files or Razor pages, you can use alternative rendering methods:

// Render from URL - useful for complex pages
var pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_58___");
// Render from HTML file in the same location
var pdf = renderer.RenderHtmlFileAsPdf("Views/Invoice.html");
// Render from wwwroot folder
var pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report.html");
// For containerized applications, use environment-specific paths
var basePath = Environment.GetEnvironmentVariable("APP_BASE_PATH") ?? "wwwroot";
var pdf = renderer.RenderHtmlFileAsPdf($"{basePath}/templates/report.html");
// Render from URL - useful for complex pages
var pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_58___");
// Render from HTML file in the same location
var pdf = renderer.RenderHtmlFileAsPdf("Views/Invoice.html");
// Render from wwwroot folder
var pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report.html");
// For containerized applications, use environment-specific paths
var basePath = Environment.GetEnvironmentVariable("APP_BASE_PATH") ?? "wwwroot";
var pdf = renderer.RenderHtmlFileAsPdf($"{basePath}/templates/report.html");
$vbLabelText   $csharpLabel

These methods provide flexibility in how you source your HTML content while maintaining high-quality PDF output. You can also load existing PDF documents, edit PDFs, and work with Word (DOCX files) and Excel formats using IronPDF's comprehensive features. Learn more about HTML to PDF conversion options in the documentation. For advanced processing and editing capabilities, check the API reference.

For DevOps engineers managing microservices architectures, IronPDF's native vs remote engine architecture provides deployment flexibility. The remote engine option allows you to separate PDF rendering into a dedicated service, improving resource utilization and enabling horizontal scaling.

How Do Users Save PDF Documents from the Browser?

To enable users to download PDFs instead of viewing them inline, modify the Content-Disposition header. This feature is essential for applications where users need offline access:

public IActionResult DownloadPdf()
{
    var renderer = new ChromePdfRenderer();
    // Create PDF with CSS styling and images
    var html = @"<h1>Download Me</h1>
                 <img src='logo.png' width='100' />";
    var pdf = renderer.RenderHtmlAsPdf(html, @"wwwroot/images");
    // Force download with custom filename
    return File(pdf.BinaryData, "application/pdf", "invoice-2024.pdf");
}

// Health check endpoint for container orchestration
[HttpGet("/health/pdf-generator")]
public IActionResult HealthCheck()
{
    try
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<p>Health Check</p>");
        return Ok(new { status = "healthy", timestamp = DateTime.UtcNow });
    }
    catch (Exception ex)
    {
        return StatusCode(503, new { status = "unhealthy", error = ex.Message });
    }
}
public IActionResult DownloadPdf()
{
    var renderer = new ChromePdfRenderer();
    // Create PDF with CSS styling and images
    var html = @"<h1>Download Me</h1>
                 <img src='logo.png' width='100' />";
    var pdf = renderer.RenderHtmlAsPdf(html, @"wwwroot/images");
    // Force download with custom filename
    return File(pdf.BinaryData, "application/pdf", "invoice-2024.pdf");
}

// Health check endpoint for container orchestration
[HttpGet("/health/pdf-generator")]
public IActionResult HealthCheck()
{
    try
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<p>Health Check</p>");
        return Ok(new { status = "healthy", timestamp = DateTime.UtcNow });
    }
    catch (Exception ex)
    {
        return StatusCode(503, new { status = "unhealthy", error = ex.Message });
    }
}
$vbLabelText   $csharpLabel

Adding the filename parameter automatically sets the Content-Disposition header to "attachment," prompting the browser to download the file. Users can also save PDFs displayed inline using their browser's save functionality (Ctrl+S or the PDF viewer toolbar). The health check endpoint shown above is crucial for Kubernetes deployments and container orchestration platforms, ensuring your PDF service remains responsive.

Output

PDF viewer showing a document with 'Download Me' text and IronPDF for .NET logo, displayed in a browser at 100% zoom. The PDF viewer successfully displays the generated invoice document with download functionality enabled through IronPDF for .NET.

Why Should You Use Streams for Large PDF Files?

For better memory efficiency with large documents, use streams:

public IActionResult StreamPdf()
{
    var renderer = new ChromePdfRenderer();
    // Load and process HTML with images
    var html = "<h1>Streamed Content</h1>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    // Stream the PDF file to the browser
    var stream = pdf.Stream;
    stream.Position = 0;
    return File(stream, "application/pdf", "document.pdf");
}

// Async streaming for better resource utilization
public async Task<IActionResult> StreamPdfAsync()
{
    var renderer = new ChromePdfRenderer();
    // Configure for optimal container performance
    renderer.RenderingOptions.Timeout = 60000; // 60 seconds for complex documents
    renderer.RenderingOptions.RenderDelay = 500; // Allow JS to execute

    var html = await LoadHtmlTemplateAsync();
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));

    var stream = pdf.Stream;
    stream.Position = 0;
    return File(stream, "application/pdf", "async-document.pdf");
}
public IActionResult StreamPdf()
{
    var renderer = new ChromePdfRenderer();
    // Load and process HTML with images
    var html = "<h1>Streamed Content</h1>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    // Stream the PDF file to the browser
    var stream = pdf.Stream;
    stream.Position = 0;
    return File(stream, "application/pdf", "document.pdf");
}

// Async streaming for better resource utilization
public async Task<IActionResult> StreamPdfAsync()
{
    var renderer = new ChromePdfRenderer();
    // Configure for optimal container performance
    renderer.RenderingOptions.Timeout = 60000; // 60 seconds for complex documents
    renderer.RenderingOptions.RenderDelay = 500; // Allow JS to execute

    var html = await LoadHtmlTemplateAsync();
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));

    var stream = pdf.Stream;
    stream.Position = 0;
    return File(stream, "application/pdf", "async-document.pdf");
}
$vbLabelText   $csharpLabel

This approach reduces memory consumption by streaming PDFs directly to the response without creating intermediate byte arrays. You can also load existing PDFs from the wwwroot folder, edit them, and stream modified versions. For advanced PDF document manipulation and image processing, explore the PdfDocument API reference. The component supports various editing operations including text selection, form filling, and adding digital signatures.

For container deployments, the async PDF generation approach prevents blocking threads and improves application throughput—critical for maintaining responsive services in orchestrated environments.

Can Users Print PDF Documents Directly from ASP.NET Core Web Applications?

IronPDF optimizes PDFs for printing by configuring the appropriate CSS media type and page settings. This ensures professional output whether users print to physical printers or save as PDF:

public IActionResult PrintablePdf()
{
    var renderer = new ChromePdfRenderer();
    // Configure printing options for the PDF viewer
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
    renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
    renderer.RenderingOptions.MarginTop = 25;
    renderer.RenderingOptions.MarginBottom = 25;
    renderer.RenderingOptions.MarginLeft = 25;
    renderer.RenderingOptions.MarginRight = 25;
    // Load HTML with print-specific CSS
    var html = @"<h1>Print-Optimized Document</h1>
                 <p>This document is optimized for printing.</p>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    // Return the PDF file for viewing and printing
    return File(pdf.BinaryData, "application/pdf");
}

// Container-optimized configuration
public IActionResult ConfigureForContainer()
{
    var renderer = new ChromePdfRenderer();
    // Disable GPU for container compatibility
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.RenderDelay = 0; // No artificial delays
    renderer.RenderingOptions.Timeout = 30000; // 30 second timeout

    // Use environment variables for configuration
    var printDpi = int.Parse(Environment.GetEnvironmentVariable("PDF_PRINT_DPI") ?? "300");
    renderer.RenderingOptions.PrintHtmlBackgrounds = true;

    return Ok("Configured for container environment");
}
public IActionResult PrintablePdf()
{
    var renderer = new ChromePdfRenderer();
    // Configure printing options for the PDF viewer
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
    renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
    renderer.RenderingOptions.MarginTop = 25;
    renderer.RenderingOptions.MarginBottom = 25;
    renderer.RenderingOptions.MarginLeft = 25;
    renderer.RenderingOptions.MarginRight = 25;
    // Load HTML with print-specific CSS
    var html = @"<h1>Print-Optimized Document</h1>
                 <p>This document is optimized for printing.</p>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    // Return the PDF file for viewing and printing
    return File(pdf.BinaryData, "application/pdf");
}

// Container-optimized configuration
public IActionResult ConfigureForContainer()
{
    var renderer = new ChromePdfRenderer();
    // Disable GPU for container compatibility
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.RenderDelay = 0; // No artificial delays
    renderer.RenderingOptions.Timeout = 30000; // 30 second timeout

    // Use environment variables for configuration
    var printDpi = int.Parse(Environment.GetEnvironmentVariable("PDF_PRINT_DPI") ?? "300");
    renderer.RenderingOptions.PrintHtmlBackgrounds = true;

    return Ok("Configured for container environment");
}
$vbLabelText   $csharpLabel

Setting CssMediaType to Print applies print-specific CSS styles, ensuring the document looks correct when printed. The margin settings provide proper spacing for physical paper. Users can print PDFs directly from their browser's PDF viewer using the standard print dialog, maintaining full control over printer selection and settings. Learn more about PDF rendering options to fine-tune your output.

PDF viewer interface showing a print-optimized document with the message 'This document is optimized for printing' displayed in the center of a white page. The PDF viewer displays a confirmation message when a document has been optimized for printing, ensuring users know their file is ready for high-quality output.

How Does IronPDF Support Cross-Platform and Container Deployments?

IronPDF runs seamlessly across Windows, Linux, macOS, Docker containers, and cloud platforms like Azure and AWS. This cross-platform compatibility ensures your ASP.NET Core PDF viewer solution works consistently regardless of deployment environment. The library handles platform-specific rendering details internally, so your code works everywhere without modification.

Cross-platform support diagram showing .NET compatibility across multiple versions, operating systems, cloud platforms, and development environments. IronPDF's comprehensive cross-platform support includes compatibility with .NET 9 through Framework 4.6.2+, runs on Windows, Linux, and Mac, and integrates with major cloud providers and development tools.

The server-side processing ensures consistent PDF generation across all platforms. Whether deployed on Windows servers or Linux containers, the component maintains the same rendering quality. The library automatically manages path differences between operating systems, handling files in the wwwroot folder or other locations correctly. For containerized deployments, check the Docker deployment guide. The package includes all necessary dependencies for each platform, requiring no additional configuration beyond standard ASP.NET Core requirements.

For production container deployments, consider this Dockerfile example:

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80

# Install IronPDF dependencies for Linux
RUN apt-get update && apt-get install -y \
    libgdiplus \
    libc6-dev \
    libx11-6 \
    && rm -rf /var/lib/apt/lists/*

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["PdfViewerApp.csproj", "./"]
RUN dotnet restore "PdfViewerApp.csproj"
COPY . .
RUN dotnet build "PdfViewerApp.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "PdfViewerApp.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "PdfViewerApp.dll"]

Get started with a free trial and transform your document viewer capabilities today.

What Are the Key Benefits of Using IronPDF for ASP.NET Core PDF Viewing?

IronPDF transforms PDF handling in ASP.NET Core applications by combining server-side generation with browser-native viewing. With just a few lines of code, you can create professional PDFs from HTML, display them inline, enable downloads, and optimize for printing. The Chrome-based rendering engine ensures pixel-perfect accuracy across all platforms, eliminating the need for Adobe Acrobat Reader or third-party viewers.

This ASP.NET Core PDF viewer solution provides comprehensive features including form filling, text selection, digital signatures, and the ability to edit PDFs. The component also supports converting Word documents (DOCX files), Excel spreadsheets, and images to PDF. Whether you're building a simple document viewer or a complex document management system, IronPDF provides the tools you need.

The library's tag helper integration and extensive documentation make implementation straightforward. Your project can display PDFs directly while backend processing handles complex PDF generation tasks. The viewer maintains consistent behavior whether loading from the wwwroot folder, generating dynamically, or retrieving from external sources. With built-in theme support and customizable width settings, you can match your application's design perfectly. For DevOps teams, the IronPDF Slim package offers reduced deployment size, addressing container size constraints in orchestrated environments.

Ready to implement PDF viewing in your .NET Core Web Application?

For production use, licenses start at $799 and include comprehensive support and updates. Visit the documentation for detailed API references and advanced features. Refer to our extensive code examples to quickly implement PDF functionality in your ASP.NET Core projects.

IronPDF licensing page showing four perpetual license tiers (Lite, Plus, Professional, and Unlimited) with pricing, developer limits, and a toggle between IronPDF and Iron Suite options. IronPDF offers various licensing options ranging from $749 for single developers to $3,999 for unlimited usage, with all licenses including 1-year support and updates.

자주 묻는 질문

ASP.NET Core 애플리케이션에서 PDF를 표시하려면 어떻게 해야 하나요?

애플리케이션 내에서 직접 PDF 파일을 렌더링하는 기능을 제공하는 IronPDF를 사용하여 ASP.NET Core 애플리케이션에서 PDF를 표시할 수 있습니다.

IronPDF를 사용하여 ASP.NET Core에서 PDF를 저장하는 단계는 무엇인가요?

ASP.NET Core에서 PDF를 저장하려면 IronPDF에 내장된 메서드를 사용하여 문서를 PDF 형식으로 변환한 다음 파일 시스템이나 스트림에 쓸 수 있습니다.

ASP.NET Core 애플리케이션에서 PDF를 인쇄할 수 있나요?

예, IronPDF를 사용하면 렌더링 및 인쇄 기능을 사용하여 ASP.NET Core 애플리케이션에서 직접 PDF를 인쇄할 수 있습니다.

ASP.NET Core에서 IronPDF를 사용하면 어떤 이점이 있나요?

IronPDF는 ASP.NET Core와 원활하게 통합되어 최소한의 설정으로 보기, 저장, 인쇄 등의 PDF 조작을 쉽게 할 수 있습니다.

IronPDF는 ASP.NET Core에서 대용량 PDF 문서를 처리할 수 있나요?

예, IronPDF는 대용량 PDF 문서를 효율적으로 처리하도록 최적화되어 있어 복잡한 파일에서도 원활한 성능을 보장합니다.

IronPDF는 ASP.NET Core에서 PDF 주석 및 주석을 지원하나요?

IronPDF는 PDF에 주석과 주석을 추가하고 읽는 기능을 지원하여 ASP.NET Core 애플리케이션에서 PDF 문서의 상호 작용과 사용성을 향상시킵니다.

기존 ASP.NET Core 프로젝트에 IronPDF를 통합하려면 어떻게 해야 하나요?

IronPDF NuGet 패키지를 설치하고 해당 API를 사용하여 PDF를 관리함으로써 IronPDF를 ASP.NET Core 프로젝트에 통합할 수 있습니다.

ASP.NET Core와 함께 IronPDF를 사용하기 위한 특정 시스템 요구 사항이 있나요?

IronPDF는 .NET Core 또는 .NET 5+가 필요하며 모든 주요 운영 체제를 지원하므로 ASP.NET Core 프로젝트를 위한 유연한 선택이 될 수 있습니다.

IronPDF는 ASP.NET Core에서 다른 파일 형식을 PDF로 변환할 수 있나요?

예, IronPDF는 ASP.NET Core 환경 내에서 HTML, 이미지, 문서 등 다양한 파일 형식을 PDF로 변환할 수 있습니다.

IronPDF는 ASP.NET Core 개발자를 위해 어떤 종류의 지원을 제공하나요?

IronPDF는 포괄적인 문서, 코드 샘플 및 대응 지원을 제공하여 ASP.NET Core 개발자가 PDF 기능을 구현하는 데 도움을 줍니다.

커티스 차우
커티스 차우
  지금 바로 엔지니어링 팀과 채팅하세요
기술 문서 작성자

커티스 차우는 칼턴 대학교에서 컴퓨터 과학 학사 학위를 취득했으며, Node.js, TypeScript, JavaScript, React를 전문으로 하는 프론트엔드 개발자입니다. 직관적이고 미적으로 뛰어난 사용자 인터페이스를 만드는 데 열정을 가진 그는 최신 프레임워크를 활용하고, 잘 구성되고 시각적으로 매력적인 매뉴얼을 제작하는 것을 즐깁니다.

커티스는 개발 분야 외에도 사물 인터넷(IoT)에 깊은 관심을 가지고 있으며, 하드웨어와 소프트웨어를 통합하는 혁신적인 방법을 연구합니다. 여가 시간에는 게임을 즐기거나 디스코드 봇을 만들면서 기술에 대한 애정과 창의성을 결합합니다.

관련 기사

30일 무료 체험 → 모든 기능 이용 가능. 제한 없음. 카드 정보 필요 없음. 무료 체험 시작하기