Generar Word a partir de una plantilla en C#

La generación automatizada de documentos de Word es muy utilizada por las empresas para crear multitud de informes. En algunos casos, los documentos se crean desde cero. Por otro lado, las plantillas predefinidas se utilizan para generar documentos de Word completando los marcadores de posición. En este artículo, demostraré cómo generar documentos de Word a partir de plantillas de forma dinámica y programática en C#. Llegará a saber cómo completar las plantillas de Word a partir de diferentes tipos de fuentes de datos.

Los siguientes escenarios junto con los ejemplos de código se tratarán en este artículo:

API de automatización de palabras de C#

Usaremos Aspose.Words for .NET: una API de automatización de Word que le permite generar documentos de Word desde cero o completando las plantillas de Word predefinidas. Puede descargar los archivos binarios de la API o instalarlos usando uno de los siguientes métodos.

Uso del Administrador de paquetes NuGet

Uso de la consola del administrador de paquetes

PM> Install-Package Aspose.Words

Genere un documento de Word a partir de una plantilla usando objetos de C#

En primer lugar, veamos cómo completar la plantilla de Word con los objetos de C#. Para ello, crearemos un documento de Word (DOC/DOCX) con los siguientes marcadores de posición como contenido del documento:

<<[sender.Name]>> says: "<<[sender.Message]>>."

Aquí, el remitente es el objeto de la siguiente clase que usaremos para completar la plantilla.

public class Sender
{
	public string Name { get; set; }
	public string Message { get; set; }

	public Sender (string _name, string _message)
	{
		Name = _name;
		Message = _message;
	}
}

Ahora, usaremos el motor de informes de Aspose.Words para generar el documento de Word a partir de la plantilla y el objeto de la clase Remitente siguiendo los pasos a continuación.

  • Cree un objeto de la clase Document e inicialícelo con la ruta de la plantilla de Word.
  • Crea e inicializa un objeto de la clase Sender.
  • Crea una instancia de la clase ReportingEngine.
  • Complete las plantillas usando ReportingEngine.BuildReport() que toma el objeto del documento, la fuente de datos y el nombre de la fuente de datos como parámetros.
  • Guarde el documento de Word generado utilizando el método Document.Save().

El siguiente ejemplo de código muestra cómo generar un documento de Word a partir de una plantilla en C#.

Document doc = new Document("template.docx");
Sender sender = new Sender("LINQ Reporting Engine", "Hello World");
ReportingEngine engine = new ReportingEngine();
engine.BuildReport(doc, sender, "sender");
doc.Save("word.docx");

Producción

Genere un documento de Word a partir de una fuente de datos XML en C#

Para generar el documento de Word a partir de una fuente de datos XML, usaremos una plantilla de Word un poco más compleja con los siguientes marcadores de posición:

<<foreach [in persons]>>Name: <<[Name]>>, Age: <<[Age]>>, Date of Birth: <<[Birth]:"dd.MM.yyyy">>
<</foreach>>
Average age: <<[persons.Average(p => p.Age)]>>

La fuente de datos XML que he usado en este ejemplo se proporciona a continuación.

<Persons>
   <Person>
       <Name>John Doe</Name>
       <Age>30</Age>
       <Birth>1989-04-01 4:00:00 pm</Birth>
   </Person>
   <Person>
       <Name>Jane Doe</Name>
       <Age>27</Age>
       <Birth>1992-01-31 07:00:00 am</Birth>
   </Person>
   <Person>
       <Name>John Smith</Name>
       <Age>51</Age>
       <Birth>1968-03-08 1:00:00 pm</Birth>
   </Person>
</Persons>

Los siguientes son los pasos para generar un documento de Word a partir de una fuente de datos XML:

  • Cree una instancia de la clase Documento e inicialícela con la ruta de la plantilla de Word.
  • Cree una instancia de la clase XmlDataSource e inicialícela con la ruta del archivo XML.
  • Crea una instancia de la clase ReportingEngine.
  • Use el método ReportingEngine.BuildReport() de la misma manera que lo hemos usado antes para completar la plantilla de Word.
  • Guarde el documento de Word generado utilizando el método Document.Save().

El siguiente ejemplo de código muestra cómo generar un documento de Word a partir de un origen de datos XML en C#.

Document doc = new Document("template.docx");
XmlDataSource dataSource = new XmlDataSource("datasource.xml");
ReportingEngine engine = new ReportingEngine();
engine.BuildReport(doc, dataSource, "persons");
doc.Save("word.docx");

Producción

Genere un documento de Word a partir de una fuente de datos JSON en C#

Veamos ahora cómo generar un documento de Word utilizando una fuente de datos JSON. En este ejemplo, generaremos una lista de los clientes que están agrupados por sus administradores. La siguiente sería la plantilla de Word en este caso:

<<foreach [in managers]>>Manager: <<[Name]>>
Contracts:
<<foreach [in Contract]>>- <<[Client.Name]>> ($<<[Price]>>)
<</foreach>>
<</foreach>>

La siguiente sería la fuente de datos JSON que usaremos para completar la plantilla:

[
   {
       Name: "John Smith",
       Contract:
       [
           {
               Client:
               {
                   Name: "A Company"
               },
               Price: 1200000
           },
           {
               Client:
               {
                   Name: "B Ltd."
               },
               Price: 750000
           },
           {
               Client:
               {
                   Name: "C & D"
               },
               Price: 350000
           }
       ]
   },
   {
       Name: "Tony Anderson",
       Contract:
       [
           {
               Client:
               {
                   Name: "E Corp."
               },
               Price: 650000
           },
           {
               Client:
               {
                   Name: "F & Partners"
               },
               Price: 550000
           }
       ]
   },
]

Para generar el documento de Word desde JSON, usaremos la clase JsonDataSource para cargar y usar la fuente de datos JSON y el resto de los pasos seguirán siendo los mismos. El siguiente ejemplo de código muestra cómo generar un documento de Word a partir de la plantilla mediante JSON en C#.

Document doc = new Document("template.docx");
JsonDataSource dataSource = new JsonDataSource("datasource.json");
ReportingEngine engine = new ReportingEngine();
engine.BuildReport(doc, dataSource, "managers");
doc.Save("word.docx");

Producción

Genere un documento de Word a partir de una fuente de datos CSV en C#

Para generar el documento de Word desde CSV, usaremos la siguiente plantilla de Word:

<<foreach [in persons]>>Name: <<[Column1]>>, Age: <<[Column2]>>, Date of Birth: <<[Column3]:"dd.MM.yyyy">>
<</foreach>>
Average age: <<[persons.Average(p => p.Column2)]>>

La plantilla se completará con los siguientes datos CSV:

John Doe,30,1989-04-01 4:00:00 pm
Jane Doe,27,1992-01-31 07:00:00 am
John Smith,51,1968-03-08 1:00:00 pm

Ahora, pasemos al código C#. Todos los pasos seguirán siendo los mismos aquí, excepto por el único cambio: usaremos la clase CsvDataSource para cargar los datos CSV. El siguiente ejemplo de código muestra cómo generar el documento de Word a partir de una fuente de datos CSV.

Document doc = new Document("template.docx");
CsvDataSource dataSource = new CsvDataSource("datasource.csv");
ReportingEngine engine = new ReportingEngine();
engine.BuildReport(doc, dataSource, "persons");
doc.Save("word.docx");

Producción

Pruebe Aspose.Words for .NET gratis

Puede probar Aspose.Words for .NET usando una licencia temporal gratuita.

Conclusión

En este artículo, ha aprendido a generar documentos de Word a partir de plantillas usando C#. Además, ha visto cómo usar fuentes de datos de objetos, XML, JSON y CSV para generar documentos de Word. Puede explorar más sobre la API de automatización de C# Word utilizando documentación. Además, puede ponerse en contacto con nosotros a través de nuestro foro.

Ver también