USO DE IRONWORD

Cómo generar un documento de Word utilizando una plantilla de Word en C#

Publicado en 24 de octubre, 2024

En las aplicaciones actuales, es fundamental generar documentos de Word sobre la marcha para diversos fines, como facturación, facturas, cartas, etc. La función de documento plantilla de Microsoft Word ofrece una forma eficaz de garantizar la coherencia y la eficiencia. Sin embargo, rellenar manualmente estas plantillas puede llevar mucho tiempo y dar lugar a errores. Ahí es dondeIronWord deIron Software viene en una robusta biblioteca .NET diseñada para automatizar el proceso de rellenar plantillas de Word mediante programación. En este artículo, veremos cómo utilizarIronWord para rellenar una plantilla de documento de Word y proporcionar un ejemplo práctico para ilustrar el proceso.

Cómo generar un documento de Word utilizando una plantilla de Word en C#

Cree un nuevo proyecto en Microsoft Visual Studio.
InstaleIronWord a través del gestor de paquetes NuGet.
Cree un documento de plantilla de Word.
Insertar datos en un documento de Word y guardarlos como un archivo nuevo.
Añade efectos de texto al documento de Word generado.

¿Qué es IronWord?

IronWord es una biblioteca .NET deIron Software diseñado para facilitar la creación, manipulación y gestión de documentos de Microsoft Word mediante programación. Permite a los desarrolladores automatizar el proceso de generación de documentos de Word, facilitando la creación dinámica de informes, facturas, cartas y otros tipos de documentos dentro de sus aplicaciones.

Características principales de IronWord

1. C# Rellenar plantilla de Word y manejo

IronWord permite utilizar plantillas de Word para definir marcadores de posición en un documento de plantilla y sustituirlos por datos reales en tiempo de ejecución.

2. Manipulación de texto

Puede insertar, sustituir o eliminar texto fácilmente en un documento de Word.

3. Formato

La biblioteca admite varias opciones de formato, como estilos de fuente, tamaños, colores y alineación de párrafos.

4. Tablas e imágenes

IronWord permite insertar y manipular tablas e imágenes en los documentos.

**5. Compatibilidad

Funciona a la perfección con distintas versiones de Microsoft Word, lo que garantiza la compatibilidad y la facilidad de uso.

Casos prácticos

Generación de informes: Genere automáticamente informes detallados con datos dinámicos.
Creación de facturas: Cree facturas profesionales rellenando los detalles del cliente y de la transacción.
Gestión de contratos: Automatice la creación de contratos con información personalizada.
Cartas y avisos: Genere cartas y avisos personalizados para clientes o empleados.
IronWord simplifica el trabajo con documentos de Word en aplicaciones .NET, lo que la convierte en una valiosa herramienta para desarrolladores que desean automatizar las tareas de generación y gestión de documentos.

Requisitos previos

Un recordatorio rápido para que te asegures de tener lo siguiente antes de que empecemos:

Visual Studio está instalado en su equipo.
Se ha instalado la última versión de .NET Framework.

Paso 1: Cree un nuevo proyecto en Microsoft Visual Studio.

Empecemos creando un nuevo proyecto de Visual Studio.

Cómo generar un documento de Word utilizando una plantilla de Word en C#: Figura 1

Seleccione la plantilla de aplicación de consola en la pantalla siguiente.

Cómo generar un documento de Word utilizando una plantilla de Word en C#: Figura 2 - Seleccionar aplicación de consola

Indique el nombre y la ubicación del proyecto.

Cómo generar un documento de Word utilizando una plantilla de Word en C#: Figura 3 - Proporcionar nombre y ubicación

Seleccione la versión de .NET, preferiblemente la última compatible, y haga clic en Crear.

Cómo generar un documento de Word utilizando una plantilla de Word en C#: Figura 4

Paso 2: Instale el gestor de paquetes NuGet de IronWord.

Instale el paquete NuGet de IronWord desde el gestor de paquetes NuGet como se indica a continuación en Visual Studio.

Cómo generar un documento de Word utilizando una plantilla de Word en C#: Figura 5 - Búsqueda de IronWord en el gestor de paquetes NuGet

Alternativamente, por favor, instálelo usando CLI directamente usando el comando de abajo.

Cómo generar un documento de Word utilizando una plantilla de Word en C#: Figura 6 - Copie el comando y péguelo en la Aplicación de Consola NuGet

dotnet add package IronWord --version 2024.9.1

dotnet add package IronWord --version 2024.9.1

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'dotnet add package IronWord --version 2024.9.1

VB C#

Paso 3: Crear un documento de plantilla de Word.

Ahora, genere un documento de plantilla de Word con una o dos páginas que se utilizará durante el proceso de generación del documento de Word.

Dear {Name},
Thanks for Purchasing {product}, happy to serve you always. Your application dated {Date} has been approved. The product comes with an expiry date of {expiryDate}. Renew the product on or before expiry date.
Fell Free to contact {phone} or {email} for further queries.
Address: {Address}
Thank you,
{Sender}

Dear {Name},
Thanks for Purchasing {product}, happy to serve you always. Your application dated {Date} has been approved. The product comes with an expiry date of {expiryDate}. Renew the product on or before expiry date.
Fell Free to contact {phone} or {email} for further queries.
Address: {Address}
Thank you,
{Sender}

Dear
If True Then
	Name
End If
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
', Thanks for Purchasing
'{
'	product
'}
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
', happy @to serve you always.Your application dated
'{
'	@Date
'}
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'has been approved.The product comes @with an expiry @date @of
'{
'	expiryDate
'}
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'.Renew the product on @or before expiry @date.Fell Free @to contact
'{
'	phone
'}
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'@or {email} for further queries.Address:
'{
'	Address
'}
Thank you,
If True Then
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'	Sender}

VB C#

Ahora guarda el documento anterior como Plantilla.docx.

Paso 4: Insertar los datos en un documento de Word y guardarlo como un archivo nuevo.

using IronWord;
class Program
{
    static void Main()
    {
        License.LicenseKey = "your key";
        // Define the path to the template and the output file object sender
        string templatePath = "Template.docx";
        string outputPath = "FilledDocument.docx";
        // Create a new instance of the WordDocument class
        WordDocument doc = new WordDocument(templatePath);
            // Define a dictionary/ first table of placeholders and their replacements
            var replacements = new Dictionary<string, string>
            {
                { "{Name}", "John Doe" },
                { "{Date}", DateTime.Now.ToString("MMMM d, yyyy") },
                { "{Address}", "123 Iron Street, Iron Software" },
                { "{product}", "IronWord" },
                { "{Sender}", "IronSoftware" },
                { "{phone}", "+123 456789" },
                { "{email}", "sale@ironsoftware.com" },
                { "{expiryDate}", DateTime.Now.AddYears(1).ToString("MMMM d, yyyy") },
            };
            // Replace placeholders with actual data
            foreach (var replacement in replacements)
            {
                doc.Texts.ForEach(x=>x.Replace(replacement.Key, replacement.Value));
            }
            // Save the filled document
           doc.Save(outputPath);
        Console.WriteLine("Document filled and saved successfully.");
    }
}

using IronWord;
class Program
{
    static void Main()
    {
        License.LicenseKey = "your key";
        // Define the path to the template and the output file object sender
        string templatePath = "Template.docx";
        string outputPath = "FilledDocument.docx";
        // Create a new instance of the WordDocument class
        WordDocument doc = new WordDocument(templatePath);
            // Define a dictionary/ first table of placeholders and their replacements
            var replacements = new Dictionary<string, string>
            {
                { "{Name}", "John Doe" },
                { "{Date}", DateTime.Now.ToString("MMMM d, yyyy") },
                { "{Address}", "123 Iron Street, Iron Software" },
                { "{product}", "IronWord" },
                { "{Sender}", "IronSoftware" },
                { "{phone}", "+123 456789" },
                { "{email}", "sale@ironsoftware.com" },
                { "{expiryDate}", DateTime.Now.AddYears(1).ToString("MMMM d, yyyy") },
            };
            // Replace placeholders with actual data
            foreach (var replacement in replacements)
            {
                doc.Texts.ForEach(x=>x.Replace(replacement.Key, replacement.Value));
            }
            // Save the filled document
           doc.Save(outputPath);
        Console.WriteLine("Document filled and saved successfully.");
    }
}

Imports IronWord
Friend Class Program
	Shared Sub Main()
		License.LicenseKey = "your key"
		' Define the path to the template and the output file object sender
		Dim templatePath As String = "Template.docx"
		Dim outputPath As String = "FilledDocument.docx"
		' Create a new instance of the WordDocument class
		Dim doc As New WordDocument(templatePath)
			' Define a dictionary/ first table of placeholders and their replacements
			Dim replacements = New Dictionary(Of String, String) From {
				{"{Name}", "John Doe"},
				{"{Date}", DateTime.Now.ToString("MMMM d, yyyy")},
				{"{Address}", "123 Iron Street, Iron Software"},
				{"{product}", "IronWord"},
				{"{Sender}", "IronSoftware"},
				{"{phone}", "+123 456789"},
				{"{email}", "sale@ironsoftware.com"},
				{"{expiryDate}", DateTime.Now.AddYears(1).ToString("MMMM d, yyyy")}
			}
			' Replace placeholders with actual data
			For Each replacement In replacements
				doc.Texts.ForEach(Function(x) x.Replace(replacement.Key, replacement.Value))
			Next replacement
			' Save the filled document
		   doc.Save(outputPath)
		Console.WriteLine("Document filled and saved successfully.")
	End Sub
End Class

VB C#

Explicación

El código proporcionado demuestra el uso de la biblioteca IronWord para rellenar una plantilla de documento de Word con datos específicos. He aquí una explicación concisa:

Configuración de la licencia: El código comienza configurando la clave de licencia de IronWord para activar su funcionalidad.
Rutas de archivos: Especifica las rutas para la plantilla de Word(\Plantilla.docx) y el archivo de salida(\DocumentoRelleno.docx).3. Crear instancia de documento: Se crea una instancia de `WordDocument` utilizando la referencia de la ruta de la plantilla.
Definir reemplazos: Se crea un diccionario donde las claves representan marcadores de posición en la plantilla y los valores representan los datos a insertar.5. Reemplazar Marcadores de Posición: Se itera a través del diccionario, sustituyendo cada marcador de posición del documento por los datos correspondientes.
Guardar documento: Finalmente, el documento actualizado se guarda en la ruta de salida especificada con el método save y pasando los parámetros. Mensaje de finalización: Se imprime un mensaje para confirmar que el documento se ha rellenado y guardado correctamente.
Salida

Paso 5: Añadir efectos de texto al documento de Word generado.

IronWord también permite añadir varios efectos de texto, como se muestra en la tabla siguiente.

En el siguiente ejemplo, añadimos efectos de texto a la palabra Word Iron Software.

using IronWord;
using IronWord.Models;
class Program
{
    static void Main()
    {
        License.LicenseKey = "your key";
        // Define the path to the template and the output file
        string templatePath = "Template.docx";
        string outputPath = "FilledDocument.docx";
        // Create a new instance of the WordDocument class
        WordDocument doc = new WordDocument(templatePath);
            // Define a dictionary of placeholders and their replacements
            var replacements = new Dictionary<string, string>
            {
                { "{Name}", "John Doe" },
                { "{Date}", DateTime.Now.ToString("MMMM d, yyyy") },
                { "{Address}", "123 Iron Street, Iron Software" },
                { "{product}", "IronWord" },
                { "{Sender}", "Sale," },
                { "{phone}", "+123 456789" },
                { "{email}", "sale@ironsoftware.com" },
                { "{expiryDate}", DateTime.Now.AddYears(1).ToString("MMMM d, yyyy") },
            };
            // Replace placeholders with actual data
            foreach (var replacement in replacements)
            {
                doc.Texts.ForEach(x=>x.Replace(replacement.Key, replacement.Value));
            }
        // Save the filled document
        //doc.Save(outputPath);
        //Console.WriteLine("Document filled and saved successfully.");
        // Create and configure text style methods
        TextStyle textStyle = new TextStyle();
        textStyle.TextEffect = new TextEffect()
        {
            GlowEffect = new Glow()
            {
                GlowColor = IronWord.Models.Color.Aqua,
                GlowRadius = 10,
            },
        };
        // Add text with style or image
        doc.AddText(" IronSoftware").Style = textStyle;
        // Export new Word document
        doc.SaveAs("glowEffect.docx");
    }
}

using IronWord;
using IronWord.Models;
class Program
{
    static void Main()
    {
        License.LicenseKey = "your key";
        // Define the path to the template and the output file
        string templatePath = "Template.docx";
        string outputPath = "FilledDocument.docx";
        // Create a new instance of the WordDocument class
        WordDocument doc = new WordDocument(templatePath);
            // Define a dictionary of placeholders and their replacements
            var replacements = new Dictionary<string, string>
            {
                { "{Name}", "John Doe" },
                { "{Date}", DateTime.Now.ToString("MMMM d, yyyy") },
                { "{Address}", "123 Iron Street, Iron Software" },
                { "{product}", "IronWord" },
                { "{Sender}", "Sale," },
                { "{phone}", "+123 456789" },
                { "{email}", "sale@ironsoftware.com" },
                { "{expiryDate}", DateTime.Now.AddYears(1).ToString("MMMM d, yyyy") },
            };
            // Replace placeholders with actual data
            foreach (var replacement in replacements)
            {
                doc.Texts.ForEach(x=>x.Replace(replacement.Key, replacement.Value));
            }
        // Save the filled document
        //doc.Save(outputPath);
        //Console.WriteLine("Document filled and saved successfully.");
        // Create and configure text style methods
        TextStyle textStyle = new TextStyle();
        textStyle.TextEffect = new TextEffect()
        {
            GlowEffect = new Glow()
            {
                GlowColor = IronWord.Models.Color.Aqua,
                GlowRadius = 10,
            },
        };
        // Add text with style or image
        doc.AddText(" IronSoftware").Style = textStyle;
        // Export new Word document
        doc.SaveAs("glowEffect.docx");
    }
}

Imports IronWord
Imports IronWord.Models
Friend Class Program
	Shared Sub Main()
		License.LicenseKey = "your key"
		' Define the path to the template and the output file
		Dim templatePath As String = "Template.docx"
		Dim outputPath As String = "FilledDocument.docx"
		' Create a new instance of the WordDocument class
		Dim doc As New WordDocument(templatePath)
			' Define a dictionary of placeholders and their replacements
			Dim replacements = New Dictionary(Of String, String) From {
				{"{Name}", "John Doe"},
				{"{Date}", DateTime.Now.ToString("MMMM d, yyyy")},
				{"{Address}", "123 Iron Street, Iron Software"},
				{"{product}", "IronWord"},
				{"{Sender}", "Sale,"},
				{"{phone}", "+123 456789"},
				{"{email}", "sale@ironsoftware.com"},
				{"{expiryDate}", DateTime.Now.AddYears(1).ToString("MMMM d, yyyy")}
			}
			' Replace placeholders with actual data
			For Each replacement In replacements
				doc.Texts.ForEach(Function(x) x.Replace(replacement.Key, replacement.Value))
			Next replacement
		' Save the filled document
		'doc.Save(outputPath);
		'Console.WriteLine("Document filled and saved successfully.");
		' Create and configure text style methods
		Dim textStyle As New TextStyle()
		textStyle.TextEffect = New TextEffect() With {
			.GlowEffect = New Glow() With {
				.GlowColor = IronWord.Models.Color.Aqua,
				.GlowRadius = 10
			}
		}
		' Add text with style or image
		doc.AddText(" IronSoftware").Style = textStyle
		' Export new Word document
		doc.SaveAs("glowEffect.docx")
	End Sub
End Class

VB C#

**Explicación

El código revisado ilustra el uso de la biblioteca IronWord para rellenar una plantilla de documento de Word, aplicar estilo al texto y guardar el documento modificado. He aquí una explicación concisa:

Configuración de licencia: Establece la clave de licencia de IronWord para habilitar la funcionalidad.
Rutas de archivos: Especifica las rutas para la plantilla(Template.docx) y el archivo de salida(glowEffect.docx).
Crear instancia de documento: Inicializa una instancia de WordDocument utilizando la ruta de la plantilla proporcionada.
Definir sustituciones: Crea un diccionario de marcadores de posición y sus correspondientes valores de sustitución.
Reemplazar marcadores de posición: Recorre el diccionario, sustituyendo los marcadores de posición del documento por datos reales.
Configurar estilo de texto: Define un estilo de texto con un efecto de resplandor, especificando el color y el radio.
Añadir texto con estilo: Añade texto con el estilo configurado al documento.
Guardar documento: Guarda el documento actualizado con un nuevo nombre(glowEffect.docx)la traducción debe reflejar el estilo de texto aplicado.
Salida de consola: La declaración de salida de la consola anterior se comenta, y la operación de guardar se ha actualizado para reflejar el nuevo nombre del documento.
Este código demuestra las funciones de automatización y personalización de documentos de IronWord, incluida la sustitución de texto y el estilo.
Salida

Licencia de IronWord

IronWord. Una vez introducidos los datos, la licencia se envía a la dirección de correo electrónico proporcionada. Esta licencia debe colocarse al principio del código, antes de utilizar la funciónIronWord biblioteca, como se indica a continuación.

License.LicenseKey = "your Key Here"

License.LicenseKey = "your Key Here"

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'License.LicenseKey = "your Key Here"

VB C#

Conclusión

IronWord ofrece varias ventajas para generar documentos de Word utilizando plantillas. Simplifica la automatización de la creación de documentos al permitir a los desarrolladores rellenar mediante programación plantillas con datos específicos, lo que reduce la necesidad de introducir datos manualmente. Esto aumenta la eficacia y la precisión, ya que se minimiza el riesgo de error humano. Además,IronWord ayuda a mantener la coherencia entre los documentos, garantizando que cada archivo generado se adhiere al mismo formato y estructura. La automatización de tareas repetitivas ahorra tiempo y recursos, por lo que resulta ideal para producir rápidamente grandes volúmenes de documentos. IronWord mejora la productividad y agiliza los flujos de trabajo en escenarios que requieren la generación frecuente o compleja de documentos.

Siguiendo los pasos descritos en este artículo y aprovechando el ejemplo proporcionado conIronWordde este modo, podrá gestionar eficazmente sus necesidades de generación de documentos y agilizar su flujo de trabajo.

SIGUIENTE >
Cómo añadir una marca de agua a un archivo de Word en C#