1. IronPDF
  2. Tutoriais
  3. PDFs da memória

Fluxo de memória para PDF em C

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

O IronPDF permite a conversão direta de objetos MemoryStream em documentos PDF em C# sem acesso ao sistema de arquivos. Passe seu MemoryStream, FileStream ou array de bytes para o construtor PdfDocument para criação e manipulação instantânea de PDF na memória.

Carregar e criar MemoryStream em arquivos PDF em C# .NET sem alterar o sistema de arquivos. Isso funciona através do objeto MemoryStream no namespace System.IO. Utilize essa funcionalidade em ambientes de nuvem, aplicações web ou cenários onde o acesso ao sistema de arquivos é restrito.

Início rápido: Criar PDF a partir de MemoryStream em C#

Converta um MemoryStream em um PDF usando o IronPDF em uma única linha de código. Inicialize um PdfDocument a partir de um MemoryStream para integrar a criação de PDFs em aplicativos C# sem manipular arquivos físicos. Ideal para processamento de dados em memória, comunicações de rede ou transformação de dados em tempo real.

  1. Instale IronPDF com o Gerenciador de Pacotes NuGet

    PM > Install-Package IronPdf

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

    var bytes = File.ReadAllBytes("sample.pdf");
var pdfDoc = new IronPdf.PdfDocument(myMemoryStream);

  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 um MemoryStream em um PDF.
  2. Recuperar os dados em bytes do arquivo PDF
  3. Use o construtor **PdfDocument** para carregar a matriz de bytes em um objeto PDF.
  4. Faça as alterações necessárias no objeto PDF.
  5. Exporte o documento PDF atualizado.

Como faço para carregar um PDF da memória?

Inicialize IronPdf.PdfDocument a partir destes objetos .NET em memória:

  • Um MemoryStream
  • Um FileStream
  • Dados binários como um byte[]

Aqui está um exemplo de leitura de um fluxo diretamente de um arquivo PDF e criação de um objeto PdfDocument:

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

// Read PDF file as stream
var fileByte = File.ReadAllBytes("sample.pdf");

// Instantiate PDF object from stream
PdfDocument pdf = new PdfDocument(fileByte);
Imports IronPdf
Imports System.IO

' Read PDF file as stream
Private fileByte = File.ReadAllBytes("sample.pdf")

' Instantiate PDF object from stream
Private pdf As New PdfDocument(fileByte)
$vbLabelText   $csharpLabel

Que tipos de objetos de fluxo posso usar?

O exemplo mostra como ler um arquivo PDF do sistema de arquivos e criar um objeto PdfDocument. Você também pode inicializar um PdfDocument a partir de um byte[] recebido via comunicação de rede ou outros protocolos de troca de dados. Transforme os dados do PDF em um objeto editável para fazer as modificações necessárias.

Aqui está um exemplo completo mostrando diferentes fontes de fluxo:

using IronPdf;
using System.IO;
using System.Net.Http;

// Example 1: From FileStream
using (FileStream fileStream = File.OpenRead("document.pdf"))
{
    var pdfFromFileStream = new PdfDocument(fileStream);
}

// Example 2: From MemoryStream
byte[] pdfBytes = GetPdfBytesFromDatabase(); // Your method to get PDF bytes
using (MemoryStream memoryStream = new MemoryStream(pdfBytes))
{
    var pdfFromMemoryStream = new PdfDocument(memoryStream);
}

// Example 3: From HTTP Response
using (HttpClient client = new HttpClient())
{
    byte[] pdfData = await client.GetByteArrayAsync("https://example.com/document.pdf");
    var pdfFromHttp = new PdfDocument(pdfData);
}
using IronPdf;
using System.IO;
using System.Net.Http;

// Example 1: From FileStream
using (FileStream fileStream = File.OpenRead("document.pdf"))
{
    var pdfFromFileStream = new PdfDocument(fileStream);
}

// Example 2: From MemoryStream
byte[] pdfBytes = GetPdfBytesFromDatabase(); // Your method to get PDF bytes
using (MemoryStream memoryStream = new MemoryStream(pdfBytes))
{
    var pdfFromMemoryStream = new PdfDocument(memoryStream);
}

// Example 3: From HTTP Response
using (HttpClient client = new HttpClient())
{
    byte[] pdfData = await client.GetByteArrayAsync("https://example.com/document.pdf");
    var pdfFromHttp = new PdfDocument(pdfData);
}
Imports IronPdf
Imports System.IO
Imports System.Net.Http

' Example 1: From FileStream
Using fileStream As FileStream = File.OpenRead("document.pdf")
    Dim pdfFromFileStream = New PdfDocument(fileStream)
End Using

' Example 2: From MemoryStream
Dim pdfBytes As Byte() = GetPdfBytesFromDatabase() ' Your method to get PDF bytes
Using memoryStream As New MemoryStream(pdfBytes)
    Dim pdfFromMemoryStream = New PdfDocument(memoryStream)
End Using

' Example 3: From HTTP Response
Using client As New HttpClient()
    Dim pdfData As Byte() = Await client.GetByteArrayAsync("https://example.com/document.pdf")
    Dim pdfFromHttp = New PdfDocument(pdfData)
End Using
$vbLabelText   $csharpLabel

Quando devo usar MemoryStream em vez de operações baseadas em arquivos?

As operações MemoryStream se destacam nestes cenários:

  1. Aplicações Web : Disponibilize PDFs dinamicamente em aplicações ASP.NET sem criar arquivos temporários no servidor.

  2. Ambientes em nuvem : Utilize no Azure Functions ou AWS Lambda quando o acesso ao sistema de arquivos for limitado ou o armazenamento temporário for dispendioso.

  3. Segurança : Processe documentos confidenciais na memória para evitar deixar arquivos temporários no disco.

  4. Desempenho : As operações de memória são mais rápidas do que as operações de E/S de disco para PDFs de pequeno a médio porte, especialmente com armazenamento de estado sólido ou conectado à rede.

Como faço para exportar um PDF para o MemoryStream?

Exporte os documentos PDF carregados ou criados de volta para um MemoryStream para processamento ou transmissão. Isso é útil ao disponibilizar PDFs em aplicações web ou ao armazená-los em bancos de dados.

Veja como exportar um PDF para o MemoryStream:

using IronPdf;
using System.IO;

// Create or load a PDF document
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML</p>");

// Export to MemoryStream
using (MemoryStream memoryStream = new MemoryStream())
{
    pdf.SaveAs(memoryStream);

    // Example: Convert to byte array for database storage
    byte[] pdfBytes = memoryStream.ToArray();

    // Example: Reset position to read from beginning
    memoryStream.Position = 0;

    // Use the stream as needed (e.g., return in web response)
}
using IronPdf;
using System.IO;

// Create or load a PDF document
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML</p>");

// Export to MemoryStream
using (MemoryStream memoryStream = new MemoryStream())
{
    pdf.SaveAs(memoryStream);

    // Example: Convert to byte array for database storage
    byte[] pdfBytes = memoryStream.ToArray();

    // Example: Reset position to read from beginning
    memoryStream.Position = 0;

    // Use the stream as needed (e.g., return in web response)
}
Imports IronPdf
Imports System.IO

' Create or load a PDF document
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML</p>")

' Export to MemoryStream
Using memoryStream As New MemoryStream()
    pdf.SaveAs(memoryStream)

    ' Example: Convert to byte array for database storage
    Dim pdfBytes As Byte() = memoryStream.ToArray()

    ' Example: Reset position to read from beginning
    memoryStream.Position = 0

    ' Use the stream as needed (e.g., return in web response)
End Using
$vbLabelText   $csharpLabel

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

Mesclando PDFs de múltiplos fluxos de memória

Mesclar vários documentos PDF na memória sem acessar o sistema de arquivos:

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

public static byte[] MergePdfsFromMemory(List<byte[]> pdfBytesList)
{
    List<PdfDocument> pdfs = new List<PdfDocument>();

    // Load all PDFs from byte arrays
    foreach (var pdfBytes in pdfBytesList)
    {
        pdfs.Add(new PdfDocument(pdfBytes));
    }

    // Merge PDFs
    PdfDocument merged = PdfDocument.Merge(pdfs);

    // Export merged PDF to byte array
    using (MemoryStream ms = new MemoryStream())
    {
        merged.SaveAs(ms);
        return ms.ToArray();
    }
}
using IronPdf;
using System.Collections.Generic;
using System.IO;

public static byte[] MergePdfsFromMemory(List<byte[]> pdfBytesList)
{
    List<PdfDocument> pdfs = new List<PdfDocument>();

    // Load all PDFs from byte arrays
    foreach (var pdfBytes in pdfBytesList)
    {
        pdfs.Add(new PdfDocument(pdfBytes));
    }

    // Merge PDFs
    PdfDocument merged = PdfDocument.Merge(pdfs);

    // Export merged PDF to byte array
    using (MemoryStream ms = new MemoryStream())
    {
        merged.SaveAs(ms);
        return ms.ToArray();
    }
}
Imports IronPdf
Imports System.Collections.Generic
Imports System.IO

Public Shared Function MergePdfsFromMemory(pdfBytesList As List(Of Byte())) As Byte()
    Dim pdfs As New List(Of PdfDocument)()

    ' Load all PDFs from byte arrays
    For Each pdfBytes In pdfBytesList
        pdfs.Add(New PdfDocument(pdfBytes))
    Next

    ' Merge PDFs
    Dim merged As PdfDocument = PdfDocument.Merge(pdfs)

    ' Export merged PDF to byte array
    Using ms As New MemoryStream()
        merged.SaveAs(ms)
        Return ms.ToArray()
    End Using
End Function
$vbLabelText   $csharpLabel

Aplicando configurações de segurança na memória

Defina senhas e permissões em PDFs, mantendo tudo na memória:

using IronPdf;
using System.IO;

// Load PDF from memory
byte[] unsecuredPdfBytes = GetPdfFromDatabase();
PdfDocument pdf = new PdfDocument(unsecuredPdfBytes);

// Apply security settings
pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.OwnerPassword = "owner456";
pdf.SecuritySettings.AllowUserPrinting = false;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;

// Export secured PDF to memory
using (MemoryStream securedStream = new MemoryStream())
{
    pdf.SaveAs(securedStream);
    byte[] securedPdfBytes = securedStream.ToArray();
    // Store or transmit secured PDF bytes
}
using IronPdf;
using System.IO;

// Load PDF from memory
byte[] unsecuredPdfBytes = GetPdfFromDatabase();
PdfDocument pdf = new PdfDocument(unsecuredPdfBytes);

// Apply security settings
pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.OwnerPassword = "owner456";
pdf.SecuritySettings.AllowUserPrinting = false;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;

// Export secured PDF to memory
using (MemoryStream securedStream = new MemoryStream())
{
    pdf.SaveAs(securedStream);
    byte[] securedPdfBytes = securedStream.ToArray();
    // Store or transmit secured PDF bytes
}
Imports IronPdf
Imports System.IO

' Load PDF from memory
Dim unsecuredPdfBytes As Byte() = GetPdfFromDatabase()
Dim pdf As New PdfDocument(unsecuredPdfBytes)

' Apply security settings
pdf.SecuritySettings.UserPassword = "user123"
pdf.SecuritySettings.OwnerPassword = "owner456"
pdf.SecuritySettings.AllowUserPrinting = False
pdf.SecuritySettings.AllowUserCopyPasteContent = False

' Export secured PDF to memory
Using securedStream As New MemoryStream()
    pdf.SaveAs(securedStream)
    Dim securedPdfBytes As Byte() = securedStream.ToArray()
    ' Store or transmit secured PDF bytes
End Using
$vbLabelText   $csharpLabel

Melhores práticas para operações de PDF no MemoryStream

  1. Descarte corretamente : Use instruções using ou descarte explicitamente os objetos MemoryStream e PdfDocument para evitar vazamentos de memória.

  2. Considere os limites de memória : Monitore o uso de memória para PDFs grandes ou processamento de alto volume. Considere implementar compressão ou processar PDFs em partes.

  3. Tratamento de erros : Implemente blocos try-catch para lidar com exceções ao trabalhar com fluxos de dados, especialmente com dados PDF corrompidos ou malformados.

  4. Operações assíncronas : Utilize métodos assíncronos ao processar PDFs em aplicações web para manter a capacidade de resposta.

Integração com outros recursos do IronPDF

Os MemoryStreams possibilitam inúmeras manipulações de PDF:

Pronto para ver o que mais você pode fazer? Confira nossa página de tutoriais aqui: Editar PDFs

Perguntas frequentes

Como posso converter um MemoryStream para PDF em C# sem acessar o sistema de arquivos?

O IronPDF permite a conversão direta de objetos MemoryStream em documentos PDF sem acesso ao sistema de arquivos. Basta passar seu MemoryStream para o construtor PdfDocument: var pdfDoc = new IronPdf.PdfDocument(myMemoryStream). Essa abordagem é ideal para ambientes em nuvem, aplicações web ou cenários com acesso restrito ao sistema de arquivos.

Que tipos de objetos de fluxo posso usar para criar PDFs na memória?

O construtor PdfDocument do IronPDF aceita três tipos de objetos em memória: MemoryStream, FileStream e arrays de bytes (byte[]). Você pode inicializar um PdfDocument a partir de qualquer uma dessas fontes, tornando-o flexível para diversas origens de dados, como comunicações de rede, blobs de banco de dados ou respostas de API.

Posso carregar um PDF a partir de uma matriz de bytes em vez de um caminho de arquivo?

Sim, o IronPDF permite carregar PDFs diretamente de arrays de bytes. Você pode criar um objeto PdfDocument a partir de dados binários usando: `var pdfDoc = new IronPdf.PdfDocument(pdfBytes)`. Isso é particularmente útil ao receber dados PDF via comunicação de rede ou ao recuperá-los de um banco de dados.

Como faço para criar um PDF a partir de um fluxo de resposta HTTP?

Com o IronPDF, você pode criar PDFs a partir de respostas HTTP convertendo primeiro a resposta em um array de bytes: `byte[] pdfData = await client.GetByteArrayAsync(url);` e, em seguida, inicializando um `PdfDocument`: `var pdfFromHttp = new IronPdf.PdfDocument(pdfData)`. Isso permite o processamento contínuo de PDFs a partir de APIs da web ou fontes remotas.

Quais são os benefícios de usar o MemoryStream para operações com PDFs?

Utilizar o MemoryStream com o IronPDF oferece diversas vantagens: ausência de dependências do sistema de arquivos, processamento em memória mais rápido, maior segurança (sem arquivos temporários) e ideal para ambientes em nuvem ou aplicações conteinerizadas onde o acesso ao sistema de arquivos pode ser limitado ou restrito.

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
Analisado por
Jeff Fritz
Jeffrey T. Fritz
Gerente de Programa Principal - Equipe da Comunidade .NET
Jeff também é Gerente de Programa Principal das equipes do .NET e do Visual Studio. Ele é o produtor executivo da série de conferências virtuais .NET Conf e apresenta o "Fritz and Friends", uma transmissão ao vivo para desenvolvedores que vai ao ar duas vezes por semana, onde ele conversa sobre tecnologia e escreve código junto com os espectadores. Jeff cria workshops, apresentações e planeja conteúdo para os maiores eventos de desenvolvedores da Microsoft, incluindo o Microsoft Build, o Microsoft Ignite, a .NET Conf e o Microsoft MVP Summit.
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.