UTILISATION D'IRONWORD

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

Name: IronWord
Brand: Iron Software
Availability: InStock

Regan Pun

octobre 24, 2024

Dans les applications modernes, il est essentiel de générer des documents Word à la volée à des fins diverses telles que la facturation, les factures, les lettres, etc. La fonction de document modèle de Microsoft Word offre un moyen puissant de garantir la cohérence et l'efficacité. Toutefois, la saisie manuelle de ces modèles peut prendre beaucoup de temps et être sujette à des erreurs. C'est là qu'intervient IronWord de Iron Software—une bibliothèque .NET robuste conçue pour automatiser le processus de remplissage de modèles Word de manière programmatique. Dans cet article, nous allons expliquer comment utiliser IronWord pour remplir un modèle de document Word et fournir un exemple pratique pour illustrer le processus.

Comment générer un document Word à l'aide d'un modèle Word dans C# ;

Créez un nouveau projet dans Microsoft Visual Studio.
Installez IronWord via le gestionnaire de packages NuGet.
Créez un document Word Template.
Insérer des données dans un document Word et les enregistrer dans un nouveau fichier.
Ajoutez des effets de texte au document Word généré.

Qu'est-ce qu'IronWord ?

IronWord est une bibliothèque .NET de Iron Software conçue pour faciliter la création, la manipulation et la gestion de documents Microsoft Word de manière programmatique. 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. Manipulation et Remplissage de Modèles Word avec C#

IronWord permet l'utilisation de 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 à 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 formatage, 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é

Elle fonctionne de manière transparente avec les différentes versions de Microsoft Word, garantissant ainsi la compatibilité et la facilité d'utilisation.

Cas d'utilisation

Génération de Rapports : Générer automatiquement des rapports détaillés avec des données dynamiques.
Création de Factures : Créez des factures professionnelles en remplissant les détails du client et de 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 avis personnalisés pour les clients ou les employés.
IronWord simplifie le travail avec les documents Word dans les applications .NET, ce qui en fait un outil précieux pour les développeurs qui souhaitent automatiser les tâches de génération et de gestion de documents.

Conditions préalables

Un petit rappel pour vous assurer que vous avez bien les éléments suivants avant que nous commencions :

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 par créer un nouveau projet Visual Studio.

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

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

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

Indiquer le nom et la localisation du projet.

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

Sélectionnez la version .NET, de préférence la plus récente avec prise en charge, et cliquez sur Créer.

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

Étape 2 : Installer le gestionnaire de paquets NuGet d'IronWord.

Installez le paquet NuGet d'IronWord à partir du gestionnaire de paquets NuGet comme indiqué ci-dessous dans Visual Studio.

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

Vous pouvez également l'installer directement à l'aide de la commande ci-dessous.

Comment générer un document Word à l'aide d'un modèle Word en C# : Figure 6 - Copiez la commande et collez-la dans l'application de la console 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

$vbLabelText $csharpLabel

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

Maintenant, générez un modèle de document Word avec une ou deux pages à utiliser pendant le processus de génération du document 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}

$vbLabelText $csharpLabel

Enregistrez maintenant le document ci-dessus sous Template.docx.

Étape 4 : Insérer des données dans un document Word et les enregistrer dans un nouveau fichier.

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

$vbLabelText $csharpLabel

Explication

Le code fourni démontre 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 :

Configuration de la Licence : Le code commence par définir la clé de licence pour IronWord afin d'activer sa fonctionnalité.
Chemins de fichiers : Il spécifie les chemins du modèle Word (Template.docx) et du fichier de sortie (FilledDocument.docx).3. Créer une instance de document : Une instance de WordDocument est créée en utilisant la référence du chemin du modèle.
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. Remplacer les espaces réservés : Il parcourt le dictionnaire, remplaçant chaque espace réservé dans le document par les données correspondantes.
Enregistrer le document : Enfin, le document mis à jour est enregistré au chemin de sortie spécifié avec la méthode d'enregistrement et les paramètres passés. Message de fin : Un message est imprimé 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 le montre le tableau ci-dessous.

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

$vbLabelText $csharpLabel

Explication

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

Configuration de la licence : Définit la clé de licence IronWord pour activer la fonctionnalité.
Chemins de fichiers : Spécifie les chemins du modèle (Template.docx) et du fichier de sortie (glowEffect.docx).
Créer une instance de document : Initialise une instance de WordDocument en utilisant le chemin de modèle fourni.
Définir les remplacements : Crée un dictionnaire de marqueurs de position et de leurs valeurs de remplacement correspondantes.
Remplacer les espaces réservés : Parcourt le dictionnaire, remplaçant les espaces réservés dans le document par des données réelles.
Configurer le style de texte : Définit un style de texte avec un effet de lueur, en spécifiant la couleur et le rayon.
Ajouter du texte stylisé : Ajoute du texte avec le style configuré au document.
Enregistrer le document : Enregistre le document mis à jour sous un nouveau nom (glowEffect.docx), reflétant le style de texte appliqué.
Sortie de la console : L'instruction de sortie de la console précédente est commentée, et l'opération de sauvegarde a été mise à jour pour refléter le nouveau nom du document.
Ce code démontre les fonctionnalités d'automatisation et de personnalisation des documents d'IronWord, notamment le remplacement de texte et le stylisme.
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"

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

$vbLabelText $csharpLabel

Conclusion

IronWord offre plusieurs avantages pour générer des documents Word à l'aide de modèles. Il simplifie l'automatisation de la création de documents en permettant aux développeurs de remplir par programme des modèles avec des données spécifiques, réduisant ainsi la nécessité d'une saisie manuelle. L'efficacité et la précision s'en trouvent accrues, car le risque d'erreur humaine est minimisé. De plus, IronWord aide à 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 d'économiser des ressources, ce qui est idéal pour produire rapidement de gros volumes de documents. IronWord améliore la productivité et simplifie les flux de travail dans des scénarios nécessitant une génération fréquente ou complexe de documents.

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

Regan Pun

Discutez avec l'équipe d'ingénierie maintenant

Ingénieur logiciel

Regan est diplômé de l'université de Reading, où il a obtenu une licence en ingénierie électronique. Avant de rejoindre Iron Software, il s'était concentré sur une seule tâche. Ce qu'il apprécie le plus chez Iron Software, c'est la diversité des tâches qu'il peut accomplir, qu'il s'agisse d'apporter une valeur ajoutée aux ventes, à l'assistance technique, au développement de produits ou à la commercialisation. Il aime comprendre comment les développeurs utilisent la bibliothèque d'Iron Software et utiliser ces connaissances pour améliorer continuellement la documentation et développer les produits.

< PRÉCÉDENT
Comment aligner le texte dans Word en utilisant C#

SUIVANT >
Comment ajouter un filigrane à un fichier Word en C#