PDF to MemoryStream C

using IronPdf;
using System.IO;

// Load PDF from byte array
byte[] pdfBytes = File.ReadAllBytes("existing.pdf");
PdfDocument pdfFromBytes = new PdfDocument(pdfBytes);

// Or directly from a MemoryStream
MemoryStream memoryStream = new MemoryStream(pdfBytes);
PdfDocument pdfFromStream = new PdfDocument(memoryStream);

// Modify the PDF (add watermark, headers, etc.)
// Then export back to memory
byte[] modifiedPdfBytes = pdfFromStream.BinaryData;

Imports IronPdf
Imports System.IO

' Load PDF from byte array
Dim pdfBytes As Byte() = File.ReadAllBytes("existing.pdf")
Dim pdfFromBytes As New PdfDocument(pdfBytes)

' Or directly from a MemoryStream
Dim memoryStream As New MemoryStream(pdfBytes)
Dim pdfFromStream As New PdfDocument(memoryStream)

' Modify the PDF (add watermark, headers, etc.)
' Then export back to memory
Dim modifiedPdfBytes As Byte() = pdfFromStream.BinaryData

using IronPdf;
using System.IO;
using System.Collections.Generic;

// Create multiple PDFs in memory
var renderer = new ChromePdfRenderer();
List<MemoryStream> pdfStreams = new List<MemoryStream>();

// Generate multiple PDFs from HTML
string[] htmlTemplates = { 
    "<h1>Report 1</h1><p>Content...</p>", 
    "<h1>Report 2</h1><p>Content...</p>" 
};

foreach (var html in htmlTemplates)
{
    PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
    pdfStreams.Add(pdf.Stream);
}

// Merge all PDFs in memory
PdfDocument mergedPdf = PdfDocument.Merge(pdfStreams.Select(s =>
    new PdfDocument(s)).ToList());

// Get the final merged PDF as a stream
MemoryStream finalStream = mergedPdf.Stream;

Imports IronPdf
Imports System.IO
Imports System.Collections.Generic
Imports System.Linq

' Create multiple PDFs in memory
Dim renderer As New ChromePdfRenderer()
Dim pdfStreams As New List(Of MemoryStream)()

' Generate multiple PDFs from HTML
Dim htmlTemplates As String() = {
    "<h1>Report 1</h1><p>Content...</p>",
    "<h1>Report 2</h1><p>Content...</p>"
}

For Each html As String In htmlTemplates
    Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(html)
    pdfStreams.Add(pdf.Stream)
Next

' Merge all PDFs in memory
Dim mergedPdf As PdfDocument = PdfDocument.Merge(pdfStreams.Select(Function(s) New PdfDocument(s)).ToList())

' Get the final merged PDF as a stream
Dim finalStream As MemoryStream = mergedPdf.Stream

using System.Web.Mvc;
using System.IO;

public ActionResult ExportPdf()
{
    // Assume pdfAsStream is a MemoryStream containing PDF data
    MemoryStream pdfAsStream = new MemoryStream();

    return new FileStreamResult(pdfAsStream, "application/pdf")
    {
        FileDownloadName = "download.pdf"
    };
}

Imports System.Web.Mvc
Imports System.IO

Public Function ExportPdf() As ActionResult
	' Assume pdfAsStream is a MemoryStream containing PDF data
	Dim pdfAsStream As New MemoryStream()

	Return New FileStreamResult(pdfAsStream, "application/pdf") With {.FileDownloadName = "download.pdf"}
End Function

using System.Web.Mvc;
using IronPdf;

public ActionResult GenerateReport(string reportType)
{
    var renderer = new ChromePdfRenderer();

    // Configure rendering options for better output
    renderer.RenderingOptions.MarginTop = 50;
    renderer.RenderingOptions.MarginBottom = 50;
    renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;

    // Generate PDF based on report type
    string htmlContent = GetReportHtml(reportType);
    PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);

    // Add metadata
    pdf.MetaData.Author = "Your Application";
    pdf.MetaData.Title = $"{reportType} Report";

    // Return as downloadable file
    return File(pdf.Stream, "application/pdf", 
        $"{reportType}_Report_{DateTime.Now:yyyyMMdd}.pdf");
}

Imports System.Web.Mvc
Imports IronPdf

Public Function GenerateReport(reportType As String) As ActionResult
    Dim renderer As New ChromePdfRenderer()

    ' Configure rendering options for better output
    renderer.RenderingOptions.MarginTop = 50
    renderer.RenderingOptions.MarginBottom = 50
    renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait

    ' Generate PDF based on report type
    Dim htmlContent As String = GetReportHtml(reportType)
    Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlContent)

    ' Add metadata
    pdf.MetaData.Author = "Your Application"
    pdf.MetaData.Title = $"{reportType} Report"

    ' Return as downloadable file
    Return File(pdf.Stream, "application/pdf", $"{reportType}_Report_{DateTime.Now:yyyyMMdd}.pdf")
End Function

using System.IO;
using System.Web;

public class PdfHandler : IHttpHandler
{
    public void ProcessRequest(HttpContext context)
    {
        // Assume pdfAsStream is a MemoryStream containing PDF data
        MemoryStream pdfAsStream = new MemoryStream();

        context.Response.Clear();
        context.Response.ContentType = "application/octet-stream";
        context.Response.OutputStream.Write(pdfAsStream.ToArray(), 0, (int)pdfAsStream.Length);
        context.Response.Flush();
    }

    public bool IsReusable => false;
}

Imports System.IO
Imports System.Web

Public Class PdfHandler
	Implements IHttpHandler

	Public Sub ProcessRequest(ByVal context As HttpContext) Implements IHttpHandler.ProcessRequest
		' Assume pdfAsStream is a MemoryStream containing PDF data
		Dim pdfAsStream As New MemoryStream()

		context.Response.Clear()
		context.Response.ContentType = "application/octet-stream"
		context.Response.OutputStream.Write(pdfAsStream.ToArray(), 0, CInt(pdfAsStream.Length))
		context.Response.Flush()
	End Sub

	Public ReadOnly Property IsReusable() As Boolean Implements IHttpHandler.IsReusable
		Get
			Return False
		End Get
	End Property
End Class

using Microsoft.AspNetCore.Mvc;
using IronPdf;
using System.Threading.Tasks;

[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
    [HttpGet("generate")]
    public async Task<IActionResult> GeneratePdf()
    {
        var renderer = new ChromePdfRenderer();

        // Render HTML to PDF asynchronously for better performance
        PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Dynamic PDF</h1>");

        // Return PDF as file stream
        return File(pdf.Stream, "application/pdf", "generated.pdf");
    }

    [HttpPost("convert")]
    public async Task<IActionResult> ConvertHtmlToPdf([FromBody] string htmlContent)
    {
        var renderer = new ChromePdfRenderer();

        // Apply custom styling and rendering options
        renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;

        PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync(htmlContent);

        // Stream directly to response without saving to disk
        return File(pdf.Stream, "application/pdf");
    }
}

Imports Microsoft.AspNetCore.Mvc
Imports IronPdf
Imports System.Threading.Tasks

<ApiController>
<Route("api/[controller]")>
Public Class PdfController
    Inherits ControllerBase

    <HttpGet("generate")>
    Public Async Function GeneratePdf() As Task(Of IActionResult)
        Dim renderer As New ChromePdfRenderer()

        ' Render HTML to PDF asynchronously for better performance
        Dim pdf As PdfDocument = Await renderer.RenderHtmlAsPdfAsync("<h1>Dynamic PDF</h1>")

        ' Return PDF as file stream
        Return File(pdf.Stream, "application/pdf", "generated.pdf")
    End Function

    <HttpPost("convert")>
    Public Async Function ConvertHtmlToPdf(<FromBody> htmlContent As String) As Task(Of IActionResult)
        Dim renderer As New ChromePdfRenderer()

        ' Apply custom styling and rendering options
        renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
        renderer.RenderingOptions.PrintHtmlBackgrounds = True

        Dim pdf As PdfDocument = Await renderer.RenderHtmlAsPdfAsync(htmlContent)

        ' Stream directly to response without saving to disk
        Return File(pdf.Stream, "application/pdf")
    End Function
End Class

// Example of proper resource management with caching
public class PdfService
{
    private readonly IMemoryCache _cache;
    private readonly ChromePdfRenderer _renderer;

    public PdfService(IMemoryCache cache)
    {
        _cache = cache;
        _renderer = new ChromePdfRenderer();
    }

    public async Task<byte[]> GetCachedPdfAsync(string cacheKey, string htmlContent)
    {
        // Try to get from cache first
        if (_cache.TryGetValue(cacheKey, out byte[] cachedPdf))
        {
            return cachedPdf;
        }

        // Generate PDF if not in cache
        using (var pdf = await _renderer.RenderHtmlAsPdfAsync(htmlContent))
        {
            byte[] pdfBytes = pdf.BinaryData;

            // Cache for 10 minutes
            _cache.Set(cacheKey, pdfBytes, TimeSpan.FromMinutes(10));

            return pdfBytes;
        }
    }
}

Imports System
Imports System.Threading.Tasks

' Example of proper resource management with caching
Public Class PdfService
    Private ReadOnly _cache As IMemoryCache
    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New(cache As IMemoryCache)
        _cache = cache
        _renderer = New ChromePdfRenderer()
    End Sub

    Public Async Function GetCachedPdfAsync(cacheKey As String, htmlContent As String) As Task(Of Byte())
        ' Try to get from cache first
        Dim cachedPdf As Byte() = Nothing
        If _cache.TryGetValue(cacheKey, cachedPdf) Then
            Return cachedPdf
        End If

        ' Generate PDF if not in cache
        Using pdf = Await _renderer.RenderHtmlAsPdfAsync(htmlContent)
            Dim pdfBytes As Byte() = pdf.BinaryData

            ' Cache for 10 minutes
            _cache.Set(cacheKey, pdfBytes, TimeSpan.FromMinutes(10))

            Return pdfBytes
        End Using
    End Function
End Class