Icône de message
Passer au contenu du pied de page
  1. IronWord
  2. Blog d'IronWord
  3. Utilisation d'IronWord
  4. ASP .NET Core Importer & Exporter un fichier Word
UTILISATION D'IRONWORD

ASP .NET Core Importer & Exporter un fichier Word

Jordi Bardia
Jordi Bardia
Mis à jour:

Ce guide explique comment importer des documents Word existants, afficher leur contenu et créer des documents à partir de zéro à l'aide de la bibliothèque IronWord . À la fin de ce tutoriel, vous aurez créé une application web ASP.NET Core capable de :

  1. Télécharger et lire des documents Word
  2. Afficher le contenu de ces documents dans une zone de texte
  3. Exportez le fichier Docx

Ce projet est idéal pour les développeurs qui ont besoin d'intégrer le traitement de documents Word dans leurs applications web, que ce soit pour des systèmes de gestion de documents, des générateurs de rapports ou tout autre scénario impliquant des fichiers Microsoft Word.

Prérequis

Pour suivre ce tutoriel, vous devez avoir :

  • Connaissances de base en C# et ASP.NET Core
  • Visual Studio 2019 ou version ultérieure installé (vous pouvez également utiliser Visual Studio Code avec l'extension C#).
  • Kit de développement logiciel .NET Core 3.1 ou version ultérieure

Ne vous inquiétez pas si vous n'êtes pas un expert dans ces technologies – nous vous guiderons à chaque étape du processus !

Qu'est-ce qu'IronWord ?

IronWord est une bibliothèque .NET qui permet aux développeurs de lire, manipuler et créer par programmation des documents Microsoft Word. Elle offre une API de haut niveau qui simplifie le travail avec les fichiers Word, ce qui en fait un excellent choix pour notre projet.

IronWord propose notamment les fonctionnalités suivantes :

  • Lecture et écriture de différents formats de texte (DOCX, DOC, etc.)
  • Manipulation du contenu et de la structure des documents
  • Mise en forme du texte et des paragraphes
  • Utilisation de tableaux, d'images et d'autres éléments de document
  • Processus de publipostage pour les documents
  • Convertissez facilement un document Word en document PDF, ce qui vous permet de transformer vos documents Word finaux en fichiers PDF faciles à partager.

Maintenant que nous avons une vue d'ensemble de ce que nous allons construire et des outils que nous allons utiliser, passons à la mise en place de notre projet !

2. Mise en place du projet

Dans cette section, nous allons créer un nouveau projet ASP.NET Core et installer les packages nécessaires pour travailler avec IronWord.

2.1 Création d'un nouveau projet ASP.NET Core

  1. Ouvrez Visual Studio 2019 ou une version ultérieure.
  2. Cliquez sur " Créer un nouveau projet ".
  3. Recherchez " Application Web ASP.NET Core " et sélectionnez-la.
  4. Cliquez sur " Suivant ".
  5. Nommez votre projet " WordDocumentProcessor " (ou tout autre nom de votre choix).
  6. Sélectionnez le framework .NET et un emplacement pour votre projet, puis cliquez sur " Créer ".

2.2 Installation du package NuGet IronWord

Maintenant que notre projet est configuré, ajoutons la bibliothèque IronWord :

  1. Faites un clic droit sur votre projet dans l'Explorateur de Solution.
  2. Sélectionnez " Gérer les packages NuGet ".
  3. Dans l'onglet " Parcourir ", recherchez " IronWord ".
  4. Recherchez le package officiel IronWord.
  5. Cliquez sur " Installer " pour l'ajouter à votre projet.

2.3 Mise à jour du contrôleur et de la vue existants

Mettons à jour notre structure existante pour y intégrer la fonctionnalité de traitement des documents :

  1. Nous utiliserons le fichier HomeController.cs existant dans le dossier Controllers pour notre logique de traitement des documents.
  2. Nous mettrons à jour la vue Index.cshtml existante dans le dossier Views/Home pour y inclure la fonctionnalité de téléchargement et d'affichage de documents.

Maintenant que notre projet est configuré et que le package IronWord est installé, nous sommes prêts à commencer à implémenter la fonctionnalité d'importation et d'exportation de documents. Nous allons ajouter de nouvelles méthodes à notre HomeController et modifier la vue Index pour gérer ces fonctionnalités. Dans la section suivante, nous nous concentrerons sur l'importation de documents Word et l'affichage de leur contenu, en utilisant notre structure de contrôleur et de vue existante.

3. Importation de documents Word

Dans cette section, nous verrons comment implémenter une fonctionnalité d'importation et de traitement de documents Word dans une application ASP.NET MVC. Nous aborderons à la fois la conception de l'interface utilisateur et la logique du contrôleur back-end.

3.1 Conception de l'interface utilisateur

L'interface utilisateur pour l'importation de documents Word est conçue pour être intuitive et visuellement attrayante. Analysons les principaux composants de l'interface utilisateur :

3.1.1 Zone de téléchargement

La zone de téléchargement est l'élément central de l'interface, invitant les utilisateurs à sélectionner et à télécharger leurs documents Word. Voici comment il est structuré :

<div class="upload-area">
    <svg class="file-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
        <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path>
        <polyline points="14 2 14 8 20 8"></polyline>
        <line x1="16" y1="13" x2="8" y2="13"></line>
        <line x1="16" y1="17" x2="8" y2="17"></line>
        <polyline points="10 9 9 9 8 9"></polyline>
    </svg>
    <p>Choose a Word document</p>
    <label for="fileInput" class="choose-file">Choose File</label>
    <p class="file-info">.DOC or .DOCX (MAX. 10MB)</p>
    <button id="uploadBtn" class="upload-button">Upload and Process</button>
</div>
<div class="upload-area">
    <svg class="file-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
        <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path>
        <polyline points="14 2 14 8 20 8"></polyline>
        <line x1="16" y1="13" x2="8" y2="13"></line>
        <line x1="16" y1="17" x2="8" y2="17"></line>
        <polyline points="10 9 9 9 8 9"></polyline>
    </svg>
    <p>Choose a Word document</p>
    <label for="fileInput" class="choose-file">Choose File</label>
    <p class="file-info">.DOC or .DOCX (MAX. 10MB)</p>
    <button id="uploadBtn" class="upload-button">Upload and Process</button>
</div>
HTML

Ce code crée une zone de téléchargement visuellement attrayante avec une icône de fichier, un champ de saisie de fichier caché et une étiquette stylisée servant de bouton de sélection de fichier. Il comprend également des informations sur les types de fichiers acceptés et un bouton pour lancer le téléchargement et le traitement.

3.1.2 Zone d'affichage du contenu

Après traitement du document, son contenu est affiché dans une zone dédiée :

<div class="content-wrapper">
    <h2>Document Content:</h2>
    <div id="documentContent" class="content-area">
        No content to display.
    </div>
</div>
<div class="content-wrapper">
    <h2>Document Content:</h2>
    <div id="documentContent" class="content-area">
        No content to display.
    </div>
</div>
HTML

Cette section offre une zone de défilement pour afficher le contenu du document traité.

3.2 Implémentation du contrôleur

Le HomeController gère la logique côté serveur pour l'importation et le traitement des documents Word. Examinons les principales méthodes :

3.2.1 Méthode UploadAndProcess

Cette méthode est chargée de gérer le téléchargement et le traitement des fichiers :

[HttpPost]
public IActionResult UploadAndProcess(IFormFile file)
{
    if (file == null || file.Length == 0)
    {
        return Json(new { success = false, message = "No file uploaded." });
    }
    var fileExtension = Path.GetExtension(file.FileName).ToLowerInvariant();
    if (fileExtension != ".doc" && fileExtension != ".docx")
    {
        return Json(new { success = false, message = "Invalid file type. Please upload a .doc or .docx file." });
    }
    try
    {
        var tempFilePath = Path.GetTempFileName();
        using (var stream = new FileStream(tempFilePath, FileMode.Create))
        {
            file.CopyTo(stream);
        }
        StringBuilder contentBuilder = new StringBuilder();
        WordDocument doc = new WordDocument(tempFilePath);
        foreach (Paragraph paragraph in doc.Paragraphs)
        {
            foreach (Text textRun in paragraph.Texts)
            {
                contentBuilder.AppendLine(textRun.Text);
            }
            contentBuilder.AppendLine(); // Add an extra line between paragraphs
        }
        System.IO.File.Delete(tempFilePath); // Clean up the temporary file
        return Json(new { success = true, content = FormatContentAsHtml(contentBuilder.ToString()) });
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error processing document");
        return Json(new { success = false, message = "An error occurred while processing the document." });
    }
}
[HttpPost]
public IActionResult UploadAndProcess(IFormFile file)
{
    if (file == null || file.Length == 0)
    {
        return Json(new { success = false, message = "No file uploaded." });
    }
    var fileExtension = Path.GetExtension(file.FileName).ToLowerInvariant();
    if (fileExtension != ".doc" && fileExtension != ".docx")
    {
        return Json(new { success = false, message = "Invalid file type. Please upload a .doc or .docx file." });
    }
    try
    {
        var tempFilePath = Path.GetTempFileName();
        using (var stream = new FileStream(tempFilePath, FileMode.Create))
        {
            file.CopyTo(stream);
        }
        StringBuilder contentBuilder = new StringBuilder();
        WordDocument doc = new WordDocument(tempFilePath);
        foreach (Paragraph paragraph in doc.Paragraphs)
        {
            foreach (Text textRun in paragraph.Texts)
            {
                contentBuilder.AppendLine(textRun.Text);
            }
            contentBuilder.AppendLine(); // Add an extra line between paragraphs
        }
        System.IO.File.Delete(tempFilePath); // Clean up the temporary file
        return Json(new { success = true, content = FormatContentAsHtml(contentBuilder.ToString()) });
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error processing document");
        return Json(new { success = false, message = "An error occurred while processing the document." });
    }
}
<HttpPost>
Public Function UploadAndProcess(ByVal file As IFormFile) As IActionResult
	If file Is Nothing OrElse file.Length = 0 Then
		Return Json(New With {
			Key .success = False,
			Key .message = "No file uploaded."
		})
	End If
	Dim fileExtension = Path.GetExtension(file.FileName).ToLowerInvariant()
	If fileExtension <> ".doc" AndAlso fileExtension <> ".docx" Then
		Return Json(New With {
			Key .success = False,
			Key .message = "Invalid file type. Please upload a .doc or .docx file."
		})
	End If
	Try
		Dim tempFilePath = Path.GetTempFileName()
		Using stream = New FileStream(tempFilePath, FileMode.Create)
			file.CopyTo(stream)
		End Using
		Dim contentBuilder As New StringBuilder()
		Dim doc As New WordDocument(tempFilePath)
		For Each paragraph As Paragraph In doc.Paragraphs
			For Each textRun As Text In paragraph.Texts
				contentBuilder.AppendLine(textRun.Text)
			Next textRun
			contentBuilder.AppendLine() ' Add an extra line between paragraphs
		Next paragraph
		System.IO.File.Delete(tempFilePath) ' Clean up the temporary file
		Return Json(New With {
			Key .success = True,
			Key .content = FormatContentAsHtml(contentBuilder.ToString())
		})
	Catch ex As Exception
		_logger.LogError(ex, "Error processing document")
		Return Json(New With {
			Key .success = False,
			Key .message = "An error occurred while processing the document."
		})
	End Try
End Function
$vbLabelText   $csharpLabel

Cette méthode effectue les tâches suivantes :

  1. Valide le fichier téléchargé, en s'assurant qu'il est au format de fichier correct (DOC ou DOCX).
  2. Traite le document à l'aide de la bibliothèque IronWord.
  3. Renvoie le contenu formaté au format JSON.

3.2.2 Méthode FormatContentAsHtml

Cette méthode privée formate le contenu extrait en HTML :

private string FormatContentAsHtml(string content)
{
    var lines = content.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
    var htmlBuilder = new StringBuilder();
    htmlBuilder.Append("<div class='document-content'>");
    foreach (var line in lines)
    {
        if (string.IsNullOrWhiteSpace(line))
        {
            htmlBuilder.Append("<p> </p>");
        }
        else
        {
            htmlBuilder.Append($"<p>{HttpUtility.HtmlEncode(line)}</p>");
        }
    }
    htmlBuilder.Append("</div>");
    return htmlBuilder.ToString();
}
private string FormatContentAsHtml(string content)
{
    var lines = content.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
    var htmlBuilder = new StringBuilder();
    htmlBuilder.Append("<div class='document-content'>");
    foreach (var line in lines)
    {
        if (string.IsNullOrWhiteSpace(line))
        {
            htmlBuilder.Append("<p> </p>");
        }
        else
        {
            htmlBuilder.Append($"<p>{HttpUtility.HtmlEncode(line)}</p>");
        }
    }
    htmlBuilder.Append("</div>");
    return htmlBuilder.ToString();
}
Private Function FormatContentAsHtml(ByVal content As String) As String
	Dim lines = content.Split( { Environment.NewLine }, StringSplitOptions.None)
	Dim htmlBuilder = New StringBuilder()
	htmlBuilder.Append("<div class='document-content'>")
	For Each line In lines
		If String.IsNullOrWhiteSpace(line) Then
			htmlBuilder.Append("<p> </p>")
		Else
			htmlBuilder.Append($"<p>{HttpUtility.HtmlEncode(line)}</p>")
		End If
	Next line
	htmlBuilder.Append("</div>")
	Return htmlBuilder.ToString()
End Function
$vbLabelText   $csharpLabel

Cette méthode garantit que le contenu du document est correctement formaté en HTML, chaque ligne étant encadrée par des balises de paragraphe et les lignes vides étant préservées.

3.3 JavaScript côté client

Pour gérer le téléchargement des fichiers et afficher le contenu traité, nous utilisons JavaScript :

uploadBtn.addEventListener('click', () => {
    const file = fileInput.files[0];
    if (!file) {
        alert('Please select a file first.');
        return;
    }
    const formData = new FormData();
    formData.append('file', file);
    uploadBtn.disabled = true;
    uploadBtn.textContent = 'Processing...';
    documentContent.innerHTML = 'Processing document...';
    fetch('/Home/UploadAndProcess', {
        method: 'POST',
        body: formData
    })
    .then(response => response.json())
    .then(data => {
        if (data.success) {
            documentContent.innerHTML = data.content;
        } else {
            documentContent.innerHTML = `<p>Error: ${data.message}</p>`;
        }
    })
    .catch(error => {
        console.error('Error:', error);
        documentContent.innerHTML = '<p>An error occurred while processing the document.</p>';
    })
    .finally(() => {
        uploadBtn.disabled = false;
        uploadBtn.textContent = 'Upload and Process';
    });
});
uploadBtn.addEventListener('click', () => {
    const file = fileInput.files[0];
    if (!file) {
        alert('Please select a file first.');
        return;
    }
    const formData = new FormData();
    formData.append('file', file);
    uploadBtn.disabled = true;
    uploadBtn.textContent = 'Processing...';
    documentContent.innerHTML = 'Processing document...';
    fetch('/Home/UploadAndProcess', {
        method: 'POST',
        body: formData
    })
    .then(response => response.json())
    .then(data => {
        if (data.success) {
            documentContent.innerHTML = data.content;
        } else {
            documentContent.innerHTML = `<p>Error: ${data.message}</p>`;
        }
    })
    .catch(error => {
        console.error('Error:', error);
        documentContent.innerHTML = '<p>An error occurred while processing the document.</p>';
    })
    .finally(() => {
        uploadBtn.disabled = false;
        uploadBtn.textContent = 'Upload and Process';
    });
});
JAVASCRIPT

Ce code JavaScript gère le processus de téléchargement de fichiers, envoie le fichier au serveur pour traitement et met à jour l'interface utilisateur avec le contenu traité ou les messages d'erreur.

3.4 Style de l'interface utilisateur

L'application utilise du CSS personnalisé pour créer une interface attrayante et conviviale.

<style>
    body {
        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        background-color: #f7f7f7;
        color: #333;
    }
    .container {
        max-width: 800px;
        margin: 0 auto;
        padding: 2rem;
        padding-top: 0.5rem;
    }
    h1 {
        font-weight: 300;
        color: #2c3e50;
        text-align: center;
        margin-bottom: 1rem;
    }
    .lead {
        text-align: center;
        color: #7f8c8d;
        margin-bottom: 2rem;
    }
    .upload-area {
        background-color: #ffffff;
        border-radius: 8px;
        box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
        padding: 2rem;
        text-align: center;
        margin-bottom: 2rem;
        transition: all 0.3s ease;
    }
    .upload-area:hover {
        box-shadow: 0 4px 20px rgba(0, 0, 0, 0.15);
    }
    .file-icon {
        width: 64px;
        height: 64px;
        margin-bottom: 1rem;
        color: #3498db;
    }
    .choose-file {
        background-color: #ecf0f1;
        color: #2c3e50;
        border: none;
        padding: 0.5rem 1rem;
        border-radius: 4px;
        cursor: pointer;
        transition: background-color 0.3s ease;
    }
    .choose-file:hover {
        background-color: #d5dbdb;
    }
    .file-info {
        font-size: 0.9em;
        color: #95a5a6;
        margin-top: 0.5rem;
    }
    .upload-button {
        background-color: #3498db;
        color: white;
        border: none;
        padding: 0.75rem 1.5rem;
        border-radius: 4px;
        cursor: pointer;
        transition: background-color 0.3s ease;
        margin-top: 1rem;
    }
    .upload-button:hover {
        background-color: #2980b9;
    }
    .content-wrapper {
        background-color: #ffffff;
        border-radius: 8px;
        box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
        padding: 1rem;
        margin-top: 2rem;
    }
    .content-area {
        max-height: 300px;
        overflow-y: auto;
        padding: 1rem;
        background-color: #f9f9f9;
        border-radius: 4px;
        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        font-size: 14px;
        line-height: 1.6;
    }
    .content-area::-webkit-scrollbar {
        width: 8px;
    }
    .content-area::-webkit-scrollbar-track {
        background: #f1f1f1;
        border-radius: 4px;
    }
    .content-area::-webkit-scrollbar-thumb {
        background: #bdc3c7;
        border-radius: 4px;
    }
    .content-area::-webkit-scrollbar-thumb:hover {
        background: #95a5a6;
    }
    .document-content p {
        margin: 0 0 10px 0;
    }
</style>

Ce CSS crée un aspect épuré et moderne avec une palette de couleurs claires. La zone de téléchargement présente un fond blanc avec de subtils effets d'ombre, tandis que la zone de contenu possède un design défilable avec un fond gris clair. L'utilisation des propriétés border-radius et box-shadow ajoute de la profondeur et un intérêt visuel aux éléments de l'interface.

4. Exportation de documents Word

Alors que nous continuons d'améliorer notre traitement de documents Word, ajoutons la possibilité d'exporter des documents. Cette fonctionnalité permettra aux utilisateurs de générer un nouveau document Word à partir de notre application.

4.1 Mise à jour de l'interface utilisateur

Tout d'abord, nous ajouterons une option " Exporter " à notre barre de navigation. Ouvrez le fichier _Layout.cshtml dans le dossier Views/Shared et localisez le

    élément. Ajoutons un nouvel élément à notre liste pour notre fonction d'exportation :

    <li class="nav-item">
    <a class="nav-link" id="exportLink" href="#" onclick="exportDocument(); return false;"><i class="fas fa-file-export"></i> Export</a>
</li>
    <li class="nav-item">
    <a class="nav-link" id="exportLink" href="#" onclick="exportDocument(); return false;"><i class="fas fa-file-export"></i> Export</a>
</li>
    HTML

    Nous utilisons Font Awesome pour l'icône, assurez-vous donc que le lien CSS figure bien dans notre section. Ce code ajoute un lien " Exporter " à la barre de navigation. Elle utilise Font Awesome pour l'icône et appelle la fonction exportDocument() lorsqu'on clique dessus. L' attribut href="#" et la valeur de retour false empêchent le comportement par défaut du lien.

4.2 Implémentation de la logique d'exportation côté client

Ajoutons maintenant la fonction JavaScript qui gérera le processus d'exportation. Tout en bas de notre fichier _Layout.cshtml , juste avant la balise de fermeture balise, nous ajouterons le script suivant :

<script>
function exportDocument() {
    $.ajax({
        url: '/Home/ExportWordDocument',
        type: 'POST',
        success: function (response) {
            if (response.success) {
                var fileName = prompt("Enter a name for the document (without extension):", "ExportedDocument");
                if (fileName === null) {
                    return;
                }
                fileName = (fileName.trim() || "ExportedDocument").replace(/\.[^/.]+$/, "") + ".docx";
                var a = document.createElement('a');
                a.style.display = 'none';
                a.href = '/Home/DownloadFile?tempFilePath=' + encodeURIComponent(response.tempFilePath) + '&userFileName=' + encodeURIComponent(fileName);
                document.body.appendChild(a);
                a.click();
                document.body.removeChild(a);
            } else {
                alert('Failed to export document: ' + response.message);
            }
        },
        error: function () {
            alert('An error occurred while exporting the document.');
        }
    });
}
</script>
<script>
function exportDocument() {
    $.ajax({
        url: '/Home/ExportWordDocument',
        type: 'POST',
        success: function (response) {
            if (response.success) {
                var fileName = prompt("Enter a name for the document (without extension):", "ExportedDocument");
                if (fileName === null) {
                    return;
                }
                fileName = (fileName.trim() || "ExportedDocument").replace(/\.[^/.]+$/, "") + ".docx";
                var a = document.createElement('a');
                a.style.display = 'none';
                a.href = '/Home/DownloadFile?tempFilePath=' + encodeURIComponent(response.tempFilePath) + '&userFileName=' + encodeURIComponent(fileName);
                document.body.appendChild(a);
                a.click();
                document.body.removeChild(a);
            } else {
                alert('Failed to export document: ' + response.message);
            }
        },
        error: function () {
            alert('An error occurred while exporting the document.');
        }
    });
}
</script>
HTML

Cette fonction JavaScript envoie une requête AJAX POST au serveur pour créer un document Word. En cas de succès, le programme invite l'utilisateur à saisir un nom de fichier, puis crée un lien temporaire pour le télécharger. Ce lien est automatiquement cliqué, puis supprimé du DOM. En cas d'erreur à n'importe quelle étape, une alerte est affichée à l'utilisateur.

4.3 Ajout de la fonctionnalité d'exportation côté serveur

Passons maintenant à la mise en œuvre de la logique côté serveur. Ouvrez le fichier HomeController.cs dans le dossier Controllers. Nous ajouterons deux nouvelles méthodes pour gérer le processus d'exportation.

Commençons par ajouter la méthode permettant de créer le document Word :

[HttpPost]
public IActionResult ExportWordDocument()
{
    try
    {
        WordDocument doc = new WordDocument();
        doc.AddText("Test Word");
        string tempFileName = $"TempDoc_{Guid.NewGuid()}.docx";
        string tempFilePath = Path.Combine(_environment.WebRootPath, "TempFiles", tempFileName);
        Directory.CreateDirectory(Path.GetDirectoryName(tempFilePath));
        doc.SaveAs(tempFilePath);
        return Json(new { success = true, tempFilePath = $"/TempFiles/{tempFileName}" });
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error exporting Word document");
        return Json(new { success = false, message = "An error occurred while exporting the document." });
    }
}
[HttpPost]
public IActionResult ExportWordDocument()
{
    try
    {
        WordDocument doc = new WordDocument();
        doc.AddText("Test Word");
        string tempFileName = $"TempDoc_{Guid.NewGuid()}.docx";
        string tempFilePath = Path.Combine(_environment.WebRootPath, "TempFiles", tempFileName);
        Directory.CreateDirectory(Path.GetDirectoryName(tempFilePath));
        doc.SaveAs(tempFilePath);
        return Json(new { success = true, tempFilePath = $"/TempFiles/{tempFileName}" });
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error exporting Word document");
        return Json(new { success = false, message = "An error occurred while exporting the document." });
    }
}
<HttpPost>
Public Function ExportWordDocument() As IActionResult
	Try
		Dim doc As New WordDocument()
		doc.AddText("Test Word")
		Dim tempFileName As String = $"TempDoc_{Guid.NewGuid()}.docx"
		Dim tempFilePath As String = Path.Combine(_environment.WebRootPath, "TempFiles", tempFileName)
		Directory.CreateDirectory(Path.GetDirectoryName(tempFilePath))
		doc.SaveAs(tempFilePath)
		Return Json(New With {
			Key .success = True,
			Key .tempFilePath = $"/TempFiles/{tempFileName}"
		})
	Catch ex As Exception
		_logger.LogError(ex, "Error exporting Word document")
		Return Json(New With {
			Key .success = False,
			Key .message = "An error occurred while exporting the document."
		})
	End Try
End Function
$vbLabelText   $csharpLabel

Cette méthode crée un nouveau document Word à l'aide de la bibliothèque IronWord, y ajoute du texte de test et l'enregistre dans un fichier temporaire portant un nom unique. Elle renvoie un objet JSON contenant le statut de réussite et le chemin d'accès au fichier temporaire. En cas d'erreur, elle consigne l'exception et renvoie un message d'échec.

Ensuite, ajoutons la méthode permettant de gérer le téléchargement du fichier :

[HttpGet]
public IActionResult DownloadFile(string tempFilePath, string userFileName)
{
    try
    {
        string fullPath = Path.Combine(_environment.WebRootPath, tempFilePath.TrimStart('/'));
        if (!System.IO.File.Exists(fullPath))
        {
            return NotFound();
        }
        byte[] fileBytes = System.IO.File.ReadAllBytes(fullPath);
        System.IO.File.Delete(fullPath);
        string fileName = !string.IsNullOrEmpty(userFileName) ? userFileName : "ExportedDocument.docx";
        return File(fileBytes, "application/vnd.openxmlformats-officedocument.wordprocessingml.document", fileName);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error downloading file");
        return BadRequest("An error occurred while downloading the file.");
    }
}
[HttpGet]
public IActionResult DownloadFile(string tempFilePath, string userFileName)
{
    try
    {
        string fullPath = Path.Combine(_environment.WebRootPath, tempFilePath.TrimStart('/'));
        if (!System.IO.File.Exists(fullPath))
        {
            return NotFound();
        }
        byte[] fileBytes = System.IO.File.ReadAllBytes(fullPath);
        System.IO.File.Delete(fullPath);
        string fileName = !string.IsNullOrEmpty(userFileName) ? userFileName : "ExportedDocument.docx";
        return File(fileBytes, "application/vnd.openxmlformats-officedocument.wordprocessingml.document", fileName);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error downloading file");
        return BadRequest("An error occurred while downloading the file.");
    }
}
<HttpGet>
Public Function DownloadFile(ByVal tempFilePath As String, ByVal userFileName As String) As IActionResult
	Try
		Dim fullPath As String = Path.Combine(_environment.WebRootPath, tempFilePath.TrimStart("/"c))
		If Not System.IO.File.Exists(fullPath) Then
			Return NotFound()
		End If
		Dim fileBytes() As Byte = System.IO.File.ReadAllBytes(fullPath)
		System.IO.File.Delete(fullPath)
		Dim fileName As String = If(Not String.IsNullOrEmpty(userFileName), userFileName, "ExportedDocument.docx")
		Return File(fileBytes, "application/vnd.openxmlformats-officedocument.wordprocessingml.document", fileName)
	Catch ex As Exception
		_logger.LogError(ex, "Error downloading file")
		Return BadRequest("An error occurred while downloading the file.")
	End Try
End Function
$vbLabelText   $csharpLabel

Cette méthode récupère le fichier temporaire créé par ExportWordDocument, lit son contenu dans un tableau d'octets, puis supprime le fichier temporaire. Elle utilise le nom de fichier fourni par l'utilisateur ou un nom par défaut si aucun n'est fourni. La méthode renvoie ensuite le contenu du fichier sous forme de document Word téléchargeable. Si le fichier est introuvable ou si une erreur se produit, des réponses HTTP appropriées sont renvoyées.

4.4 Amélioration de la conception visuelle de l'application

Pour améliorer l'apparence générale de notre traitement de documents Word, nous avons ajouté du CSS personnalisé directement dans le fichier _Layout.cshtml. Examinons le style que nous avons implémenté :

<style>
    :root {
        --primary-color: #3498db;
        --text-color: #333;
        --bg-color: #f8f9fa;
        --nav-bg: #fff;
        --nav-text: #2c3e50;
        --nav-hover: #3498db;
    }
    body {
        font-family: 'Segoe UI', sans-serif;
        background-color: var(--bg-color);
        color: var(--text-color);
        line-height: 1.6;
    }
    .navbar { background-color: var(--nav-bg); }
    .navbar-brand {
        font-size: 1.5rem;
        font-weight: 700;
        color: var(--primary-color);
        margin-right: 2rem;
    }
    .navbar-nav { margin-left: auto; }
    .navbar-nav .nav-item { margin-left: 1rem; }
    .navbar-nav .nav-link {
        color: var(--nav-text);
        font-weight: 500;
        transition: all 0.3s ease;
        padding: 0.5rem 1rem;
        border-radius: 4px;
    }
    .navbar-nav .nav-link:hover, .navbar-nav .nav-link.active {
        color: var(--primary-color);
        background-color: rgba(52, 152, 219, 0.1);
    }
    .navbar-nav .nav-link i {
        margin-right: 0.5rem;
        font-size: 1.1em;
    }
    .centered-container {
        max-width: 800px;
        margin: 0 auto;
        padding: 2rem;
    }
    .footer {
        background-color: var(--nav-bg);
        border-top: 1px solid #ecf0f1;
        font-size: 0.9em;
        color: var(--nav-text);
    }
    .footer a {
        color: var(--primary-color);
        text-decoration: none;
        transition: color 0.3s ease;
    }
    .footer a:hover { color: var(--nav-hover); }
    @media (max-width: 576px) {
        .navbar-nav {
            margin-left: 0;
            margin-top: 1rem;
        }
        .navbar-nav .nav-item {
            margin-left: 0;
            margin-bottom: 0.5rem;
        }
    }
</style>

Ce bloc CSS définit le schéma de couleurs et la mise en page de notre application. Nous utilisons des variables CSS (propriétés personnalisées) pour créer une palette de couleurs cohérente dans toute l'application. Les styles ciblent différents éléments, notamment le corps, la barre de navigation et le pied de page, garantissant ainsi un design harmonieux. Nous avons configuré la barre de navigation avec un design épuré et moderne, intégrant des effets de survol et des icônes.

Bien que notre application soit actuellement axée sur les documents Word, nous pouvons utiliser IronPDF pour prendre en charge les documents PDF et étendre ses fonctionnalités à un plus large éventail de types de fichiers. Le système pourrait ainsi permettre aux utilisateurs d'exporter leurs documents au format PDF, en plus des options actuelles de format Word.

5. Exécution de l'application

Commençons par exécuter notre application WordDocumentProcessor. Comme on peut le voir sur l'image, l'application s'est chargée avec succès dans le navigateur. L'interface est claire et conviviale, avec une barre de navigation en haut affichant les options " Accueil " et " Exporter ". La zone de contenu principale affiche le titre " Traitement de documents Word " et une brève description : " Téléchargez et traitez vos documents Word en toute simplicité. "

Importation et exportation d'un fichier Word avec ASP.NET Core : Figure 3

Essayons maintenant d'importer un document. Sur l'image, nous pouvons voir que nous avons sélectionné un fichier nommé " Honey research synopsis.docx ". Le nom du fichier s'affiche dans la zone de téléchargement, remplaçant le bouton " Choisir un fichier ". Nous sommes maintenant prêts à télécharger et à traiter ce document.

Importation et exportation d'un fichier Word avec ASP.NET Core : Figure 4

Après avoir cliqué sur " Télécharger et traiter ", l'application traite le document et affiche son contenu. La section " Contenu du document " affiche désormais le début du document téléchargé. On peut voir le titre " Technologies apicoles et qualité de la production de miel en milieu urbain ", suivi d'un résumé. Cela démontre que notre application a correctement lu et affiché le contenu du document Word.

Importation et exportation d'un fichier Word avec ASP.NET Core : Figure 5

Enfin, testons la fonctionnalité d'exportation. Sur l'image, on voit une invite qui apparaît lorsque l'on clique sur le bouton " Exporter " dans la barre de navigation. Le message nous demande de " Saisir un nom pour le document (sans extension) ". Le nom par défaut " ExportedDocument " est prérempli, mais nous pouvons le modifier si nous le souhaitons. Cette invite nous permet de personnaliser le nom de notre document exporté avant de le télécharger.

Importation et exportation d'un fichier Word avec ASP.NET Core : Figure 6

Après avoir cliqué sur " OK ", l'application génère un nouveau document Word portant le nom spécifié et lance le processus de téléchargement. Ce document exporté contient le contenu que nous avons traité ou toutes les modifications que nous avons apportées au sein de l'application.

Importation et exportation d'un fichier Word avec ASP.NET Core : Figure 7

Tout au long de ce processus, nous pouvons constater que l'application fonctionne comme prévu. Nous pouvons utiliser cette application pour importer des documents Word, créer des documents et les exporter facilement. L'interface utilisateur est intuitive et réactive.

Conclusion

En conclusion, notre application WordDocumentProcessor démontre avec succès la puissance et la flexibilité de l'intégration du traitement de documents Word dans une application web ASP.NET Core. En tirant parti de la bibliothèque IronWord, nous avons créé une solution robuste pour importer, afficher et exporter facilement des documents Word. Cette application constitue une base solide pour des systèmes de gestion de documents ou des générateurs de rapports plus complexes. Pour les développeurs souhaitant explorer les fonctionnalités d'IronWords, la bibliothèque propose un essai gratuit . Après la période d'essai, la licence est disponible à partir de $799 , ce qui en fait une solution économique pour les entreprises ayant besoin de fonctionnalités avancées de traitement de documents Word dans leurs applications web.

Questions Fréquemment Posées

Comment puis-je importer des documents Word dans une application ASP.NET Core ?

Vous pouvez importer des documents Word dans une application ASP.NET Core en utilisant IronWord. Cela vous permet de fournir une zone de téléchargement dans l'interface utilisateur, puis d'utiliser la bibliothèque IronWord pour traiter le document, extraire et afficher son contenu dans votre application.

Quelles sont les étapes pour exporter un document Word dans ASP.NET Core ?

Pour exporter un document Word dans ASP.NET Core, utilisez IronWord pour créer un nouveau document et fournir une fonctionnalité permettant aux utilisateurs de le télécharger. Vous pouvez spécifier un nom de fichier et utiliser les méthodes d'IronWord pour écrire du contenu dans le fichier Word.

Puis-je convertir des documents Word en PDF dans les applications ASP.NET Core ?

Oui, vous pouvez convertir des documents Word en PDF en utilisant IronWord dans les applications ASP.NET Core. IronWord fournit des méthodes pour transformer facilement les documents Word en format PDF pour un partage et un accès facilités.

Quels formats de fichiers l'application prend-elle en charge pour l'importation de documents Word ?

L'application prend en charge l'importation des formats de fichiers .DOC et .DOCX en utilisant la bibliothèque IronWord, vous permettant de traiter et d'afficher ces documents dans votre application ASP.NET Core.

Comment JavaScript est-il utilisé pour améliorer l'application de traitement de documents ?

JavaScript est utilisé pour gérer les téléchargements de fichiers, envoyer des requêtes AJAX au serveur pour le traitement de documents avec IronWord, et mettre à jour l'interface utilisateur avec le contenu traité ou les messages d'erreur, garantissant une expérience utilisateur fluide.

Quels sont les prérequis pour développer une application de traitement de texte dans ASP.NET Core ?

Pour développer une application de traitement de texte dans ASP.NET Core, vous avez besoin de connaissances de base en C# et ASP.NET Core, Visual Studio 2019 ou ultérieur, ou Visual Studio Code avec l'extension C#, et le SDK .NET Core 3.1 ou ultérieur installé.

Comment l'interface utilisateur peut-elle être conçue pour un meilleur traitement de documents ?

L'interface utilisateur peut être conçue avec une zone de téléchargement pour sélectionner les documents Word et une zone d'affichage de contenu pour montrer le contenu traité. Du CSS personnalisé peut être utilisé pour améliorer la conception pour une expérience utilisateur attrayante et conviviale.

Quels sont certains cas d'utilisation potentiels pour intégrer le traitement de texte dans les applications web ?

Les cas d'utilisation potentiels incluent les systèmes de gestion de documents et les générateurs de rapports, où l'intégration de capacités de traitement de texte en utilisant IronWord peut simplifier la gestion, l'édition et les processus de conversion de documents dans l'application web.

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