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

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 pourquoiIronWord deIron Software est une bibliothèque .NET robuste conçue pour automatiser le processus de remplissage programmatique des modèles Word. Dans cet article, nous verrons comment utiliserIronWord l'objectif est de remplir un modèle de document Word et de fournir un exemple pratique pour illustrer le processus.

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

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

2. InstallerIronWord via le gestionnaire de paquets NuGet.

3. Créez un document Word Template.

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

5. Ajoutez des effets de texte au document Word généré.

Qu'est-ce qu'IronWord ?

IronWord est une bibliothèque .NET deIron Software cet outil est conçu pour faciliter la création, la manipulation et la gestion de documents Microsoft Word par programmation. 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. C&num ; Remplir le modèle Word et la manipulation

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

2. Manipulation de texte

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

3. Formatage

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 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 renseignant 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érer des lettres et des 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.

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

Indiquer le nom et la localisation du projet.

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

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

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

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

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

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

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 :

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 le fichier de sortie(``FilledDocument.docx``).3. Créer une instance de document : Une instance de \NWordDocument\Nest créée en utilisant la référence du chemin d'accès au modèle.

3. Définir les remplacements : Un dictionnaire est créé dans lequel 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 : Il parcourt le dictionnaire, remplaçant chaque espace réservé dans le document par les données correspondantes.

4. Sauvegarder le document : Enfin, le document mis à jour est enregistré dans le chemin de sortie spécifié à l'aide de la méthode save et en passant des paramètres.7. Message d'achèvement : 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

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 :

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 le fichier de sortie(glowEffect.docx).

3. Créer une instance de document : Initialise une instance de WordDocument en utilisant le chemin d'accès au modèle fourni.

4. Define Replacements : Crée un dictionnaire d'espaces réservés et de valeurs de remplacement correspondantes.

5. Replace Placeholders : Interroge 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 d'éclat, en spécifiant la couleur et le rayon.

7. Ajouter du texte stylé : Ajoute au document du texte avec le style configuré.

8. Sauvegarder le document : Enregistre le document mis à jour sous un nouveau nom(glowEffect.docx)la traduction doit être réalisée dans une langue étrangère, reflétant le style de texte appliqué.

9. Sortie de la console : La déclaration de sortie de la console précédente est commentée et l'opération d'enregistrement 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 l'utilisation de la commandeIronWord la traduction doit se faire à l'aide d'une bibliothèque en ligne, 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"

Conclusion

IronWord offre plusieurs avantages pour la création de 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é. En outre,IronWord l'équipe de traduction 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 l'outil de création de documents améliore la productivité et rationalise les flux de travail dans les scénarios nécessitant la génération de documents fréquents ou complexes.

En suivant les étapes décrites dans cet article et en exploitant l'exemple fourni avec le logicielIronWordgrâce à ces outils, vous pouvez gérer efficacement vos besoins en matière de génération de documents et rationaliser votre flux de travail.