Icône de message
Passer au contenu du pied de page
  1. IronWord
  2. Blog d'IronWord
  3. Utilisation d'IronWord
  4. C# Remplir modèle Word
UTILISATION D'IRONWORD

Comment générer un document Word en utilisant un modèle Word en C#

Jordi Bardia
Jordi Bardia
Mis à jour:

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 professionnelles 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.

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

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

Comment générer un document Word à partir d'un modèle Word en C# : Figure 2 - Sélectionner une application console

Fournissez le nom et l'emplacement du projet.

Comment générer un document Word à partir d'un modèle Word en C# : Figure 3 - Indiquez le nom et l'emplacement

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

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

É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.

Comment générer un document Word à partir d'un modèle Word en C# : Figure 5 - Recherche d'IronWord dans le gestionnaire de packages NuGet

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
dotnet add package IronWord --version 2024.9.1
SHELL

É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}

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
$vbLabelText   $csharpLabel

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 pour 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.

Output

Comment générer un document Word à partir d'un modèle Word en C# : Figure 7 - Document Word généré

É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
$vbLabelText   $csharpLabel

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 à l'aide du 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 est imprimé pour confirmer que le document stylisé a été enregistré.

Output

Comment générer un document Word à partir d'un modèle Word en C# : Figure 8 - Exemple de document Word généré

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"
$vbLabelText   $csharpLabel

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.

Questions Fréquemment Posées

Comment puis-je remplir un modèle de document Word en utilisant C# ?

Vous pouvez remplir un modèle de document Word en utilisant C# en exploitant IronWord. Tout d'abord, configurez votre projet dans Visual Studio et installez le package IronWord via NuGet. Créez un modèle Word et utilisez IronWord pour insérer des données, puis enregistrez le modèle rempli comme un nouveau document.

Quels sont les avantages d'utiliser une bibliothèque .NET pour l'automatisation des modèles Word ?

Utiliser une bibliothèque .NET comme IronWord pour l'automatisation des modèles Word réduit les saisies manuelles, minimise les erreurs et assure la cohérence dans la création de documents. Elle permet de gérer efficacement des tâches telles que la facturation, l'émission de factures et la rédaction de lettres.

Puis-je ajouter des effets de texte lors du remplissage d'un modèle Word de façon programmée ?

Oui, avec IronWord, vous pouvez ajouter des effets de texte tels que des lueurs ou des ombres au texte de vos documents Word lors du remplissage de modèles de manière programmée.

Quelles sont les étapes à suivre pour configurer IronWord dans un projet Visual Studio ?

Pour configurer IronWord dans un projet Visual Studio, commencez par installer le package NuGet IronWord, créez votre modèle Word, puis utilisez les méthodes d'IronWord pour remplir et enregistrer le document de manière programmée.

Comment IronWord assure-t-il la cohérence dans la génération de documents ?

IronWord assure la cohérence en permettant aux développeurs d'utiliser des modèles Word qui maintiennent le même format et la même mise en page sur plusieurs documents, réduisant le risque d'erreurs humaines.

Quelles sont quelques applications pratiques de l'automatisation de la génération de documents Word ?

L'automatisation de la génération de documents Word avec IronWord peut être appliquée dans divers scénarios, y compris la génération de rapports, la création de factures, la gestion de contrats et la rédaction de lettres personnalisées.

Est-il possible de gérer différentes versions de Microsoft Word en utilisant IronWord ?

Oui, IronWord est compatible avec plusieurs versions de Microsoft Word, permettant une gestion transparente des documents dans différents environnements.

Qu'est-ce qui est nécessaire pour commencer à utiliser IronWord pour la gestion de documents Word ?

Pour commencer à utiliser IronWord, assurez-vous d'avoir Visual Studio installé, ainsi que le dernier .NET Framework. Ensuite, ajoutez IronWord à votre projet via le gestionnaire de packages NuGet.

Jordi Bardia
Jordi Bardia
  Discutez maintenant avec l'équipe d'ingénierie
Ingénieur logiciel
Jordi est le plus compétent en Python, C# et C++, et lorsqu'il ne met pas à profit ses compétences chez Iron Software, il programme des jeux. Partageant les responsabilités des tests de produit, du développement de produit et de la recherche, Jordi apporte une immense valeur à l'amé...
Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit