1. IronPDF
  2. Guides pratiques
  3. PDFs en mémoire

PDF vers MemoryStream C#

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

Convertissez des PDF en MemoryStream en C# .NET en utilisant la propriété Stream ou la propriété BinaryData d'IronPDF, 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.

<TODO : Ajouter une image ici -->

Nous pouvons exporter des PDF vers MemoryStream en C# .NET sans toucher au système de fichiers. L'objet MemoryStream présent dans l'espace de noms System.IO .NET permet de réaliser cette opération. 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 MemoryStream à l'aide de l'API d'IronPDF. Ce guide aide les développeurs à commencer à charger un PDF et à l'exporter vers un MemoryStream pour l'intégrer dans des applications .NET. Suivez cet exemple pour mettre en œuvre des fonctionnalités de traitement des PDF en C#.

Nuget IconCommencez dès maintenant à créer des PDF avec NuGet :

  1. Installez IronPDF avec le gestionnaire de packages NuGet

    PM > Install-Package IronPdf

  2. Copiez et exécutez cet extrait de code.

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

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

    Commencez à utiliser IronPDF dans votre projet dès aujourd'hui grâce à un essai gratuit.
    arrow pointer

Flux de travail minimal (5 étapes)

  1. Téléchargez la bibliothèque IronPDF C# pour convertir MemoryStream en PDF
  2. Charger un PDF existant en tant qu'objet PdfDocument
  3. Créer un nouveau PDF à partir d'une URL ou d'une chaîne/fichier HTML
  4. Convertissez le PDF en flux à l'aide de la méthode Stream et de la propriété BinaryData
  5. Servir le MemoryStream sur le Web, y compris MVC et ASP.NET

Comment enregistrer un PDF en mémoire?

<TODO : Ajouter une image ici -->

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

Le choix entre l'utilisation de Stream ou de BinaryData dépend de votre cas d'utilisation spécifique. MemoryStream est idéal lorsque vous devez travailler avec des API 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 dans lesquels vous devez stocker les données PDF dans une base de données, les mettre en cache dans la mémoire ou les transmettre sur un réseau.

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

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

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

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

<TODO : Ajouter une image ici -->

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

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

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

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

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 :

  1. Éliminez les ressources correctement : Utilisez toujours des instructions using ou disposez explicitement des objets MemoryStream pour éviter les fuites de mémoire.

  2. 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.

  3. 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.

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

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.

Curtis Chau
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 ...

Lire la suite
Prêt à commencer?
Nuget Téléchargements 17,012,929 | Version : 2025.12 vient de sortir