Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronWord
  2. IronWord-Blog
  3. IronWord verwenden
  4. ASP .NET Core Import & Export Word-Datei
IRONWORD VERWENDEN

ASP .NET Core Import & Export einer Word-Datei

Jordi Bardia
Jordi Bardia
Aktualisiert:

Dieser Leitfaden untersucht, wie vorhandene Word-Dokumente importiert, deren Inhalte angezeigt und Dokumente von Grund auf neu erstellt werden können, indem die IronWord-Bibliothek verwendet wird. Am Ende dieses Tutorials haben Sie eine ASP.NET Core Webanwendung erstellt, die Folgendes kann:

  1. Word-Dokumente hochladen und lesen
  2. Den Inhalt dieser Dokumente in einem Textfeld anzeigen
  3. Die Docx-Datei exportieren

Dieses Projekt ist perfekt für Entwickler, die die Verarbeitung von Word-Dokumenten in ihre Webanwendungen integrieren müssen, sei es für Dokumentenmanagementsysteme, Berichtsgeneratoren oder andere Szenarien, die Microsoft Word-Dateien beinhalten.

Voraussetzungen

Um diesem Tutorial zu folgen, sollten Sie haben:

  • Grundkenntnisse in C# und ASP.NET Core
  • Visual Studio 2019 oder höher installiert (alternativ können Sie Visual Studio Code mit der C#-Erweiterung verwenden)
  • .NET Core SDK 3.1 oder höher

Keine Sorge, wenn Sie kein Experte in diesen Technologien sind – wir führen Sie durch jeden Schritt des Prozesses!

Was ist IronWord?

IronWord ist eine .NET-Bibliothek, die Entwicklern ermöglicht, Microsoft Word-Dokumente programmatisch zu lesen, zu manipulieren und zu erstellen. Es bietet eine hochrangige API, die die Arbeit mit Word-Dateien vereinfacht und es zu einer ausgezeichneten Wahl für unser Projekt macht.

Einige der wichtigsten Funktionen von IronWord umfassen:

  • Lesen und Schreiben verschiedener Word-Formate (DOCX, DOC, etc.)
  • Manipulation von Dokumentinhalten und -strukturen
  • Formatierung von Texten und Absätzen
  • Arbeiten mit Tabellen, Bildern und anderen Dokumentelementen
  • Serienbriefprozess für Dokumente
  • Konvertieren eines Word-Dokuments in ein PDF-Dokument mit Leichtigkeit, was Ihnen ermöglicht, Ihre endgültigen Word-Dokumente in einfach freizugeben PDF-Dateien umzuwandeln

Jetzt, da wir einen Überblick darüber haben, was wir bauen und welche Werkzeuge wir nutzen werden, tauchen wir in die Einrichtung unseres Projekts ein!

2. Einrichten des Projekts

In diesem Abschnitt erstellen wir ein neues ASP.NET Core-Projekt und installieren die erforderlichen Pakete, um mit IronWord zu arbeiten.

2.1 Erstellung eines neuen ASP.NET Core-Projekts

  1. Öffnen Sie Visual Studio 2019 oder neuer.
  2. Klicken Sie auf "Neues Projekt erstellen".
  3. Suchen Sie nach "ASP.NET Core Web Application" und wählen Sie es aus.
  4. Klicken Sie auf "Weiter".
  5. Nennen Sie Ihr Projekt "WordDocumentProcessor" (oder einen anderen Namen Ihrer Wahl).
  6. Wählen Sie das .NET Framework und einen Speicherort für Ihr Projekt aus und klicken Sie auf "Erstellen".

2.2 Installation des IronWord NuGet-Pakets

Jetzt, da wir unser Projekt eingerichtet haben, fügen wir die IronWord-Bibliothek hinzu:

  1. Klicken Sie mit der rechten Maustaste auf Ihr Projekt im Projektmappen-Explorer.
  2. Wählen Sie "NuGet-Pakete verwalten".
  3. Suchen Sie im Tab "Durchsuchen" nach "IronWord".
  4. Suchen Sie nach dem offiziellen IronWord-Paket.
  5. Klicken Sie auf "Installieren", um es Ihrem Projekt hinzuzufügen.

2.3 Aktualisierung des vorhandenen Controllers und der Ansicht

Aktualisieren wir unsere bestehende Struktur, um die Dokumentverarbeitungsfunktionalität zu integrieren:

  1. Wir werden die vorhandene HomeController.cs im Controllers-Ordner für unsere Dokumentverarbeitungslogik verwenden.
  2. Wir werden die vorhandene Index.cshtml Ansicht im Ordner Views/Home aktualisieren, um die Funktionalität zum Hochladen und Anzeigen von Dokumenten einzubinden.

Da wir unser Projekt eingerichtet und das IronWord-Paket installiert haben, können wir mit der Implementierung der Import- und Exportfunktionen für Dokumente beginnen. Wir werden neue Methoden zu unserem HomeController hinzufügen und die Index-Ansicht ändern, um diese Funktionen zu unterstützen. Im nächsten Abschnitt konzentrieren wir uns auf das Importieren von Word-Dokumenten und das Anzeigen ihrer Inhalte, indem wir unsere vorhandene Controller- und Ansichtsstruktur verwenden.

3. Importieren von Word-Dokumenten

In diesem Abschnitt erfahren wir, wie Sie eine Funktion zum Importieren und Verarbeiten von Word-Dokumenten in einer ASP.NET MVC-Anwendung implementieren. Wir behandeln sowohl das Design der Benutzeroberfläche als auch die Back-End-Controller-Logik.

3.1 Entwurf der Benutzeroberfläche

Die Benutzeroberfläche für das Importieren von Word-Dokumenten ist so konzipiert, dass sie intuitiv und optisch ansprechend ist. Lassen Sie uns die wichtigsten Komponenten der Benutzeroberfläche aufschlüsseln:

3.1.1 Upload-Bereich

Der Upload-Bereich ist der zentrale Punkt der Benutzeroberfläche, der die Benutzer einlädt, ihre Word-Dokumente auszuwählen und hochzuladen. Hier ist, wie es strukturiert ist:

<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

Dieser Code erstellt einen optisch ansprechenden Upload-Bereich mit einem Dateisymbol, einem versteckten Dateieingabefeld und einem stilisierten Label, das als Dateiauswahlschaltfläche fungiert. Es enthält auch Informationen zu akzeptierten Dateitypen und eine Schaltfläche, um den Upload und die Verarbeitung zu starten.

3.1.2 Bereich zur Inhaltsanzeige

Nach der Verarbeitung des Dokuments wird sein Inhalt in einem speziellen Bereich angezeigt:

<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

Dieser Abschnitt bietet einen scrollbaren Bereich, um den verarbeiteten Dokumentinhalt anzuzeigen.

3.2 Implementierung des Controllers

Der HomeController übernimmt die serverseitige Logik für das Importieren und Verarbeiten von Word-Dokumenten. Lassen Sie uns die wichtigsten Methoden untersuchen:

3.2.1 UploadAndProcess Methode

Diese Methode ist für die Handhabung des Datei-Uploads und der Verarbeitung verantwortlich:

[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

Diese Methode führt die folgenden Aufgaben aus:

  1. Validiert die hochgeladene Datei und stellt sicher, dass sie im richtigen Dateiformat (DOC oder DOCX) vorliegt.
  2. Verarbeitet das Dokument mit der IronWord-Bibliothek.
  3. Gibt den formatierten Inhalt als JSON zurück.

3.2.2 FormatContentAsHtml Methode

Diese private Methode formatiert den extrahierten Inhalt in 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

Diese Methode stellt sicher, dass der Dokumentinhalt korrekt als HTML formatiert wird, wobei jede Zeile in Absatz-Tags eingeschlossen und leere Zeilen beibehalten werden.

3.3 Clientseitiges JavaScript

Um den Datei-Upload zu handhaben und den verarbeiteten Inhalt anzuzeigen, verwenden wir 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

Dieses JavaScript-Code handhabt den Datei-Upload-Prozess, sendet die Datei zur Verarbeitung an den Server und aktualisiert die Benutzeroberfläche mit dem verarbeiteten Inhalt oder Fehlermeldungen.

3.4 Stilgestaltung der Benutzeroberfläche

Die Anwendung verwendet benutzerdefiniertes CSS, um eine attraktive und benutzerfreundliche Benutzeroberfläche zu erstellen.

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

Dieses CSS schafft ein sauberes, modernes Erscheinungsbild mit einem hellen Farbschema. Der Upload-Bereich präsentiert sich mit einem weißen Hintergrund und subtilen Schattierungseffekten, während der Inhaltsbereich ein scrollbares Design mit einem hellgrauen Hintergrund besitzt. Verwendung von border-radius und box-shadow Eigenschaften verleiht den Interface-Elementen Tiefe und visuelles Interesse.

4. Exportieren von Word-Dokumenten

Während wir unseren Word Document Processor weiter verbessern, fügen wir die Möglichkeit hinzu, Dokumente zu exportieren. Diese Funktion ermöglicht es Benutzern, ein neues Word-Dokument aus unserer Anwendung zu generieren.

4.1 Aktualisierung der Benutzeroberfläche

Zuerst fügen wir eine "Export"-Option zu unserer Navigationsleiste hinzu. Öffnen Sie die Datei _Layout.cshtml im Ordner Views/Shared und lokalisieren Sie das Element

    . Fügen Sie der Navigationsleiste ein neues Listenfeld für unsere Exportfunktion hinzu:

    <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

    Wir verwenden Font Awesome für das Icon, daher stellen Sie sicher, dass wir den CSS-Link in unserem -Abschnitt haben. Dieser Code fügt der Navigationsleiste einen "Export"-Link hinzu. Er verwendet Font Awesome für das Icon und ruft die Funktion exportDocument() auf, wenn darauf geklickt wird. Das href="#" und return false verhindern das Standardverhalten des Links.

4.2 Implementierung der clientseitigen Exportlogik

Nun fügen wir die JavaScript-Funktion hinzu, die den Exportprozess handhabt. Am Ende unserer Datei _Layout.cshtml, kurz vor dem schließenden -Tag, fügen wir das folgende Skript hinzu:

<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

Diese JavaScript-Funktion sendet eine AJAX-POST-Anfrage an den Server, um ein Word-Dokument zu erstellen. Bei Erfolg fordert es den Benutzer auf, einen Dateinamen einzugeben, und erstellt dann einen temporären Link, um die Datei herunterzuladen. Der Link wird automatisch geklickt und dann aus dem DOM entfernt. Bei einem Fehler in irgendeiner Phase wird dem Benutzer eine Warnung angezeigt.

4.3 Hinzufügen von serverseitiger Exportfunktionalität

Nun implementieren wir die serverseitige Logik. Öffnen Sie die Datei HomeController.cs im Ordner Controllers. Wir fügen zwei neue Methoden hinzu, um den Exportprozess zu handhaben.

Zuerst fügen wir die Methode hinzu, um das Word-Dokument zu erstellen:

[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

Diese Methode erstellt ein neues Word-Dokument mit der IronWord-Bibliothek, fügt etwas Text zum Testen hinzu und speichert es in einer temporären Datei mit einem eindeutigen Namen. Sie gibt ein JSON-Objekt mit dem Erfolgsstatus und dem Pfad zur temporären Datei zurück. Tritt ein Fehler auf, wird die Ausnahme protokolliert und eine Fehlermeldung zurückgegeben.

Als nächstes fügen wir die Methode hinzu, um den Dateidownload zu handhaben:

[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

Diese Methode ruft die temporäre Datei ab, die von ExportWordDocument erstellt wurde, liest ihre Inhalte in ein Byte-Array und löscht dann die temporäre Datei. Sie verwendet den bereitgestellten Benutzernamen oder einen Standardnamen, wenn keiner angegeben wird. Die Methode gibt dann den Dateiinhalt als herunterladbares Word-Dokument zurück. Wenn die Datei nicht gefunden wird oder ein Fehler auftritt, werden entsprechende HTTP-Antworten zurückgegeben.

4.4 Verbesserung des visuellen Designs der Anwendung

Um das gesamte Erscheinungsbild unseres Word Document Processors zu verbessern, haben wir benutzerdefiniertes CSS direkt in der Datei _Layout.cshtml hinzugefügt. Lassen Sie uns die implementierte Stilgestaltung untersuchen:

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

Dieser CSS-Block definiert das Farbschema und Layout unserer Anwendung. Wir verwenden CSS-Variablen (benutzerdefinierte Eigenschaften), um eine konsistente Farbpalette in der gesamten App zu erstellen. Die Stile richten sich auf verschiedene Elemente, einschließlich Körper, Navigationsleiste und Fußzeile, was ein zusammenhängendes Design sicherstellt. Wir haben die Navigationsleiste mit einem sauberen, modernen Aussehen eingerichtet, das Hovureffekte und Icon-Integration umfasst.

Während unsere Anwendung derzeit auf Word-Dokumente fokussiert ist, können wir IronPDF verwenden, um Unterstützung für PDF-Dokumente einzubeziehen und ihre Funktionalität zu erweitern, um ein breiteres Spektrum an Dateitypen abzudecken. Das System könnte erweitert werden, um Benutzern zu ermöglichen, ihre Dokumente als PDF-Datei zu exportieren, zusätzlich zu den aktuellen Word-Formatoptionen.

5. Ausführen der Anwendung

Lassen Sie uns beginnen, unsere WordDocumentProcessor-Anwendung auszuführen. Wie wir auf dem Bild sehen können, wurde die Anwendung erfolgreich im Browser geladen. Die Benutzeroberfläche ist sauber und benutzerfreundlich, mit einer Navigationsleiste oben, die "Start"- und "Export"-Optionen anzeigt. Der Hauptinhaltbereich zeigt den Titel "Word Document Processor" und eine kurze Beschreibung: "Laden Sie Ihre Word-Dokumente hoch und verarbeiten Sie sie einfach."

ASP .NET Core Import & Export A Word File: Abbildung 3

Lassen Sie uns nun versuchen, ein Dokument zu importieren. Auf dem Bild sehen wir, dass wir eine Datei mit dem Namen "Honey research synopsis.docx" ausgewählt haben. Der Dateiname wird im Upload-Bereich angezeigt und ersetzt die Schaltfläche "Datei auswählen". Wir sind jetzt bereit, dieses Dokument hochzuladen und zu verarbeiten.

ASP .NET Core Import & Export A Word File: Abbildung 4

Nach dem Klicken auf "Hochladen und Verarbeiten" verarbeitet die Anwendung das Dokument und zeigt dessen Inhalt an. Der Abschnitt "Dokumenteninhalt" zeigt nun den Anfang des hochgeladenen Dokuments. Wir sehen den Titel "Beekeeping Technologies and Quality of Honey Production in Urban Areas" gefolgt von einem Abstract. Dies zeigt, dass unsere Anwendung den Inhalt des Word-Dokuments erfolgreich gelesen und angezeigt hat.

ASP .NET Core Import & Export A Word File: Abbildung 5

Abschließend testen wir die Exportfunktion. Auf dem Bild sehen wir eine Eingabeaufforderung, die erscheint, wenn wir auf die Schaltfläche "Exportieren" in der Navigationsleiste klicken. Die Aufforderung fordert uns auf, "einen Namen für das Dokument einzugeben (ohne Erweiterung)". Der Standardname "ExportedDocument" ist vorausgefüllt, kann aber nach Belieben geändert werden. Diese Eingabeaufforderung ermöglicht es uns, den Namen unseres exportierten Dokuments anzupassen, bevor es heruntergeladen wird.

ASP .NET Core Import & Export A Word File: Abbildung 6

Nach dem Klicken auf "OK" erstellt die Anwendung ein neues Word-Dokument mit dem angegebenen Namen und initiiert den Download-Prozess. Dieses exportierte Dokument enthält den von uns verarbeiteten Inhalt oder alle Änderungen, die wir innerhalb der Anwendung vorgenommen haben.

ASP .NET Core Import & Export A Word File: Abbildung 7

Im gesamten Prozess sehen wir, dass die Anwendung wie beabsichtigt funktioniert. Wir können diese Anwendung verwenden, um Word-Dokumente zu importieren, Dokumente zu erstellen und sie einfach zu exportieren. Die Benutzeroberfläche ist intuitiv und reaktionsschnell.

Abschluss

Zusammenfassend demonstriert unsere WordDocumentProcessor-Anwendung erfolgreich die Power und Flexibilität der Integration von Word-Dokumentenverarbeitung in eine ASP.NET Core-Webanwendung. Durch die Nutzung der IronWord-Bibliothek haben wir eine robuste Lösung zum Importieren, Anzeigen und Exportieren von Word-Dokumenten mit Leichtigkeit创建. Diese Anwendung dient als solide Grundlage für komplexere Dokumentenmanagementsysteme oder Berichtsgeneratoren. Für Entwickler, die IronWords Fähigkeiten weiter erkunden möchten, bietet die Bibliothek eine kostenlose Testversion an. Nach der Testversion beginnt die Lizenzierung bei $799, was sie zu einer kostengünstigen Lösung für Unternehmen macht, die erweiterte Word-Dokumentenverarbeitungsfunktionen in ihren Webanwendungen benötigen.

Häufig gestellte Fragen

Wie kann ich Word-Dokumente in einer ASP.NET Core-Anwendung importieren?

Sie können Word-Dokumente in einer ASP.NET Core-Anwendung importieren, indem Sie IronWord verwenden. Es ermöglicht Ihnen, einen Upload-Bereich in der Benutzeroberfläche bereitzustellen und dann die IronWord-Bibliothek zu verwenden, um das Dokument zu verarbeiten, dessen Inhalt zu extrahieren und in Ihrer Anwendung anzuzeigen.

Was sind die Schritte zum Exportieren eines Word-Dokuments in ASP.NET Core?

Um ein Word-Dokument in ASP.NET Core zu exportieren, verwenden Sie IronWord, um ein neues Dokument zu erstellen und bieten Sie Funktionen für Benutzer zum Herunterladen an. Sie können einen Dateinamen angeben und die Methoden von IronWord verwenden, um Inhalte in die Word-Datei zu schreiben.

Kann ich Word-Dokumente in ASP.NET Core-Anwendungen in PDF konvertieren?

Ja, Sie können Word-Dokumente in PDF konvertieren, indem Sie IronWord in ASP.NET Core-Anwendungen verwenden. IronWord bietet Methoden, um Word-Dokumente einfach in das PDF-Format zu transformieren, um die Freigabe und Zugänglichkeit zu erleichtern.

Welche Dateiformate unterstützt die Anwendung für den Import von Word-Dokumenten?

Die Anwendung unterstützt den Import von .DOC- und .DOCX-Dateiformaten unter Verwendung der IronWord-Bibliothek, sodass Sie diese Dokumente innerhalb Ihrer ASP.NET Core-Anwendung verarbeiten und anzeigen können.

Wie wird JavaScript zur Verbesserung der Dokumentverarbeitungsanwendung eingesetzt?

JavaScript wird verwendet, um Dateiuploads zu handhaben, AJAX-Anfragen an den Server für die Dokumentverarbeitung mit IronWord zu senden und die Benutzeroberfläche mit den verarbeiteten Inhalten oder Fehlermeldungen zu aktualisieren, um ein nahtloses Benutzererlebnis zu gewährleisten.

Was sind die Voraussetzungen für die Entwicklung einer Word-Verarbeitungs-App in ASP.NET Core?

Um eine Word-Verarbeitungs-App in ASP.NET Core zu entwickeln, benötigen Sie Grundkenntnisse in C# und ASP.NET Core, Visual Studio 2019 oder später oder Visual Studio Code mit der C#-Erweiterung und das .NET Core SDK 3.1 oder später installiert.

Wie kann die Benutzeroberfläche für eine bessere Dokumentverarbeitung gestaltet werden?

Die Benutzeroberfläche kann mit einem Upload-Bereich zum Auswählen von Word-Dokumenten und einem Inhaltsanzeigebereich zum Anzeigen der verarbeiteten Inhalte gestaltet werden. Benutzerdefiniertes CSS kann verwendet werden, um das Design für ein attraktives, benutzerfreundliches Erlebnis zu verbessern.

Was sind einige mögliche Einsatzmöglichkeiten für die Integration der Word-Verarbeitung in Webanwendungen?

Mögliche Einsatzmöglichkeiten umfassen Dokumentenverwaltungssysteme und Berichtsgeneratoren, bei denen die Integration der Word-Verarbeitungsfähigkeiten unter Verwendung von IronWord die Dokumentenhandhabung, das Bearbeiten und den Konvertierungsprozess innerhalb der Webanwendung optimieren kann.

Jordi Bardia
Jordi Bardia
  Jetzt mit dem Ingenieurteam chatten
Software Ingenieur
Jordi ist am besten in Python, C# und C++ versiert. Wenn er nicht bei Iron Software seine Fähigkeiten einsetzt, programmiert er Spiele. Mit Verantwortung für Produkttests, Produktentwicklung und -forschung trägt Jordi mit immensem Wert zur kontinuierlichen Produktverbesserung bei. Die abwechslungsreiche Erfahrung hält ihn gefordert und engagiert, ...
Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Testversion