MemoryStream vers C#35; PDF

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

IronPDF permet de convertir directement des objets MemoryStream en documents PDF en C# sans accès au système de fichiers. Passez votre MemoryStream, FileStream ou un tableau d'octets au constructeur de PdfDocument pour une création et une manipulation instantanées de PDF en mémoire.

Charger et créer des MemoryStream vers des fichiers PDF en C# .NET sans toucher au système de fichiers. Cela fonctionne grâce à l'objet MemoryStream dans l'espace de noms System.IO. Utilisez cette capacité pour les environnements en nuage, les applications web ou les scénarios dans lesquels l'accès au système de fichiers est restreint.

<TODO : Ajouter une image ici -->

Démarrage rapide : Créer un PDF à partir de MemoryStream en C#

Convertir un MemoryStream en un PDF à l'aide d'IronPDF en une seule ligne de code. Initialiser un PdfDocument à partir d'un MemoryStream pour intégrer la création de PDF dans les applications C# sans manipuler de fichiers physiques. Idéal pour le traitement des données en mémoire, les communications réseau ou la transformation des données en temps réel.

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.

    var bytes = File.ReadAllBytes("sample.pdf");
    var pdfDoc = new IronPdf.PdfDocument(myMemoryStream);
  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

Comment charger un PDF à partir de la mémoire?

<TODO : Ajouter une image ici -->

Initialisez IronPdf.PdfDocument à partir de ces objets .NET en mémoire :

  • Un MemoryStream
  • Un FileStream
  • Données binaires sous la forme d'un octet[]

Voici un exemple de lecture d'un flux directement à partir d'un fichier PDF et de création d'un objet 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);
$vbLabelText   $csharpLabel

Quels types d'objets de flux puis-je utiliser ?

L'exemple montre comment lire un fichier PDF à partir du système de fichiers et créer un objet PdfDocument. Vous pouvez également initialiser un PdfDocument à partir d'un byte[] reçu via une communication réseau ou d'autres protocoles d'échange de données. Transformer des données PDF en un objet éditable afin d'y apporter les modifications nécessaires.

Voici un exemple complet montrant différentes sources de flux :

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

Quand devrais-je utiliser MemoryStream plutôt que des opérations basées sur des fichiers?

les opérations MemoryStream excellent dans ces scénarios :

  1. Applications web : Servez des PDF de manière dynamique dans des applications ASP.NET sans créer de fichiers serveur temporaires.

  2. Environnements cloud : Utilisez dans Azure Functions ou AWS Lambda lorsque l'accès au système de fichiers est limité ou que le stockage temporaire est coûteux.

  3. Sécurité : Traiter les documents sensibles en mémoire pour éviter de laisser des fichiers temporaires sur le disque.

  4. Performances : Les opérations en mémoire sont plus rapides que les E/S sur disque pour les PDF de petite et moyenne taille, en particulier avec un stockage sur support solide ou en réseau.

Comment exporter un PDF vers MemoryStream?

Exporter des documents PDF chargés ou créés vers un MemoryStream à des fins de traitement ou de transmission. Cela s'avère utile pour servir des PDF dans des applications web ou les stocker dans des bases de données.

<TODO : Ajouter une image ici -->

Voici comment exporter un PDF vers 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)
}
$vbLabelText   $csharpLabel

Opérations avancées de MemoryStream

Fusionner des PDF à partir de plusieurs flux de mémoire

Fusionner plusieurs documents PDF en mémoire sans accès au système de fichiers :

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

Application des paramètres de sécurité en mémoire

Définir les mots de passe et les autorisations sur les PDF tout en gardant tout en mémoire :

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

Bonnes pratiques pour les opérations PDF MemoryStream

  1. Éliminer correctement : Utilisez les instructions using ou disposez explicitement des objets MemoryStream et PdfDocument pour éviter les fuites de mémoire.

  2. Considérez les limites de mémoire : Surveillez l'utilisation de la mémoire pour les PDF volumineux ou le traitement de gros volumes. Pensez à mettre en œuvre la compression ou à traiter les PDF par morceaux.

  3. Gestion des erreurs : mettez en œuvre des blocs try-catch pour gérer les exceptions lorsque vous travaillez avec des flux, en particulier avec des données PDF corrompues ou malformées.

  4. Opérations asynchrones : Utilisez des méthodes asynchrones lors du traitement des PDF dans les applications web pour maintenir la réactivité.

Intégration avec d'autres fonctionnalités d'IronPDF

Les MemoryStreams offrent de nombreuses possibilités de manipulation des PDF :

Prêt à voir ce que vous pouvez faire d'autre? Consultez notre page de tutoriel ici : Modifier les PDFs

Questions Fréquemment Posées

Comment convertir un MemoryStream en PDF dans C# sans accéder au système de fichiers ?

IronPDF permet la conversion directe d'objets MemoryStream en documents PDF sans accès au système de fichiers. Il suffit de passer votre MemoryStream au constructeur de PdfDocument : var pdfDoc = new IronPdf.PdfDocument(myMemoryStream). Cette approche est idéale pour les environnements en nuage, les applications web ou les scénarios avec un accès restreint au système de fichiers.

Quels types d'objets de flux puis-je utiliser pour créer des PDF en mémoire ?

Le constructeur PdfDocument d'IronPDF accepte trois types d'objets en mémoire : MemoryStream, FileStream et les tableaux d'octets (byte[]). Vous pouvez initialiser un document Pdf à partir de n'importe laquelle de ces sources, ce qui le rend flexible pour diverses sources de données telles que les communications réseau, les blobs de base de données ou les réponses API.

Puis-je charger un PDF à partir d'un tableau d'octets au lieu d'un chemin de fichier ?

Oui, IronPDF permet de charger des PDF directement à partir de tableaux d'octets. Vous pouvez créer un objet PdfDocument à partir de données binaires en utilisant : var pdfDoc = new IronPdf.PdfDocument(pdfBytes). Ceci est particulièrement utile pour recevoir des données PDF via une communication réseau ou pour les extraire d'une base de données.

Comment créer un PDF à partir d'un flux de réponses HTTP ?

Avec IronPDF, vous pouvez créer des PDF à partir de réponses HTTP en convertissant d'abord la réponse en un tableau d'octets : byte[] pdfData = await client.GetByteArrayAsync(url) ; puis initialiser un PdfDocument : var pdfFromHttp = new IronPdf.PdfDocument(pdfData). Cela permet un traitement transparent des PDF à partir d'API web ou de sources distantes.

Quels sont les avantages de l'utilisation de MemoryStream pour les opérations PDF ?

L'utilisation de MemoryStream avec IronPDF offre plusieurs avantages : pas de dépendance au système de fichiers, traitement en mémoire plus rapide, meilleure sécurité (pas de fichiers temporaires), et idéal pour les environnements cloud ou les applications conteneurisées où l'accès au système de fichiers peut être limité ou restreint.

Curtis Chau
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
Revu par
Jeff Fritz
Jeffrey T. Fritz
Responsable principal du programme - Équipe de la communauté .NET
Jeff est également responsable principal du programme pour les équipes .NET et Visual Studio. Il est le producteur exécutif de la série de conférences virtuelles .NET Conf et anime 'Fritz and Friends', une diffusion en direct pour développeurs qui est diffusée deux fois par semaine où il parle de technologie et écrit du code avec les téléspectateurs. Jeff écrit des ateliers, des présentations et prévoit du contenu pour les plus grands événements de développement Microsoft, y compris Microsoft Build, Microsoft Ignite, .NET Conf et le sommet Microsoft MVP
Prêt à commencer?
Nuget Téléchargements 17,012,929 | Version : 2025.12 vient de sortir