Cómo cargar y guardar documentos de Word con flujos y Async en C#
IronWord 2026.10.1+ introduce la carga directa desde y el guardado a cualquier System.IO.Stream, junto con métodos asincrónicos para ambos. La carga y el guardado funcionaban previamente mediante rutas de archivo y matrices de bytes. Un .docx que llega como una carga web, baja del almacenamiento en blob o se devuelve en una respuesta HTTP nunca tiene que tocar el disco, por lo que las funciones sin servidor y los puntos finales web permanecen completamente en memoria.
Tres puntos de entrada en WordDocument cubren todos los escenarios: una ruta de archivo cuando el .docx está en el disco, un flujo cuando los bytes ya están fluyendo, y una matriz de bytes cuando todo está en memoria.
Pase cualquier flujo legible al constructor WordDocument, luego guarde en otro flujo, como en el ejemplo de carga y guardado con flujos.
-
1Instalar IronWord con NuGet Package Manager
-
2Copie y ejecute este fragmento de código.
using var input = File.OpenRead("source.docx"); var doc = new WordDocument(input); using var output = new MemoryStream(); doc.Save(output);C# -
3Despliegue para probar en su entorno real
Empiece a usar IronWord en su proyecto hoy con una prueba gratuita
Flujo de trabajo mínimo (5 pasos)
¿Qué sobrecarga de Cargar y Guardar debería usar?
Escoja la sobrecarga que se ajuste al lugar donde están los datos.
| Método | Dirección | E/S | Async |
|---|---|---|---|
WordDocument(string filePath) | Cargar | Archivo | No |
WordDocument(byte[] bytes) | Cargar | None | No |
WordDocument(Stream stream) | Cargar | Enviar a | No |
WordDocument.LoadAsync(string, CancellationToken) | Cargar | Archivo | Sí |
WordDocument.LoadAsync(Stream, CancellationToken) | Cargar | Enviar a | Sí |
Save() devuelve byte[] | Guardar | None | No |
Save(string filePath) | Guardar | Archivo | No |
Save(Stream stream) | Guardar | Enviar a | No |
SaveAs(string filePath) | Guardar | Archivo | No |
SaveAsync(string, CancellationToken) | Guardar | Archivo | Sí |
SaveAsync(Stream, CancellationToken) | Guardar | Enviar a | Sí |
SaveAsAsync(string, CancellationToken) | Guardar | Archivo | Sí |
Las matrices de bytes permanecen sincrónicas por diseño: construir a partir de bytes y serializar a una matriz de bytes no realiza E/S, por lo que no hay nada que esperar. Para producir un documento completamente en memoria y obtenerlo como bytes, llame a byte[] Save().
Guardar requiere una licencia válida de IronWord, al igual que cualquier otra ruta de guardado.
¿Cuál es el contrato de flujo?
Cinco reglas gobiernan cómo IronWord trata el flujo de un llamador.
- Propiedad del flujo: IronWord nunca cierra el flujo del llamador, por lo que el llamador lo posee y dispone de él
- Carga: lee desde la posición actual hasta el final y deja el flujo en su final
- Guardado: escribe en la posición actual
- Sin truncamiento: un flujo reutilizado que ya contenía un documento más largo conserva sus bytes finales antiguos después del nuevo contenido y el resultado es un .docx corrupto, por lo que reinícielo con
SetLength(0)antes de guardar - Flujos no ubicables: se admiten tanto como fuente como destino, ya que ni la carga ni el guardado buscan
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");
¿Cómo uso flujos en ASP.NET Core?
ASP.NET Core: new WordDocument(Request.Body) y doc.Save(Response.Body) lanzan bajo el predeterminado de Kestrel, por lo que use LoadAsync y SaveAsync
¿Cómo se ve el documento cargado?
La carga es un breve memo del proveedor con un título y dos párrafos.

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();
¿Qué devuelve el punto final?
El punto final devuelve el mismo memo con un párrafo CONFIDENTIAL añadido.

¿Qué hacen realmente los métodos asíncronos?
Solo el I/O de archivo o flujo es asíncrono y cancelable. Analizar un documento cargado y serializar uno guardado son pasos sincrónicos, dependientes de la CPU, que CancellationToken no puede interrumpir. El token se verifica antes de ese trabajo y alrededor de las llamadas de I/O.
¿Cómo se ve el informe antes del guardado?
report.docx contiene un título y dos párrafos.

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");
¿Cómo se ve el informe actualizado?
report-updated.docx gana la línea de apéndice fechada, y report.docx permanece sin cambios.

¿Es seguro cancelar guardados de archivo?
La cancelación es segura solo si el token ya está cancelado cuando la llamada comienza. En ese caso, una guardado de ruta lanza antes de que el archivo de destino se abra, por lo que un archivo existente no se toca.
Después de que la escritura comienza: un guardado cancelado puede dejar el archivo vacío o parcialmente escrito, con su contenido antiguo desaparecido, y un flujo parcialmente escrito
¿Es WordDocument seguro para hilos?
No. Una sola instancia de WordDocument no es segura para hilos. No ejecute operaciones de guardado concurrentemente contra la misma instancia: Task.WhenAll(doc.SaveAsync(pathA), doc.SaveAsync(pathB)) produce un comportamiento indefinido.
Preguntas frecuentes
¿Cómo puedo cargar un documento de Word desde un stream en C# usando IronWord?
Pase cualquier stream legible, como un MemoryStream o un archivo subido, al constructor de WordDocument. IronWord lee el documento desde la posición actual del stream hasta el final.
¿Cómo puedo guardar un documento de Word en un stream con IronWord?
Llame a Save con cualquier stream escribible, como un MemoryStream, para escribir el documento sin guardarlo en el disco. IronWord escribe el documento en la posición actual del stream.
¿Puedo cargar y guardar documentos de Word de forma asíncrona en C#?
Sí. IronWord proporciona LoadAsync para rutas de archivos y streams, además de SaveAsync y SaveAsAsync para guardar, de modo que el código de aplicación asíncrono no bloquee un hilo en la E/S de archivos.
¿IronWord cierra el stream después de cargar o guardar un documento?
No. IronWord nunca cierra el stream del llamador. La aplicación que abrió el stream lo posee y es responsable de desecharlo.
¿Por qué se corrompe mi documento de Word guardado cuando reutilizo un stream?
Guardar en un stream que ya contiene un documento más largo deja en su lugar los bytes antiguos al final, lo que corrompe la salida. Restablezca o trunque el stream antes de guardar en él nuevamente.
¿Puede un CancellationToken detener a IronWord mientras carga o guarda un documento?
El token cancela solo la E/S de archivos o streams. Analizar un documento cargado y serializar uno guardado son pasos sincrónicos que el token no puede interrumpir.
¿Existe un método asíncrono para cargar o guardar matrices de bytes en IronWord?
No, por diseño. Cargar desde una matriz de bytes y guardar en una no implica E/S, por lo que IronWord mantiene el constructor sincrónico de matrices de bytes y el método Save para esos casos en memoria.
¿Es un WordDocument seguro para subprocesos en IronWord?
No. Una única instancia de WordDocument no es segura para subprocesos, por lo que no ejecute operaciones de guardado de manera concurrente contra el mismo documento, por ejemplo, con Task.WhenAll.
¿Puedo cargar un documento de Word desde una carga sin guardarlo primero en el disco?
Sí. Pase el stream de la carga directamente al constructor de WordDocument o LoadAsync, edite el documento en memoria y guárdelo de nuevo en un stream, para que el archivo nunca toque el disco.
¿Guardar un documento de Word en un stream requiere una licencia de IronWord?
Sí. Guardar en un stream requiere una licencia válida de IronWord, al igual que guardar en una ruta de archivo o en una matriz de bytes.
Ahmad es un desarrollador full-stack con una sólida base en C#, Python y tecnologías web. Tiene un profundo interés en construir soluciones de software escalables y disfruta explorando cómo el diseño y la funcionalidad se encuentran en aplicaciones del mundo real.