PDF to MemoryStream C#

Updated: 17 septembre 2026

Convertissez des PDF en MemoryStream en C# .NET en utilisant la propriété Stream d'IronPDF ou la propriété BinaryData, permettant la manipulation de PDF en mémoire sans accès au système de fichiers pour les applications web et le traitement des données.

Nous pouvons exporter des PDF vers MemoryStream en C# .NET sans toucher au système de fichiers. Cela est possible grâce à l'objet MemoryStream présent dans le namespace .NET System.IO. Cette approche est particulièrement utile pour développer des applications basées sur le cloud, travailler avec Azure Blob Storage, ou lorsque vous devez traiter des PDF en mémoire pour optimiser les performances.

La possibilité de travailler avec des PDF dans des flux de mémoire est essentielle pour les applications web modernes, en particulier lors d'un déploiement sur Azure ou d'autres plateformes cloud où l'accès au système de fichiers peut être restreint ou lorsque vous souhaitez éviter la surcharge des opérations d'E/S sur disque. IronPDF rend ce processus simple grâce à ses méthodes intégrées de manipulation des flux.

Démarrage rapide : Convertir un PDF en MemoryStream

Convertissez vos fichiers PDF en un MemoryStream en utilisant l'API d'IronPDF. Ce guide aide les développeurs à commencer à charger un PDF et à l'exporter vers un MemoryStream pour l'intégration dans des applications .NET. Suivez cet exemple pour mettre en œuvre des fonctionnalités de traitement des PDF en C#.

1Install IronPDF with NuGet Package Manager
PM > Install-Package IronPdf
```
Install-Package IronPdf
```

2Copiez et exécutez cet extrait de code.

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

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

3Déployez pour tester sur votre environnement de production.

Commencez à utiliser IronPDF dans votre projet dès aujourd'hui avec un essai gratuit

Flux de travail minimal (5 étapes)

Téléchargez la bibliothèque IronPDF C# pour convertir MemoryStream en PDF
Charger un PDF existant en tant qu'objet PdfDocument
Créer un nouveau PDF à partir d'une URL ou d'une chaîne/fichier HTML

Convertissez le PDF en flux à l'aide de la méthode Stream et de la propriété BinaryData
Servez le MemoryStream au Web, y compris MVC et ASP.NET

Comment enregistrer un PDF en mémoire?

Un IronPdf.PdfDocument peut être sauvegardé directement en mémoire de deux manières :

IronPdf.PdfDocument.Stream exports the PDF as a System.IO.MemoryStream
IronPdf.PdfDocument.BinaryData exporte le PDF en tant que tableau d'octets (byte[])

Le choix entre l'utilisation de Stream ou BinaryData dépend de votre cas d'utilisation spécifique. MemoryStream est idéal lorsque vous devez travailler avec des APIs basées sur les flux ou lorsque vous souhaitez maintenir la compatibilité avec d'autres opérations de flux .NET. BinaryData en tant que tableau d'octets est parfait pour les scénarios où vous devez stocker les données PDF dans une base de données, les mettre en cache en mémoire, ou les transmettre sur un réseau.

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;

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

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

Utilisation des fichiers PDF existants

Lorsque vous devez charger des PDF à partir de la mémoire, IronPDF fournit des méthodes pratiques pour travailler avec des PDF qui sont déjà en mémoire :

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;

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;

Opérations avancées de flux de mémoire

Pour les scénarios plus complexes, comme lorsque vous créez des PDF à partir de chaînes HTML ou convertissez plusieurs images en PDF, vous pouvez combiner plusieurs opérations tout en gardant tout en mémoire :

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;

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;

Ma bibliothèque préférée de ce genre est IronPDF. Elle permet une manipulation rapide et efficace des fichiers PDF. Elle dispose également de nombreuses fonctionnalités précieuses, comme l'exportation au format PDF/A et la signature numérique des documents PDF.

Milan Jovanovic

Microsoft MVP

Voir l'étude de cas

IronOCR signifie que nous pouvons économiser 40 000 $ par an grâce au traitement manuel, tout en améliorant la productivité et en libérant des ressources pour des tâches à fort impact. Je le recommande vivement.

Brent Matzelle

Directeur technique, OPYN

Voir l'étude de cas

Comment servir un PDF sur le web à partir de la mémoire?

Pour servir ou exporter un PDF sur le web, vous devez envoyer le fichier PDF sous forme de données binaires au lieu de HTML. Vous trouverez de plus amples informations dans ce guide sur l'exportation et l'enregistrement de documents PDF en C#. Lorsque l'on travaille avec des applications web, notamment dans des environnements ASP.NET MVC, servir des PDF à partir de flux de mémoire offre plusieurs avantages, notamment de meilleures performances et une réduction de l'utilisation du disque du serveur.

Voici un exemple rapide pour MVC et ASP.NET :

Comment exporter un PDF avec MVC?

Le flux dans l'extrait de code ci-dessous est la donnée binaire récupérée depuis IronPDF. Le type MIME de la réponse est 'application/pdf', spécifiant le nom de fichier comme 'download.pdf'. Cette approche fonctionne parfaitement avec les applications MVC modernes et peut être intégrée dans vos contrôleurs existants.

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

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

Pour des scénarios plus avancés, comme lorsque vous travaillez avec Razor Pages ou devez mettre en œuvre des en-têtes personnalisés :

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 = 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

Imports System.Web.Mvc
Imports IronPdf

Public Function GenerateReport(reportType As String) As ActionResult
    Dim 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
    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

Comment exporter un PDF avec ASP.NET?

Similaire à l'exemple ci-dessus, le flux est la donnée binaire récupérée depuis IronPDF. La réponse est ensuite configurée et vidée pour s'assurer qu'elle est envoyée au client. Cette méthode est particulièrement utile pour les ASP.NET Web Forms applications ou lorsque vous avez besoin de plus de contrôle sur la réponse 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

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

Pour les applications ASP.NET Core modernes, le processus est encore plus rationalisé :

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

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

Bonnes pratiques pour la gestion des flux de mémoire

Lorsque vous travaillez avec des flux de mémoire PDF dans des applications web, tenez compte de ces bonnes pratiques :

Disposez correctement des ressources : utilisez toujours des instructions using ou disposez explicitement des objets MemoryStream pour éviter les fuites de mémoire.
Opérations asynchrones : Pour une meilleure évolutivité, en particulier lorsque travaille avec des opérations asynchrones, utilisez des méthodes asynchrones lorsqu'elles sont disponibles.
Considération de la taille du flux : Pour les PDF volumineux, envisagez de mettre en œuvre des réponses en continu afin d'éviter de charger l'intégralité du PDF en mémoire en une seule fois.
Mise en cache : Pour les PDF fréquemment consultés, envisagez de mettre en cache le tableau d'octets en mémoire ou d'utiliser un cache distribué pour améliorer les performances.

// 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;
        }
    }
}

' 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()
        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

' 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()
        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

En suivant ces modèles et en utilisant les capacités de flux de mémoire d'IronPDF, vous pouvez créer des applications web efficaces et évolutives qui gèrent la génération et la diffusion de PDF sans dépendre des opérations du système de fichiers. Cette approche est particulièrement utile pour déployer sur des plateformes cloud comme AWS ou pour travailler dans des environnements conteneurisés.

Questions Fréquemment Posées

Comment convertir un PDF en MemoryStream en C# ?

IronPDF propose deux façons principales de convertir les PDF en mémoire : en utilisant la propriété Stream pour exporter en tant que System.IO.MemoryStream, ou en utilisant la propriété BinaryData pour exporter en tant que tableau d'octets. Il suffit de créer ou de charger un document Pdf et d'accéder à ces propriétés pour travailler avec des PDF en mémoire sans toucher au système de fichiers.

Quels sont les avantages de travailler avec des PDF en mémoire plutôt qu'avec des fichiers ?

Travailler avec des PDF en mémoire à l'aide d'IronPDF présente plusieurs avantages : amélioration des performances en évitant les opérations d'E/S sur disque, meilleure compatibilité avec les plateformes cloud comme Azure où l'accès au système de fichiers peut être restreint, sécurité renforcée en ne stockant pas les PDF sensibles sur disque, et intégration transparente avec les applications web et les API.

Puis-je charger un PDF existant à partir d'un flux de mémoire ?

Oui, IronPDF vous permet de charger des PDF depuis la mémoire en utilisant la méthode PdfDocument.FromStream() pour les entrées MemoryStream ou PdfDocument.FromBytes() pour les entrées byte array. Cela vous permet de travailler avec des PDF reçus à partir de requêtes Web, de bases de données ou d'autres sources basées sur la mémoire sans les enregistrer sur le disque.

Comment puis-je servir un PDF à partir de la mémoire dans des applications ASP.NET ou MVC ?

IronPDF permet de servir facilement des PDF directement à partir de la mémoire dans les applications web. Vous pouvez utiliser la propriété Stream ou la propriété BinaryData pour obtenir le contenu du PDF et le renvoyer en tant que FileResult ou FileContentResult dans les actions de votre contrôleur, ce qui est parfait pour générer et servir des PDF à la volée dans les applications ASP.NET Core ou MVC.

Est-il possible de convertir HTML en PDF directement en mémoire ?

Oui, IronPDF's ChromePdfRenderer peut rendre le contenu HTML directement dans un MemoryStream sans créer de fichiers temporaires. Vous pouvez utiliser la méthode RenderHtmlAsPdf() et accéder immédiatement à la propriété Stream pour obtenir le PDF en tant que MemoryStream, ce qui en fait un outil idéal pour les applications basées sur le cloud et les scénarios à haute performance.

How can IronPDF help with cloud deployments?

IronPDF is ideal for cloud deployments as it supports in-memory PDF processing, allowing you to avoid disk I/O operations. This is beneficial for environments like Azure where file system access might be limited.

Does IronPDF support asynchronous PDF rendering?

Yes, IronPDF supports asynchronous PDF rendering with methods like `RenderHtmlAsPdfAsync`. This enhances performance in web applications by allowing non-blocking operations, especially useful in scalable environments.

How can I manage resources effectively when working with PDF streams?

Effective resource management with PDF streams includes using `using` statements for automatic disposal and employing caching strategies for frequently accessed PDFs. IronPDF supports these best practices to prevent memory leaks and enhance performance.

What rendering options can I configure with IronPDF?

IronPDF enables you to configure various rendering options such as margins, paper orientation, and CSS media types. These options help customize the output to meet specific presentation requirements.

How can I merge multiple PDFs in memory using IronPDF?

IronPDF allows you to merge multiple PDFs directly in memory by using the `Merge` method on a list of `PdfDocument` objects. This is useful for scenarios requiring the combination of several documents without saving intermediate files.

Curtis Chau

Discutez maintenant avec l'équipe d'ingénierie

Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.

...

Prêt à commencer ?

Nuget Downloads 21,105,021|Version :2026.9vient de sortir

Téléchargement NuGet gratuit

Total des téléchargements :21,105,021

Voir les licences

Voir sur GitHub

Installer avec NuGet

Version : 2026.9

PM > Install-Package IronPdf

nuget.org/packages/IronPdf/

Dans l'explorateur de solutions, faites un clic droit sur Références, Gestion des packages NuGet
Sélectionnez Parcourir et recherchez « IronPDF »
Sélectionnez le package et installez

Télécharger DLL

Version : 2026.9

ou téléchargez l'installateur Windows ici.

Téléchargez et décompressez IronPDF à un emplacement tel que ~/Libs dans votre répertoire de solution
Dans l'explorateur de solutions Visual Studio, faites un clic droit sur Références. Sélectionnez Parcourir, « IronPDF.dll »

Licences à partir de 749 $