How can IronWord assist with filling Word templates in C#?

IronWord allows developers to use Word templates by defining placeholders and replacing them with actual data at runtime, simplifying the process of generating Word documents programmatically.

What are some key features of IronWord?

IronWord supports text manipulation, various formatting options, insertion of tables and images, and compatibility with different versions of Microsoft Word.

Can IronWord manage text formatting in generated Word documents?

Yes, IronWord provides options for text formatting, including font styles, sizes, colors, and paragraph alignment.

How does IronWord help with document consistency?

By automating the filling of Word templates, IronWord ensures each document adheres to the same format and structure, maintaining consistency across generated documents.

What are some use cases for IronWord?

IronWord can be used for report generation, invoice creation, contract management, and generating personalized letters and notices.

How can text effects be added to a Word document using IronWord?

IronWord allows for text effects such as glow; developers can define text styles and apply these to text elements within the document.

What are the prerequisites for using IronWord in a project?

You need to have Microsoft Visual Studio and the latest .NET Framework installed to use IronWord in your project.

How do you install IronWord for use in C# projects?

IronWord can be installed via the NuGet package manager in Visual Studio, or using the command line interface with a specific command to add the package.

The C# DOCX Library

Q: What is the primary purpose of IronWord?

IronWord is a .NET library designed to automate the creation, manipulation, and management of Microsoft Word documents programmatically.

Q: Is IronWord compatible with all versions of Microsoft Word?

Yes, IronWord is designed to work seamlessly with different versions of Microsoft Word, ensuring ease of use and broad compatibility.

Explore IronWord Start Free Trial

Add Text

See All Code Examples

using IronWord;
using IronWord.Models;

// Load docx
WordDocument doc = new WordDocument("document.docx");

// Add text
doc.AddText("Add text using IronWord");

// Export docx
doc.SaveAs("save_document.docx");

using IronWord;
using IronWord.Models;

// Load docx
WordDocument doc = new WordDocument("document.docx");

// Add text
doc.AddText("Add text using IronWord");

// Export docx
doc.SaveAs("save_document.docx");

PM >Install-Package IronWord

Install-Package IronWord

USING IRONWORD

How to Generate a Word Document Using a Word Template in C#

Curtis Chau

Updated: August 1, 2026

In modern-day applications, it is crucial to generate Word documents on the fly for various purposes like billing, invoices, letters, etc. The Microsoft Word template document feature offers a powerful way to ensure consistency and efficiency. However, manually populating these templates can be time-consuming and prone to errors. That's where IronWord from Iron Software comes in - a robust .NET library designed to automate the process of filling Word templates programmatically. In this article, we'll walk through how to use IronWord to fill a Word document template and provide a practical example to illustrate the process.

How to Generate a Word Document Using a Word Template in C#

Create a new project in Microsoft Visual Studio.
Install IronWord through NuGet package manager.
Create a Word Template document.
Insert data into a Word document and save it as a new file.
Add text effects to the generated Word document.

What is IronWord?

IronWord is a .NET library from Iron Software designed to facilitate the creation, manipulation, and management of Microsoft Word documents programmatically. It allows developers to automate the process of generating Word documents, making it easier to dynamically create reports, invoices, letters, and other types of documents within their applications.

Key Features of IronWord

1. C# Fill Word Template and Handling

IronWord enables the use of Word templates to define placeholders in a template document and replace them with actual data at runtime.

2. Text Manipulation

You can easily insert, replace, or delete text within a Word document.

3. Formatting

The library supports various formatting options, including font styles, sizes, colors, and paragraph alignment.

4. Tables and Images

IronWord allows you to insert and manipulate tables and images within your documents.

5. Compatibility

It works seamlessly with different versions of Microsoft Word, ensuring compatibility and ease of use.

Use Cases

Report Generation: Automatically generate detailed reports with dynamic data.
Invoice Creation: Create professional invoices by filling in customer and transaction details.
Contract Management: Automate the creation of contracts with personalized information.
Letters and Notices: Generate personalized letters and notices for clients or employees.

IronWord simplifies working with Word documents in .NET applications, making it a valuable tool for developers who want to automate document generation and management tasks.

Prerequisites

A quick reminder to make sure you have the following before we get started:

Visual Studio is installed on your machine.
The latest .NET Framework is installed.

Step 1: Create a new project in Microsoft Visual Studio.

Now, let us begin by creating a new Visual Studio project.

How to Generate a Word Document Using a Word Template in C#: Figure 1

Select the console application template on the screen below.

How to Generate a Word Document Using a Word Template in C#: Figure 2 - Select Console App

Provide the project name and location.

How to Generate a Word Document Using a Word Template in C#: Figure 3 - Provide name and location

Select the .NET Version, preferably the latest one with support, and click Create.

How to Generate a Word Document Using a Word Template in C#: Figure 4

Step 2: Install IronWord NuGet Package manager.

Install IronWord NuGet package from NuGet package manager as below in Visual Studio.

How to Generate a Word Document Using a Word Template in C#: Figure 5 - Search for IronWord from NuGet Package Manager

Alternatively, please install it using CLI directly using the command below.

> dotnet add package IronWord --version 2024.9.1

dotnet add package IronWord --version 2024.9.1

Step 3: Create a Word Template document.

Now, generate a Word template document with one or two pages to be used during the Word document generation process.

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}

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}

Text

Now, save the document above as Template.docx.

Step 4: Inserting data into a Word document and saving as a new file.

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

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

Explanation

The provided code demonstrates using the IronWord library to fill a Word document template with specific data. Here's a concise explanation:

License Setup: The code begins by setting the license key for IronWord to activate its functionality.
File Paths: It specifies the paths for the Word template (Template.docx) and the output file (FilledDocument.docx).
Create Document Instance: An instance of WordDocument is created using the template path reference.
Define Replacements: A dictionary is created where keys represent placeholders in the template, and values represent the data to insert.
Replace Placeholders: It iterates through the dictionary, replacing each placeholder in the document with the corresponding data.
Save Document: Finally, the updated document is saved to the specified output path.
Completion Message: A message is printed to confirm that the document has been successfully filled and saved.

Output

How to Generate a Word Document Using a Word Template in C#: Figure 7 - Word Document Output

Step 5: Add text effects to generated Word document.

IronWord also allows adding various text effects, as shown in the table below.

In the following example, we add text effects to the word "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

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

Explanation

The revised code illustrates using the IronWord library to fill out a Word document template, style text, and save the modified document. Here's a concise explanation:

License Setup: Sets the IronWord license key to enable functionality.
File Paths: Specifies the paths for the template (Template.docx) and the output file (glowEffect.docx).
Create Document Instance: Initializes a WordDocument instance using the provided template path.
Define Replacements: Creates a dictionary of placeholders and their corresponding replacement values.
Replace Placeholders: Iterates through the dictionary, replacing placeholders in the document with actual data.
Configure Text Style: Defines a text style with a glow effect, specifying color and radius.
Add Styled Text: Adds text with the configured style to the document.
Save Document: Saves the updated document with a new name (glowEffect.docx), reflecting the applied text style.
Console Output: A message is printed to confirm that the styled document has been saved.

Output

How to Generate a Word Document Using a Word Template in C#: Figure 8 - Example Word Output

IronWord Licensing

IronWord. Once the data is entered, the license is delivered to the email ID provided. This license needs to be placed at the beginning of the code, before using the IronWord library, as below.

License.LicenseKey = "your Key Here";

License.LicenseKey = "your Key Here";

License.LicenseKey = "your Key Here"

License.LicenseKey = "your Key Here"

Conclusion

IronWord offers several advantages for generating Word documents using templates. It simplifies document creation automation by allowing developers to programmatically fill out templates with specific data, reducing the need for manual input. This increases efficiency and accuracy, as the risk of human error is minimized. Additionally, IronWord helps maintain consistency across documents, ensuring that each generated file adheres to the same format and structure. Automating repetitive tasks saves time and resources, making it ideal for quickly producing large volumes of documents. IronWord enhances productivity and streamlines workflows in scenarios requiring frequent or complex document generation.

By following the steps outlined in this article and leveraging the provided example with IronWord, you can efficiently manage your document generation needs and streamline your workflow.

Curtis Chau

Chat with engineering team now

Technical Writer

Curtis Chau holds a Bachelor’s degree in Computer Science (Carleton University) and specializes in front-end development with expertise in Node.js, TypeScript, JavaScript, and React. Passionate about crafting intuitive and aesthetically pleasing user interfaces, Curtis enjoys working with modern frameworks and creating well-structured, visually appealing manuals.

...