Dans les applications modernes, il est essentiel de générer rapidement des documents Word à des fins diverses telles que la facturation, les factures, les lettres, etc. La fonctionnalité de modèles de documents de Microsoft Word offre un moyen efficace de garantir la cohérence et l'efficacité. Cependant, le remplissage manuel de ces modèles peut s'avérer long et source d'erreurs. C'est là qu'intervient IronWord d' Iron Software : une bibliothèque .NET robuste conçue pour automatiser le processus de remplissage programmatique des modèles Word. Dans cet article, nous allons vous montrer comment utiliser IronWord pour remplir un modèle de document Word et vous fournir un exemple pratique pour illustrer le processus.

Comment générer un document Word à partir d'un modèle Word en C#

1. Créez un nouveau projet dans Microsoft Visual Studio.
2. Installez IronWord via le gestionnaire de packages NuGet.
3. Créez un document modèle Word.
4. Insérez les données dans un document Word et enregistrez-le comme un nouveau fichier.
5. Ajouter des effets de texte au document Word généré.

Qu'est-ce qu'IronWord ?

IronWord est une bibliothèque .NET d' Iron Software conçue pour faciliter la création, la manipulation et la gestion par programmation de documents Microsoft Word. Il permet aux développeurs d'automatiser le processus de génération de documents Word, facilitant ainsi la création dynamique de rapports, de factures, de lettres et d'autres types de documents au sein de leurs applications.

Principales caractéristiques d'IronWord

1. Remplissage et gestion des modèles Word en C#

IronWord permet d'utiliser des modèles Word pour définir des espaces réservés dans un document modèle et les remplacer par des données réelles lors de l'exécution.

2. Manipulation de texte

Vous pouvez facilement insérer, remplacer ou supprimer du texte dans un document Word.

3. Mise en forme

La bibliothèque prend en charge diverses options de mise en forme, notamment les styles de police, les tailles, les couleurs et l'alignement des paragraphes.

4. Tableaux et images

IronWord vous permet d'insérer et de manipuler des tableaux et des images dans vos documents.

5. Compatibilité

Il fonctionne parfaitement avec différentes versions de Microsoft Word, garantissant compatibilité et facilité d'utilisation.

Cas d'utilisation

• Génération de rapports : Générez automatiquement des rapports détaillés avec des données dynamiques.
• Création de factures : Créez des factures Professional en renseignant les informations relatives au client et à la transaction.
• Gestion des contrats : Automatisez la création de contrats avec des informations personnalisées.
• Lettres et avis : Générez des lettres et des avis personnalisés pour vos clients ou employés.

IronWord simplifie la manipulation des documents Word dans les applications .NET, ce qui en fait un outil précieux pour les développeurs souhaitant automatiser les tâches de génération et de gestion de documents.

Prérequis

Petit rappel pour vérifier que vous avez bien le matériel suivant avant de commencer :

• Visual Studio est installé sur votre machine.
• La dernière version de .NET Framework est installée.

Étape 1 : Créez un nouveau projet dans Microsoft Visual Studio.

Commençons maintenant par créer un nouveau projet Visual Studio.

Sélectionnez le modèle d'application console sur l'écran ci-dessous.

Fournissez le nom et l'emplacement du projet.

Sélectionnez la version .NET, de préférence la plus récente compatible, puis cliquez sur Créer.

Étape 2 : Installez le gestionnaire de packages NuGet IronWord.

Installez le package NuGet IronWord à partir du gestionnaire de packages NuGet comme indiqué ci-dessous dans Visual Studio.

Vous pouvez également l'installer directement via l'interface de ligne de commande (CLI) en utilisant la commande ci-dessous.

dotnet add package IronWord --version 2024.9.1

Étape 3 : Créer un document modèle Word.

Générez maintenant un modèle de document Word d'une ou deux pages qui sera utilisé lors du processus de génération du document 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}

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}

Maintenant, enregistrez le document ci-dessus sous le nom Template.docx.

Étape 4 : Insertion des données dans un document Word et enregistrement en tant que nouveau fichier.

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

Explication

Le code fourni illustre l'utilisation de la bibliothèque IronWord pour remplir un modèle de document Word avec des données spécifiques. Voici une explication concise :

1. Configuration de la licence : Le code commence par définir la clé de licence d' IronWord afin d'activer ses fonctionnalités.
2. Chemins d'accès aux fichiers : Il spécifie les chemins d'accès au modèle Word (Template.docx) et au fichier de sortie (FilledDocument.docx).
3. Créer une instance de document : Une instance de WordDocument est créée à l'aide de la référence de chemin du modèle.
4. Définir les remplacements : un dictionnaire est créé où les clés représentent les espaces réservés dans le modèle et les valeurs représentent les données à insérer.
5. Remplacer les espaces réservés : Cette fonction parcourt le dictionnaire et remplace chaque espace réservé du document par les données correspondantes.
6. Enregistrement du document : Enfin, le document mis à jour est enregistré dans le chemin de sortie spécifié.
7. Message de confirmation : Un message s'affiche pour confirmer que le document a été rempli et enregistré avec succès.

Sortie

Étape 5 : Ajouter des effets de texte au document Word généré.

IronWord permet également d'ajouter divers effets de texte, comme indiqué dans le tableau ci-dessous.

Dans l'exemple suivant, nous ajoutons des effets de texte au mot " 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

Explication

Le code révisé illustre l'utilisation de la bibliothèque IronWord pour remplir un modèle de document Word, mettre en forme le texte et enregistrer le document modifié. Voici une explication concise :

1. Configuration de la licence : Définit la clé de licence IronWord pour activer les fonctionnalités.
2. Chemins d'accès aux fichiers : Spécifie les chemins d'accès au modèle (Template.docx) et au fichier de sortie (glowEffect.docx).
3. Créer une instance de document : Initialise une instance WordDocument en utilisant le chemin de modèle fourni.
4. Définir les remplacements : Crée un dictionnaire d'espaces réservés et de leurs valeurs de remplacement correspondantes.
5. Remplacer les espaces réservés : parcourt le dictionnaire en remplaçant les espaces réservés dans le document par des données réelles.
6. Configurer le style de texte : Définit un style de texte avec un effet de halo, en spécifiant la couleur et le rayon.
7. Ajouter du texte stylisé : Ajoute au document du texte avec le style configuré.
8. Enregistrer le document : Enregistre le document mis à jour sous un nouveau nom (glowEffect.docx), reflétant le style de texte appliqué.
9. Sortie console : Un message s'affiche pour confirmer que le document mis en forme a été enregistré.

Sortie

Licences IronWord

IronWord . Une fois les données saisies, la licence est envoyée à l'adresse électronique fournie. Cette licence doit être placée au début du code, avant d'utiliser la bibliothèque IronWord , comme ci-dessous.

License.LicenseKey = "your Key Here";

License.LicenseKey = "your Key Here";

License.LicenseKey = "your Key Here"

License.LicenseKey = "your Key Here"

Conclusion

IronWord offre plusieurs avantages pour la génération de documents Word à partir de modèles. Il simplifie l'automatisation de la création de documents en permettant aux développeurs de remplir par programmation des modèles avec des données spécifiques, réduisant ainsi le besoin de saisie manuelle. Cela accroît l'efficacité et la précision, car le risque d'erreur humaine est minimisé. De plus, IronWord contribue à maintenir la cohérence entre les documents, en veillant à ce que chaque fichier généré respecte le même format et la même structure. L'automatisation des tâches répétitives permet de gagner du temps et des ressources, ce qui la rend idéale pour produire rapidement de grands volumes de documents. IronWord améliore la productivité et rationalise les flux de travail dans les scénarios nécessitant une génération de documents fréquente ou complexe.

En suivant les étapes décrites dans cet article et en tirant parti de l'exemple fourni avec IronWord , vous pouvez gérer efficacement vos besoins en matière de génération de documents et rationaliser votre flux de travail.