Ícono de mensaje
Saltar al pie de página
  1. IronWord
  2. Blog de IronWord
  3. Usando IronWord
  4. C# Completar Plantilla de Word
USANDO IRONWORD

Cómo Generar un Documento Word Usando una Plantilla de Word en C#

Jordi Bardia
Jordi Bardia
Actualizado:

En las aplicaciones modernas, es crucial generar documentos de Word al instante para diversos propósitos como facturación, facturas, cartas, etc. La función de documento plantilla de Microsoft Word ofrece una poderosa manera de garantizar consistencia y eficiencia. Sin embargo, completar manualmente estas plantillas puede consumir tiempo y ser propenso a errores. Ahí es donde IronWord de Iron Software entra en juego: una robusta biblioteca .NET diseñada para automatizar el proceso de rellenar plantillas de Word de manera programática. En este artículo, explicaremos cómo usar IronWord para completar una plantilla de documento de Word y proporcionamos un ejemplo práctico para ilustrar el proceso.

Cómo generar un documento de Word usando una plantilla de Word en C

  1. Crea un nuevo proyecto en Microsoft Visual Studio.
  2. Instale IronWord a través del gestor de paquetes NuGet.
  3. Cree un documento de Plantilla de Word.
  4. Inserte datos en un documento de Word y guárdelo como un nuevo archivo.
  5. Agregue efectos de texto al documento de Word generado.

¿Qué es IronWord?

IronWord es una biblioteca .NET de Iron Software diseñada para facilitar la creación, manipulación y gestión de documentos de Microsoft Word de manera programática. Permite a los desarrolladores automatizar el proceso de generar 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. Plantilla de Word para rellenar en C# y su manejo

IronWord permite el uso de plantillas de Word para definir marcadores de posición en un documento plantilla y reemplazarlos con datos reales en tiempo de ejecución.

2. Manipulación de texto

Puedes insertar, reemplazar o eliminar texto fácilmente dentro de un documento de Word.

3. Formato

La biblioteca soporta varias opciones de formateo, incluyendo 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 dentro de sus documentos.

5. Compatibilidad

Funciona a la perfección con diferentes versiones de Microsoft Word, garantizando compatibilidad y facilidad de uso.

Casos de uso

  • Generación de Informes: Generar automáticamente informes detallados con datos dinámicos.
  • Creación de Facturas: Crea facturas profesionales rellenando los detalles del cliente y la transacción.
  • Gestión de Contratos: Automatiza la creación de contratos con información personalizada.
  • Cartas y Avisos: Genera cartas y avisos personalizados para clientes o empleados.

IronWord simplifica el trabajo con documentos de Word en aplicaciones .NET, convirtiéndolo en una herramienta valiosa para los desarrolladores que desean automatizar las tareas de generación y gestión de documentos.

Requisitos previos

Un recordatorio rápido para asegurarte de que tienes lo siguiente antes de comenzar:

  • Visual Studio instalado en su máquina.
  • La última versión de .NET Framework está instalada.

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

Ahora, comencemos creando un nuevo proyecto de Visual Studio.

Cómo Generar un Documento de Word Usando una Plantilla de Word en C#: Figura 1

Seleccione la plantilla de aplicación de consola en la pantalla a continuación.

Cómo Generar un Documento de Word Usando una Plantilla de Word en C#: Figura 2 - Seleccione App de Consola

Proporciona el nombre y la ubicación del proyecto.

Cómo Generar un Documento de Word Usando una Plantilla de Word en C#: Figura 3 - Proporcione nombre y ubicación

Selecciona la Versión de .NET, preferiblemente la última con soporte, y haz clic en Crear.

Cómo Generar un Documento de Word Usando una Plantilla de Word en C#: Figura 4

Paso 2: Instale el administrador de paquetes NuGet IronWord.

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

Cómo Generar un Documento de Word Usando una Plantilla de Word en C#: Figura 5 - Buscar IronWord desde NuGet Package Manager

Alternativamente, instálalo directamente usando la CLI utilizando el siguiente comando.

dotnet add package IronWord --version 2024.9.1
dotnet add package IronWord --version 2024.9.1
SHELL

Paso 3: Crea un documento de plantilla de Word.

Ahora, genere un documento de plantilla de Word con una o dos páginas para ser utilizado durante el proceso de generación del documento de Word.

Dear {Name},

Thanks for purchasing {product}. We are 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 the expiry date.

Feel free to contact {phone} or {email} for further queries.

Address: {Address}

Thank you,

{Sender}

Ahora, guarde el documento anterior como Template.docx.

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

using System;
using System.Collections.Generic;
using IronWord;

class Program
{
    static void Main()
    {
        // Set the license key for IronWord
        License.LicenseKey = "your key";

        // Define paths for the template and the output file
        string templatePath = "Template.docx";
        string outputPath = "FilledDocument.docx";

        // Create a new instance of the WordDocument class using the template path
        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}", "IronSoftware" },
            { "{phone}", "+123 456789" },
            { "{email}", "sale@ironsoftware.com" },
            { "{expiryDate}", DateTime.Now.AddYears(1).ToString("MMMM d, yyyy") },
        };

        // Replace placeholders in the document 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);

        // Notify the user that the document has been saved successfully
        Console.WriteLine("Document filled and saved successfully.");
    }
}
using System;
using System.Collections.Generic;
using IronWord;

class Program
{
    static void Main()
    {
        // Set the license key for IronWord
        License.LicenseKey = "your key";

        // Define paths for the template and the output file
        string templatePath = "Template.docx";
        string outputPath = "FilledDocument.docx";

        // Create a new instance of the WordDocument class using the template path
        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}", "IronSoftware" },
            { "{phone}", "+123 456789" },
            { "{email}", "sale@ironsoftware.com" },
            { "{expiryDate}", DateTime.Now.AddYears(1).ToString("MMMM d, yyyy") },
        };

        // Replace placeholders in the document 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);

        // Notify the user that the document has been saved successfully
        Console.WriteLine("Document filled and saved successfully.");
    }
}
Imports System
Imports System.Collections.Generic
Imports IronWord

Friend Class Program
	Shared Sub Main()
		' Set the license key for IronWord
		License.LicenseKey = "your key"

		' Define paths for 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 using the template path
		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}", "IronSoftware"},
			{"{phone}", "+123 456789"},
			{"{email}", "sale@ironsoftware.com"},
			{"{expiryDate}", DateTime.Now.AddYears(1).ToString("MMMM d, yyyy")}
		}

		' Replace placeholders in the document 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)

		' Notify the user that the document has been saved successfully
		Console.WriteLine("Document filled and saved successfully.")
	End Sub
End Class
$vbLabelText   $csharpLabel

Explicación

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

  1. Configuración de Licencia: El código comienza configurando la clave de licencia para IronWord para activar su funcionalidad.
  2. Rutas de Archivos: Especifica las rutas para la plantilla de Word (Template.docx) y el archivo de salida (FilledDocument.docx).
  3. Crear Instancia de Documento: Se crea una instancia de WordDocument usando la referencia de la ruta de la plantilla.
  4. Definir Reemplazos: Se crea un diccionario donde las claves representan los marcadores de posición en la plantilla y los valores representan los datos a insertar.
  5. Reemplazar Marcadores de Posición: Itera a través del diccionario, reemplazando cada marcador de posición en el documento con los datos correspondientes.
  6. Guardar Documento: Finalmente, el documento actualizado se guarda en la ruta de salida especificada.
  7. Mensaje de Finalización: Se imprime un mensaje para confirmar que el documento ha sido completado y guardado exitosamente.

Output

Cómo Generar un Documento de Word Usando una Plantilla de Word en C#: Figura 7 - Salida de Documento de Word

Paso 5: Agregue efectos de texto al documento de Word generado.

IronWord también permite agregar varios efectos de texto, como se muestra en la tabla a continuación.

En el siguiente ejemplo, agregamos efectos de texto a la palabra "Iron Software".

using System;
using System.Collections.Generic;
using IronWord;
using IronWord.Models;

class Program
{
    static void Main()
    {
        // Set the license key for IronWord
        License.LicenseKey = "your key";

        // Define paths for the template and the output file
        string templatePath = "Template.docx";
        string outputPath = "glowEffect.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 in the document with actual data
        foreach (var replacement in replacements)
        {
            doc.Texts.ForEach(x => x.Replace(replacement.Key, replacement.Value));
        }

        // Create and configure text style methods with a glow effect
        TextStyle textStyle = new TextStyle
        {
            TextEffect = new TextEffect()
            {
                GlowEffect = new Glow()
                {
                    GlowColor = IronWord.Models.Color.Aqua,
                    GlowRadius = 10,
                },
            }
        };

        // Add styled text to the document
        doc.AddText(" IronSoftware").Style = textStyle;

        // Save the document with the glow effect
        doc.SaveAs(outputPath);

        // Notify the user that the document has been saved successfully
        Console.WriteLine("Styled document saved successfully.");
    }
}
using System;
using System.Collections.Generic;
using IronWord;
using IronWord.Models;

class Program
{
    static void Main()
    {
        // Set the license key for IronWord
        License.LicenseKey = "your key";

        // Define paths for the template and the output file
        string templatePath = "Template.docx";
        string outputPath = "glowEffect.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 in the document with actual data
        foreach (var replacement in replacements)
        {
            doc.Texts.ForEach(x => x.Replace(replacement.Key, replacement.Value));
        }

        // Create and configure text style methods with a glow effect
        TextStyle textStyle = new TextStyle
        {
            TextEffect = new TextEffect()
            {
                GlowEffect = new Glow()
                {
                    GlowColor = IronWord.Models.Color.Aqua,
                    GlowRadius = 10,
                },
            }
        };

        // Add styled text to the document
        doc.AddText(" IronSoftware").Style = textStyle;

        // Save the document with the glow effect
        doc.SaveAs(outputPath);

        // Notify the user that the document has been saved successfully
        Console.WriteLine("Styled document saved successfully.");
    }
}
Imports System
Imports System.Collections.Generic
Imports IronWord
Imports IronWord.Models

Friend Class Program
	Shared Sub Main()
		' Set the license key for IronWord
		License.LicenseKey = "your key"

		' Define paths for the template and the output file
		Dim templatePath As String = "Template.docx"
		Dim outputPath As String = "glowEffect.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 in the document with actual data
		For Each replacement In replacements
			doc.Texts.ForEach(Function(x) x.Replace(replacement.Key, replacement.Value))
		Next replacement

		' Create and configure text style methods with a glow effect
		Dim textStyle As New TextStyle With {
			.TextEffect = New TextEffect() With {
				.GlowEffect = New Glow() With {
					.GlowColor = IronWord.Models.Color.Aqua,
					.GlowRadius = 10
				}
			}
		}

		' Add styled text to the document
		doc.AddText(" IronSoftware").Style = textStyle

		' Save the document with the glow effect
		doc.SaveAs(outputPath)

		' Notify the user that the document has been saved successfully
		Console.WriteLine("Styled document saved successfully.")
	End Sub
End Class
$vbLabelText   $csharpLabel

Explicación

El código revisado ilustra el uso de la biblioteca IronWord para llenar una plantilla de documento de Word, estilizar texto y guardar el documento modificado. Aquí hay una explicación concisa:

  1. Configuración de Licencia: Establece la clave de licencia de IronWord para habilitar la funcionalidad.
  2. Rutas de Archivos: Especifica las rutas para la plantilla (Template.docx) y el archivo de salida (glowEffect.docx).
  3. Crear Instancia de Documento: Inicializa una instancia de WordDocument usando la ruta de plantilla proporcionada.
  4. Definir Reemplazos: Crea un diccionario de marcadores de posición y sus valores de reemplazo correspondientes.
  5. Reemplazar Marcadores de Posición: Itera a través del diccionario, reemplazando los marcadores de posición en el documento con datos reales.
  6. Configurar Estilo de Texto: Define un estilo de texto con un efecto de resplandor, especificando color y radio.
  7. Agregar Texto Estilizado: Agrega texto con el estilo configurado al documento.
  8. Guardar Documento: Guarda el documento actualizado con un nuevo nombre (glowEffect.docx), reflejando el estilo de texto aplicado.
  9. Salida de Consola: Se imprime un mensaje para confirmar que el documento estilizado ha sido guardado.

Output

Cómo Generar un Documento de Word Usando una Plantilla de Word en C#: Figura 8 - Ejemplo de Salida de Word

Licencias de IronWord

IronWord. Una vez que los datos son ingresados, la licencia se entrega al ID de correo electrónico proporcionado. Esta licencia necesita colocarse al principio del código, antes de usar la biblioteca IronWord, como se muestra a continuación.

License.LicenseKey = "your Key Here";
License.LicenseKey = "your Key Here";
License.LicenseKey = "your Key Here"
$vbLabelText   $csharpLabel

Conclusión

IronWord ofrece varias ventajas para generar documentos de Word usando plantillas. Simplifica la automatización de creación de documentos al permitir a los desarrolladores completar plantillas programáticamente con datos específicos, reduciendo la necesidad de entrada manual. Esto aumenta la eficiencia y precisión, ya que se minimiza el riesgo de error humano. Además, IronWord ayuda a mantener la consistencia entre documentos, asegurando que cada archivo generado siga el mismo formato y estructura. Automatizar tareas repetitivas ahorra tiempo y recursos, siendo ideal para producir rápidamente grandes volúmenes de documentos. IronWord mejora la productividad y simplifica flujos de trabajo en escenarios que requieren generación frecuente o compleja de documentos.

Siguiendo los pasos descritos en este artículo y aprovechando el ejemplo proporcionado con IronWord, puede gestionar eficientemente sus necesidades de generación de documentos y simplificar su flujo de trabajo.

Preguntas Frecuentes

¿Cómo puedo completar una plantilla de documento de Word usando C#?

Puedes completar una plantilla de documento de Word usando C# aprovechando IronWord. Primero, configura tu proyecto en Visual Studio e instala el paquete IronWord a través de NuGet. Crea una plantilla de Word y usa IronWord para insertar datos, luego guarda la plantilla llena como un nuevo documento.

¿Cuáles son los beneficios de usar una biblioteca .NET para la automatización de plantillas de Word?

Usar una biblioteca .NET como IronWord para la automatización de plantillas de Word reduce la entrada manual, minimiza errores y asegura consistencia en la creación de documentos. Permite manejar eficientemente tareas como facturación, emisión de facturas y redacción de cartas.

¿Puedo agregar efectos de texto al completar una plantilla de Word programáticamente?

Sí, con IronWord, puedes agregar efectos de texto como resplandor o sombra al texto en tus documentos de Word al completar plantillas programáticamente.

¿Qué pasos están involucrados al configurar IronWord en un proyecto de Visual Studio?

Para configurar IronWord en un proyecto de Visual Studio, comienza instalando el paquete NuGet de IronWord, crea tu plantilla de Word, y luego usa los métodos de IronWord para rellenar y guardar el documento programáticamente.

¿Cómo asegura IronWord la consistencia en la generación de documentos?

IronWord asegura la consistencia al permitir a los desarrolladores usar plantillas de Word que mantienen el mismo formato y diseño a través de múltiples documentos, reduciendo el riesgo de errores humanos.

¿Cuáles son algunas aplicaciones prácticas de la automatización de generación de documentos de Word?

La automatización de generación de documentos de Word con IronWord puede aplicarse en varios escenarios, incluyendo generación de reportes, creación de facturas, gestión de contratos y redacción de cartas personalizadas.

¿Es posible manejar diferentes versiones de Microsoft Word usando IronWord?

Sí, IronWord es compatible con varias versiones de Microsoft Word, permitiendo un manejo sin problemas de documentos en diferentes entornos.

¿Qué se requiere para comenzar a usar IronWord para la gestión de documentos de Word?

Para comenzar a usar IronWord, asegúrate de tener instalado Visual Studio, junto con el último .NET Framework. Luego, agrega IronWord a tu proyecto a través del gestor de paquetes NuGet.

Jordi Bardia
Jordi Bardia
  Chatea con el equipo de ingeniería ahora
Ingeniero de Software
Jordi es más competente en Python, C# y C++. Cuando no está aprovechando sus habilidades en Iron Software, está programando juegos. Compartiendo responsabilidades para pruebas de productos, desarrollo de productos e investigación, Jordi agrega un valor inmenso a la mejora continua del producto. La experiencia variada lo mantiene ...
Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Comenzar prueba gratuita