1. IronPDF
  2. Tutoriais
  3. PDFs para a memória

PDF to MemoryStream C

Curtis Chau
Curtis Chau
Atualizado:
This article was translated from English: Does it need improvement?
Translated
View the article in English

Converta PDFs em MemoryStream em C# .NET usando a propriedade Stream ou BinaryData do IronPDF, permitindo a manipulação de PDFs na memória sem acesso ao sistema de arquivos para aplicações web e processamento de dados.

Em C# .NET, podemos exportar PDFs para MemoryStream sem acessar o sistema de arquivos. Isso é possível através do objeto MemoryStream presente dentro do namespace .NET System.IO. Essa abordagem é particularmente útil ao desenvolver aplicativos baseados em nuvem, ao trabalhar com o Armazenamento de Blobs do Azure ou quando você precisa processar PDFs na memória para otimizar o desempenho.

A capacidade de trabalhar com PDFs em fluxos de memória é essencial para aplicações web modernas, especialmente ao implantar no Azure ou em outras plataformas de nuvem onde o acesso ao sistema de arquivos pode ser restrito ou quando se deseja evitar a sobrecarga das operações de E/S de disco. O IronPDF simplifica esse processo com seus métodos integrados para manipulação de fluxos de dados.

Início rápido: Converter PDF para MemoryStream

Converta seus arquivos PDF em um MemoryStream usando a API do IronPDF. Este guia ajuda os desenvolvedores a começar a carregar um PDF e exportá-lo para um MemoryStream para integração em aplicativos .NET . Siga este exemplo para implementar funcionalidades de manipulação de PDF em C#.

  1. Instale IronPDF com o Gerenciador de Pacotes NuGet

    PM > Install-Package IronPdf

  2. Copie e execute este trecho de código.

    using var stream = new IronPdf.ChromePdfRenderer().RenderHtmlAsPdf("<h1>Hello Stream!</h1>").Stream;

  3. Implante para testar em seu ambiente de produção.

    Comece a usar IronPDF em seu projeto hoje com uma avaliação gratuita

    arrow pointer

Fluxo de trabalho mínimo (5 etapas)

  1. Baixe a biblioteca IronPDF C# para converter MemoryStream em PDF.
  2. Carregar um PDF existente como objeto **`PdfDocument`**
  3. Gere um novo PDF a partir de uma URL ou de uma string/arquivo HTML.
  4. Converter o PDF em um fluxo usando o método `Stream` e a propriedade **`BinaryData`**
  5. Disponibilize o MemoryStream para a Web, incluindo MVC e ASP.NET.

Como faço para salvar um PDF na memória?

Um código IronPdf.PdfDocument pode ser salvo diretamente na memória de duas maneiras:

A escolha entre usar Stream ou BinaryData depende do seu caso de uso específico. MemoryStream é ideal quando você precisa trabalhar com APIs baseadas em fluxo ou quando deseja manter a compatibilidade com outras operações de fluxo do .NET . O formato BinaryData como um array de bytes é perfeito para cenários em que você precisa armazenar os dados do PDF em um banco de dados, armazená-los em cache na memória ou transmiti-los por uma rede.

:path=/static-assets/pdf/content-code-examples/how-to/pdf-to-memory-stream-to-stream.cs
using IronPdf;
using System.IO;

var renderer = new ChromePdfRenderer();

// Convert the URL into PDF
PdfDocument pdf = renderer.RenderUrlAsPdf("https://ironpdf.com/");

// Export PDF as Stream
MemoryStream pdfAsStream = pdf.Stream;

// Export PDF as Byte Array
byte[] pdfAsByte = pdf.BinaryData;
Imports IronPdf
Imports System.IO

Private renderer = New ChromePdfRenderer()

' Convert the URL into PDF
Private pdf As PdfDocument = renderer.RenderUrlAsPdf("https://ironpdf.com/")

' Export PDF as Stream
Private pdfAsStream As MemoryStream = pdf.Stream

' Export PDF as Byte Array
Private pdfAsByte() As Byte = pdf.BinaryData
$vbLabelText   $csharpLabel

Trabalhando com PDFs existentes

Quando você precisa carregar PDFs da memória , o IronPDF oferece métodos convenientes para trabalhar com PDFs que já estão na memória:

using IronPdf;
using System.IO;

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

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

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

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

// Or directly from a MemoryStream
MemoryStream memoryStream = new MemoryStream(pdfBytes);
PdfDocument pdfFromStream = PdfDocument.FromFile(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 PdfDocument = PdfDocument.FromFile(New MemoryStream(pdfBytes))

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

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

Operações avançadas de fluxo de memória

Para cenários mais complexos, como a criação de PDFs a partir de strings HTML ou a conversão de várias imagens para PDF , você pode combinar diversas operações mantendo tudo na memória:

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 => 
    PdfDocument.FromFile(s)).ToList());

// Get the final merged PDF as a stream
MemoryStream finalStream = mergedPdf.Stream;
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 => 
    PdfDocument.FromFile(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) PdfDocument.FromFile(s)).ToList())

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

Como faço para disponibilizar um PDF na Web a partir da memória?

Para disponibilizar ou exportar um PDF na web, você precisa enviar o arquivo PDF como dados binários em vez de HTML. Você pode encontrar mais informações neste guia sobre como exportar e salvar documentos PDF em C# . Ao trabalhar com aplicações web, particularmente em ambientes ASP.NET MVC , servir PDFs a partir de fluxos de memória oferece diversas vantagens, incluindo melhor desempenho e menor uso de disco do servidor.

Aqui está um exemplo rápido para MVC e ASP.NET:

Como faço para exportar um PDF com MVC?

O fluxo no trecho de código abaixo são os dados binários recuperados do IronPDF. O tipo MIME da resposta é 'application/pdf', especificando o nome do arquivo como 'download.pdf'. Essa abordagem funciona perfeitamente com aplicações MVC modernas e pode ser integrada aos seus controladores existentes.

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"
    };
}
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
$vbLabelText   $csharpLabel

Para cenários mais avançados, como quando você está trabalhando com Razor Pages ou precisa implementar cabeçalhos personalizados:

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");
}
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
$vbLabelText   $csharpLabel

Como exportar um PDF com ASP.NET?

Semelhante ao exemplo acima, o fluxo são os dados binários recuperados do IronPDF. A resposta é então configurada e enviada para garantir que seja encaminhada ao cliente. Este método é particularmente útil para aplicações ASP.NET Web Forms ou quando você precisa de mais controle sobre a resposta HTTP.

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;
}
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
$vbLabelText   $csharpLabel

Para aplicações ASP.NET Core modernas, o processo é ainda mais simplificado:

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");
    }
}
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
$vbLabelText   $csharpLabel

Melhores práticas para gerenciamento de fluxo de memória

Ao trabalhar com fluxos de memória PDF em aplicações web, considere estas boas práticas:

  1. Libere os recursos corretamente : Sempre use instruções using ou libere explicitamente os objetos MemoryStream para evitar vazamentos de memória.

  2. Operações assíncronas : Para melhor escalabilidade, especialmente ao trabalhar com operações assíncronas , utilize métodos assíncronos sempre que disponíveis.

  3. Considerações sobre o tamanho do fluxo : Para PDFs grandes, considere implementar respostas em fluxo contínuo para evitar carregar o PDF inteiro na memória de uma só vez.

  4. Cache : Para PDFs acessados ​​com frequência, considere armazenar o array de bytes em cache na memória ou usar um cache distribuído para melhorar o desempenho.
// 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;
        }
    }
}
// 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
$vbLabelText   $csharpLabel

Seguindo esses padrões e utilizando os recursos de fluxo de memória do IronPDF, você pode criar aplicativos web eficientes e escaláveis ​​que lidam com a geração e distribuição de PDFs sem depender de operações do sistema de arquivos. Essa abordagem é particularmente benéfica ao implantar em plataformas de nuvem como a AWS ou ao trabalhar em ambientes conteinerizados.

Perguntas frequentes

Como posso converter um PDF em MemoryStream em C#?

O IronPDF oferece duas maneiras principais de converter PDFs para a memória: usando a propriedade Stream para exportar como System.IO.MemoryStream ou usando a propriedade BinaryData para exportar como uma matriz de bytes. Basta criar ou carregar um PdfDocument e acessar essas propriedades para trabalhar com PDFs na memória sem precisar modificar o sistema de arquivos.

Quais são as vantagens de trabalhar com PDFs na memória em vez de arquivos?

Trabalhar com PDFs na memória usando o IronPDF oferece diversas vantagens: melhor desempenho ao evitar operações de E/S em disco, maior compatibilidade com plataformas em nuvem como o Azure, onde o acesso ao sistema de arquivos pode ser restrito, segurança aprimorada ao não armazenar PDFs confidenciais em disco e integração perfeita com aplicativos da web e APIs.

Posso carregar um PDF existente a partir de um fluxo de memória?

Sim, o IronPDF permite carregar PDFs da memória usando o método `PdfDocument.FromStream()` para entradas do tipo `MemoryStream` ou `PdfDocument.FromBytes()` para entradas do tipo array de bytes. Isso permite trabalhar com PDFs recebidos de requisições web, bancos de dados ou outras fontes baseadas em memória sem precisar salvá-los em disco.

Como faço para exibir um PDF a partir da memória em aplicações ASP.NET ou MVC?

O IronPDF facilita a exibição de PDFs diretamente da memória em aplicações web. Você pode usar a propriedade Stream ou BinaryData para obter o conteúdo do PDF e retorná-lo como um FileResult ou FileContentResult nas ações do seu controlador, ideal para gerar e exibir PDFs dinamicamente em aplicações ASP.NET Core ou MVC.

É possível renderizar HTML para PDF diretamente na memória?

Sim, o ChromePdfRenderer do IronPDF pode renderizar conteúdo HTML diretamente em um MemoryStream sem criar arquivos temporários. Você pode usar o método RenderHtmlAsPdf() e acessar imediatamente a propriedade Stream para obter o PDF como um MemoryStream, tornando-o ideal para aplicações baseadas em nuvem e cenários de alto desempenho.

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais ...

Leia mais
Pronto para começar?
Nuget Downloads 18,318,263 | Versão: 2026.4 acaba de ser lançado
Still Scrolling Icon

Ainda está rolando a tela?

Quer provas rápidas? PM > Install-Package IronPdf
executar um exemplo Veja seu HTML se transformar em um PDF.