Comment charger et enregistrer des documents Word avec des flux et Async en C#
IronWord 2026.10.1+ introduit le chargement direct depuis et l'enregistrement vers tout System.IO.Stream, ainsi que les méthodes asynchrones pour les deux. Le chargement et l'enregistrement fonctionnaient auparavant via des chemins de fichiers et des tableaux d'octets. Un .docx qui arrive par un téléchargement Web, descend du stockage de blobs, ou retourne dans une réponse HTTP n'a jamais besoin d'accéder au disque, donc les fonctions sans serveur et les points de terminaison Web restent entièrement en mémoire.
Trois points d'entrée dans WordDocument couvrent chaque scénario : un chemin de fichier lorsque le .docx est sur le disque, un flux lorsque les octets circulent déjà, et un tableau d'octets lorsque tout est déjà en mémoire.
Passez n'importe quel flux lisible au constructeur WordDocument, puis enregistrez dans un autre flux, comme dans l'exemple de chargement et d'enregistrement avec des flux.
-
1Installez IronWord avec NuGet Package Manager
-
2Copiez et exécutez cet extrait de code.
using var input = File.OpenRead("source.docx"); var doc = new WordDocument(input); using var output = new MemoryStream(); doc.Save(output);C# -
3Déployez pour tester sur votre environnement de production.
Commencez à utiliser IronWord dans votre projet dès aujourd'hui avec un essai gratuit
Flux de travail minimal (5 étapes)
- Téléchargez la bibliothèque IronWord C# depuis NuGet
- Ouvrez ou recevez un
Streamcontenant des octets .docx - Chargez-le avec
new WordDocument(stream)ouawait WordDocument.LoadAsync(stream) - Modifiez le document - ajoutez du texte, des images ou des tableaux
- Enregistrez-le avec
doc.Save(stream)ouawait doc.SaveAsync(stream)
Quelle surcharge de chargement et d'enregistrement devrais-je utiliser ?
Choisissez la surcharge qui correspond à l'endroit où se trouvent les données.
| Méthode | Direction | I/O | Async |
|---|---|---|---|
WordDocument(string filePath) | Charger | Fichier | Non |
WordDocument(byte[] bytes) | Charger | None | Non |
WordDocument(Stream stream) | Charger | Flux | Non |
WordDocument.LoadAsync(string, CancellationToken) | Charger | Fichier | Oui |
WordDocument.LoadAsync(Stream, CancellationToken) | Charger | Flux | Oui |
Save() retourne byte[] | Enregistrer | None | Non |
Save(string filePath) | Enregistrer | Fichier | Non |
Save(Stream stream) | Enregistrer | Flux | Non |
SaveAs(string filePath) | Enregistrer | Fichier | Non |
SaveAsync(string, CancellationToken) | Enregistrer | Fichier | Oui |
SaveAsync(Stream, CancellationToken) | Enregistrer | Flux | Oui |
SaveAsAsync(string, CancellationToken) | Enregistrer | Fichier | Oui |
Les tableaux d'octets restent synchrones par conception : la construction à partir d'octets et la sérialisation en un tableau d'octets ne réalisent pas d'I/O, donc il n'y a rien à attendre. Pour produire un document entièrement en mémoire et l'obtenir sous forme d'octets, appelez byte[] Save().
L'enregistrement nécessite une licence IronWord valide, comme chaque autre chemin d'enregistrement.
Qu'est-ce que le contrat de flux ?
Cinq règles régissent la manière dont IronWord traite le flux d'un appelant.
- Propriété du flux : IronWord ne ferme jamais le flux de l'appelant, donc l'appelant le possède et le dispose
- Chargement : lit de la position actuelle jusqu'à la fin et laisse le flux à sa fin
- Enregistrement : écrit à la position actuelle
- Aucune troncation : un flux réutilisé qui contenait déjà un document plus long conserve ses anciens octets de terminaison après le nouveau contenu et le résultat est un .docx corrompu, alors réinitialisez-le avec
SetLength(0)avant d'enregistrer - Flux non-recherchables : supportés comme source et cible, puisque ni le chargement ni l'enregistrement ne recherchent
using IronWord;
using IronWord.Models;
// Build a document entirely in memory
var doc = new WordDocument();
doc.AddParagraph(new Paragraph(new TextContent("Invoice #1042")));
doc.AddParagraph(new Paragraph(new TextContent("Total: $2,450.00")));
// Save to a MemoryStream
using var ms = new MemoryStream();
doc.Save(ms);
// Reset the position before handing the stream to another consumer
ms.Position = 0;
// Print the document size
Console.WriteLine($"Document size: {ms.Length} bytes");
Comment utiliser les flux dans ASP.NET Core ?
ASP.NET Core : new WordDocument(Request.Body) et doc.Save(Response.Body) lancent sous le défaut de Kestrel, donc utilisez LoadAsync et SaveAsync
À quoi ressemble le document téléchargé ?
Le téléchargement est une courte note de fournisseur avec un titre et deux paragraphes.

using IronWord;
using IronWord.Models;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
var app = WebApplication.Create();
// Upload a .docx, append a confidentiality notice, and return the modified document
app.MapPost("/add-notice", async (HttpRequest request) =>
{
// Load the request body asynchronously
var doc = await WordDocument.LoadAsync(request.Body);
// Append a confidentiality notice
doc.AddParagraph(new Paragraph(new TextContent("CONFIDENTIAL")));
// Set the download headers
var response = request.HttpContext.Response;
response.ContentType =
"application/vnd.openxmlformats-officedocument.wordprocessingml.document";
response.Headers.ContentDisposition = "attachment; filename=modified.docx";
// Save to the response body asynchronously
await doc.SaveAsync(response.Body);
return Results.Empty;
});
app.Run();
Que retourne le point de terminaison ?
Le point de terminaison retourne la même note avec un paragraphe CONFIDENTIAL ajouté.

Que font réellement les méthodes Async ?
Seul le fichier ou le flux I/O est asynchrone et annulable. Analyser un document chargé et sérialiser un document enregistré sont des étapes synchrones, liées au CPU, que CancellationToken ne peut pas interrompre. Le jeton est vérifié avant ce travail et autour des appels I/O.
À quoi ressemble le rapport avant l'enregistrement ?
report.docx contient un titre et deux paragraphes.

using IronWord;
using IronWord.Models;
// Load a document from disk asynchronously
var doc = await WordDocument.LoadAsync("report.docx");
// Append a dated paragraph
doc.AddParagraph(new Paragraph(
new TextContent("Appendix added on " + DateTime.Now.ToString("yyyy-MM-dd"))));
// Save to a new path, leaving the original untouched
await doc.SaveAsAsync("report-updated.docx");
À quoi ressemble le rapport mis à jour ?
report-updated.docx gagne la ligne annexe datée, et report.docx reste inchangé.

L'annulation est-elle sûre pour les enregistrements de fichiers ?
L'annulation est sûre uniquement si le jeton est déjà annulé quand l'appel commence. Dans ce cas, un enregistrement sur chemin échoue avant que le fichier de destination ne soit ouvert, donc un fichier existant reste intact.
Après le début de l'écriture : un enregistrement annulé peut laisser le fichier vide ou partiellement écrit, avec son ancien contenu perdu, et un flux partiellement écrit
WordDocument est-il thread-safe ?
Non. Une seule instance WordDocument n'est pas thread-safe. Ne pas exécuter des opérations d'enregistrement simultanément sur la même instance : Task.WhenAll(doc.SaveAsync(pathA), doc.SaveAsync(pathB)) produit un comportement indéfini.
Questions fréquemment posées
Comment puis-je charger un document Word à partir d'un flux en C# en utilisant IronWord ?
Passez n'importe quel flux lisible, tel qu'un MemoryStream ou un fichier téléchargé, au constructeur WordDocument. IronWord lit le document depuis la position actuelle du flux jusqu'à la fin.
Comment puis-je enregistrer un document Word dans un flux avec IronWord ?
Appelez Save avec n'importe quel flux inscriptible, tel qu'un MemoryStream, pour écrire le document sans l'enregistrer sur le disque. IronWord écrit le document à la position actuelle du flux.
Puis-je charger et enregistrer des documents Word de manière asynchrone en C# ?
Oui. IronWord fournit LoadAsync pour les chemins de fichiers et les flux, ainsi que SaveAsync et SaveAsAsync pour l'enregistrement, pour que le code d'application asynchrone ne bloque pas un thread sur les entrées/sorties de fichiers.
IronWord ferme-t-il le flux après avoir chargé ou enregistré un document ?
Non. IronWord ne ferme jamais le flux d'un appelant. L'application qui a ouvert le flux en est propriétaire et est responsable de sa suppression.
Pourquoi mon document Word enregistré est-il corrompu lorsque je réutilise un flux ?
Enregistrer dans un flux qui contient déjà un document plus long laisse les anciens octets finaux en place, ce qui corrompt la sortie. Réinitialisez ou tronquez le flux avant de l'utiliser à nouveau pour l'enregistrement.
Un CancellationToken peut-il arrêter IronWord pendant qu'il charge ou enregistre un document ?
Le token annule uniquement l'entrée/sortie de fichiers ou de flux. L'analyse d'un document chargé et la sérialisation d'un document enregistré sont des étapes synchrones que le token ne peut pas interrompre.
Existe-t-il une méthode asynchrone pour charger ou enregistrer des tableaux d'octets dans IronWord ?
Non, par conception. Charger à partir d'un tableau d'octets et enregistrer dans un tableau ne comporte aucune entrée/sortie, donc IronWord conserve le constructeur de tableaux d'octets synchrone et la méthode Save pour ces cas en mémoire.
Un WordDocument est-il sûr pour les threads dans IronWord ?
Non. Une instance unique de WordDocument n'est pas sûre pour les threads, donc n'exécutez pas des opérations d'enregistrement simultanément sur le même document, par exemple avec Task.WhenAll.
Puis-je charger un document Word à partir d'un téléchargement sans l'enregistrer d'abord sur le disque ?
Oui. Passez directement le flux du téléchargement au constructeur WordDocument ou LoadAsync, éditez le document en mémoire et enregistrez-le à nouveau dans un flux, pour que le fichier ne touche jamais le disque.
L'enregistrement d'un document Word dans un flux nécessite-t-il une licence IronWord ?
Oui. Enregistrer dans un flux nécessite une licence IronWord valide, tout comme enregistrer à un chemin de fichier ou à un tableau d'octets.
Ahmad est un développeur full-stack avec une solide fondation en C#, Python et technologies web. Il a un profond intérêt pour la construction de solutions logicielles évolutives et aime explorer comment le design et la fonctionnalité se rencontrent dans des applications du monde réel.