Didn’t find what you were looking for?
Ikona wiadomości
Przejdź do treści stopki
  1. IronWord
  2. Blog IronWord
  3. Używanie IronWord
  4. ASP .NET Core Importowanie i Eksportowanie pliku Word
UZYWANIE IRONWORD

VS 2022 Programistyczne tworzenie nowych dokumentów Word (samouczek)

Curtis Chau
Curtis Chau
Zaktualizowano:

W tym przewodniku omówiono, jak importować istniejące dokumenty WORD, wyświetlać ich zawartość oraz tworzyć dokumenty od podstaw przy użyciu biblioteki IronWord. Pod koniec tego samouczka stworzysz aplikację internetową ASP.NET Core, która będzie potrafiła:

  1. Prześlij i przeczytaj dokumenty WORD
  2. Wyświetl zawartość tych dokumentów w polu tekstowym
  3. Eksportuj plik Docx

Ten projekt jest idealny dla programistów, którzy muszą zintegrować przetwarzanie dokumentów WORD ze swoimi aplikacjami internetowymi, czy to w systemach zarządzania dokumentami, generatorach raportów, czy w jakimkolwiek innym scenariuszu z wykorzystaniem plików Microsoft WORD.

Wymagania wstępne

Aby śledzić ten samouczek, należy posiadać:

  • Podstawowa znajomość języka C# i platformy ASP.NET Core
  • Zainstalowany program Visual Studio 2019 lub nowszy (alternatywnie można użyć programu Visual Studio Code z rozszerzeniem C#)
  • .NET Core SDK 3.1 lub nowszy

Nie martw się, jeśli nie jesteś ekspertem w tych technologiach – poprowadzimy Cię przez każdy etap procesu!

Czym jest IronWord?

IronWord to biblioteka .NET, która pozwala programistom programowo odczytywać, modyfikować i tworzyć dokumenty Microsoft Word. Zapewnia API wysokiego poziomu, które upraszcza pracę z plikami WORD, co czyni go doskonałym wyborem dla naszego projektu.

Niektóre kluczowe funkcje IronWord to:

  • Odczytywanie i zapisywanie różnych formatów WORDa (DOCX, DOC itp.)
  • Manipulowanie treścią i strukturą dokumentu
  • Formatowanie tekstu i akapitów
  • Praca z tabelami, obrazami i innymi elementami dokumentu
  • Proces korespondencji seryjnej dla dokumentów
  • Łatwa konwersja dokumentu WORDa do formatu PDF, umożliwiająca przekształcenie gotowych dokumentów WORDa w pliki PDF, które można łatwo udostępniać

Teraz, gdy mamy już ogólny zarys tego, co tworzymy, oraz narzędzi, których będziemy używać, przejdźmy do konfiguracji naszego projektu!

2. Konfiguracja projektu

W tej sekcji utworzymy nowy projekt ASP.NET Core i zainstalujemy pakiety niezbędne do pracy z IronWord.

2.1 Tworzenie nowego projektu ASP.NET Core

  1. Otwórz program Visual Studio 2019 lub nowszą wersję.
  2. Kliknij na "Utwórz nowy projekt".
  3. Wyszukaj "Aplikacja internetowa ASP.NET Core" i wybierz ją.
  4. Kliknij "Dalej".
  5. Nazwij swój projekt "WordDocumentProcessor" (lub dowolną inną nazwą).
  6. Wybierz platformę .NET Framework oraz lokalizację dla swojego projektu, a następnie kliknij "Utwórz".

2.2 Instalacja pakietu IronWord NuGet

Skoro mamy już skonfigurowany projekt, dodajmy bibliotekę IronWord:

  1. Kliknij prawym przyciskiem na swoim projekcie w Eksploratorze rozwiązań.
  2. Wybierz opcję "Zarządzaj pakietami NuGet".
  3. W zakładce "Przeglądaj" wyszukaj "IronWord".
  4. Poszukaj oficjalnego pakietu IronWord.
  5. Kliknij "Zainstaluj", aby dodać ją do swojego projektu.

2.3 Aktualizacja istniejącego kontrolera i widoku

Zaktualizujmy naszą istniejącą strukturę, aby uwzględnić funkcjonalność przetwarzania dokumentów:

  1. Do logiki przetwarzania dokumentów wykorzystamy istniejący plik HomeController.cs znajdujący się w folderze Controllers.
  2. Zaktualizujemy istniejący widok Index.cshtml w folderze Views/Home, aby uwzględnić funkcję przesyłania i wyświetlania dokumentów.

Teraz, gdy mamy już skonfigurowany projekt i zainstalowany pakiet IronWord, jesteśmy gotowi do rozpoczęcia wdrażania funkcji importu i eksportu dokumentów. Dodamy nowe metody do naszego HomeController i zmodyfikujemy widok Index, aby obsługiwał te funkcje. W następnej sekcji skupimy się na importowaniu dokumentów WORDa i wyświetlaniu ich treści, wykorzystując naszą istniejącą strukturę kontrolerów i widoków.

3. Importowanie dokumentów WORD

W tej sekcji omówimy, jak zaimplementować funkcję importowania i przetwarzania dokumentów WORD w aplikacji ASP.NET MVC. Omówimy zarówno projekt interfejsu użytkownika, jak i logikę kontrolera zaplecza.

3.1 Projektowanie interfejsu użytkownika

Interfejs użytkownika służący do importowania dokumentów WORD został zaprojektowany tak, aby był intuicyjny i atrakcyjny wizualnie. Przeanalizujmy kluczowe elementy interfejsu użytkownika:

3.1.1 Obszar przesyłania plików

Obszar przesyłania plików jest centralnym punktem interfejsu, zachęcającym użytkowników do wybierania i przesyłania dokumentów WORD. Oto jak wygląda struktura tekstu:

<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

Ten kod tworzy atrakcyjny wizualnie obszar przesyłania plików z ikoną pliku, ukrytym polem wprowadzania pliku oraz stylizowaną etykietą pełniącą rolę przycisku wyboru pliku. Zawiera również informacje o akceptowanych typach plików oraz przycisk do rozpoczęcia przesyłania i przetwarzania.

3.1.2 Obszar wyświetlania treści

Po przetworzeniu dokumentu jego treść jest wyświetlana w specjalnym obszarze:

<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

Ta sekcja zawiera obszar przewijalny, w którym wyświetlana jest przetworzona treść dokumentu.

3.2 Implementacja kontrolera

HomeController obsługuje logikę po stronie serwera dotyczącą importowania i przetwarzania dokumentów WORD. Przyjrzyjmy się kluczowym metodom:

3.2.1 Metoda UploadAndProcess

Ta metoda odpowiada za obsługę przesyłania i przetwarzania plików:

[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

Ta metoda wykonuje następujące zadania:

  1. Sprawdza przesłany plik, upewniając się, że ma on prawidłowy format (DOC lub DOCX).
  2. Przetwarza dokument przy użyciu biblioteki IronWord.
  3. Zwraca sformatowaną treść w formacie JSON.

3.2.2 Metoda FormatContentAsHtml

Ta metoda prywatna formatuje wyodrębnioną treść do postaci 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

Ta metoda zapewnia, że treść dokumentu jest poprawnie sformatowana jako HTML, z każdą linią zawartą w tagach akapitu i zachowanymi pustymi liniami.

3.3 JavaScript po stronie klienta

Aby obsłużyć przesyłanie plików i wyświetlić przetworzoną treść, używamy 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

Ten kod JavaScript obsługuje proces przesyłania plików, wysyła plik do serwera w celu przetworzenia oraz aktualizuje interfejs użytkownika o przetworzoną treść lub komunikaty o błędach.

3.4 Stylizacja interfejsu użytkownika

Aplikacja wykorzystuje niestandardowy CSS do tworzenia atrakcyjnego i przyjaznego dla użytkownika interfejsu.

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

Ten CSS tworzy przejrzysty, nowoczesny wygląd z jasną kolorystyką. Obszar przesyłania plików ma białe tło z subtelnymi efektami cieni, natomiast obszar treści ma układ umożliwiający przewijanie na jasnoszarym tle. Zastosowanie właściwości border-radius i box-shadow nadaje elementom interfejsu głębię i atrakcyjny wygląd.

4. Eksportowanie dokumentów Word

Kontynuując udoskonalanie naszego procesora dokumentów Word, dodajmy możliwość eksportowania dokumentów. Ta funkcja pozwoli użytkownikom na generowanie nowego dokumentu Word z naszej aplikacji.

4.1 Aktualizowanie interfejsu użytkownika

Najpierw dodamy opcję "Eksportuj" do naszego paska nawigacyjnego. Otwórz plik _Layout.cshtml w folderze Widoki/Wspólne i zlokalizuj element <ul class="navbar-nav">. Dodajmy nowy element listy dla naszej funkcji eksportowania:

<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

Używamy Font Awesome dla ikony, więc upewnij się, że mamy link do CSS w naszej sekcji <head>. Ten kod dodaje link "Eksportuj" do paska nawigacyjnego. Wykorzystuje Font Awesome do ikony i wywołuje funkcję exportDocument() po kliknięciu. Element href="#" i return false zapobiegają domyślnemu zachowaniu linku.

4.2 Implementacja logiki eksportu po stronie klienta

Teraz dodajmy funkcję JavaScript, która obsłuży proces eksportowania. Na dole naszego pliku _Layout.cshtml, tuż przed zamykającym tagiem </body>, dodamy następujący skrypt:

<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

Ta funkcja JavaScript wysyła żądanie AJAX POST do serwera, aby utworzyć dokument Word. Po pomyślnym zakończeniu proces wyświetla użytkownikowi powiadomienie o nazwie pliku i tworzy tymczasowy link do pobrania pliku. Link jest automatycznie klikany i następnie usuwany z DOM. Jeśli na jakimkolwiek etapie wystąpi błąd, użytkownik otrzymuje powiadomienie.

4.3 Dodawanie funkcjonalności eksportu po stronie serwera

Pozwólmy teraz zaimplementować logikę po stronie serwera. Otwórz plik HomeController.cs w folderze Kontrolerów. Dodamy dwie nowe metody do obsługi procesu eksportu.

Najpierw dodajmy metodę do tworzenia dokumentu 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

Ta metoda tworzy nowy dokument Word przy użyciu biblioteki IronWord, dodaje trochę testowego tekstu i zapisuje go do tymczasowego pliku z unikalną nazwą. Zwraca obiekt JSON ze statusem pomyślności i ścieżką do tymczasowego pliku. Jeśli wystąpi błąd, loguje wyjątek i zwraca komunikat o niepowodzeniu.

Następnie dodajmy metodę do obsługi pobierania pliku:

[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

Ta metoda pobiera tymczasowy plik utworzony przez ExportWordDocument, czyta jego zawartość do tablicy bajtów, a następnie usuwa tymczasowy plik. Używa podanej przez użytkownika nazwy pliku lub domyślnej nazwy, jeśli żadna nie została podana. Metoda następnie zwraca zawartość pliku jako możliwy do pobrania dokument Word. Jeśli plik nie zostanie znaleziony lub wystąpi błąd, odpowiednie odpowiedzi HTTP są zwracane.

4.4 Ulepszanie wizualnego projektu aplikacji

Aby poprawić ogólny wygląd naszego procesora dokumentów Word, dodaliśmy niestandardowe CSS bezpośrednio w pliku _Layout.cshtml. Przyjrzyjmy się stylom, które wprowadziliśmy:

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

Ten blok CSS definiuje nasz schemat kolorów i układ aplikacji. Używamy zmiennych CSS (własności niestandardowe) do stworzenia spójnej palety kolorów w całej aplikacji. Style są skierowane do różnych elementów, w tym ciała, paska nawigacji i stopki, zapewniając spójny design. Ustaliliśmy, że pasek nawigacji ma czysty, nowoczesny wygląd, z efektami najechania i integracją ikon.

Chociaż nasza aplikacja skupia się obecnie na dokumentach Word, możemy użyć IronPDF, aby dodać wsparcie dla dokumentów PDF i rozbudować jej funkcjonalność o szerszy zakres rodzajów plików. System mógłby zostać rozszerzony, aby pozwalał użytkownikom eksportować dokumenty jako plik PDF w dodatku do obecnych opcji formatu Word.

5. Uruchamianie aplikacji

Zacznijmy od uruchomienia naszej aplikacji WordDocumentProcessor. Jak widzimy na obrazku, aplikacja załadowała się pomyślnie w przeglądarce. Interfejs jest czysty i przyjazny dla użytkownika, z paskiem nawigacyjnym na górze pokazującym opcje "Strona główna" i "Eksport". Główna część wyświetla tytuł "Procesor Dokumentów Word" i krótki opis: "Przesyłaj i przetwarzaj swoje dokumenty Word z łatwością."

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

Teraz spróbujmy zaimportować dokument. Na obrazku widzimy, że wybraliśmy plik o nazwie "Streszczenie badań miodu.docx". Nazwa pliku jest wyświetlana w obszarze przesyłania, zastępując przycisk "Wybierz Plik". Jesteśmy teraz gotowi do przesłania i przetwarzania tego dokumentu.

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

Po kliknięciu "Przesyłaj i Przetwarzaj", aplikacja przetwarza dokument i wyświetla jego zawartość. Sekcja "Treść dokumentu" teraz pokazuje początek przesłanego dokumentu. Widzimy tytuł "Technologie Pszczelarstwa i Jakość Produkcji Miodu w Obszarach Miejskich" po którym następuje abstrakt. To pokazuje, że nasza aplikacja pomyślnie odczytała i wyświetliła zawartość dokumentu Word.

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

Na koniec przetestujmy funkcję eksportu. Na obrazku widzimy monit, który pojawia się po kliknięciu przycisku "Eksportuj" w pasku nawigacyjnym. Komunikat prosi nas o "Wprowadź nazwę dokumentu (bez rozszerzenia)". Domyślna nazwa "ExportedDocument" jest wstępnie wypełniona, ale możemy ją zmienić, jeśli chcemy. Ten monit pozwala nam dostosować nazwę eksportowanego dokumentu przed jego pobraniem.

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

Po kliknięciu "OK", aplikacja generuje nowy dokument Word z określoną nazwą i inicjuje proces pobierania. Ten wyeksportowany dokument zawiera przetworzoną zawartość lub wszelkie modyfikacje, które wprowadziliśmy w aplikacji.

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

Podczas tego procesu widzimy, że aplikacja działa zgodnie z założeniami. Możemy używać tej aplikacji do importowania dokumentów Word, tworzenia dokumentów i ich eksportowania z łatwością. Interfejs użytkownika jest intuicyjny i responsywny.

Wnioski

Podsumowując, nasza aplikacja WordDocumentProcessor pomyślnie demonstruje moc i elastyczność integracji przetwarzania dokumentów Word w aplikacji webowej ASP.NET Core. Wykorzystując bibliotekę IronWord, stworzyliśmy solidne rozwiązanie do importowania, wyświetlania i eksportowania dokumentów Word z łatwością. Ta aplikacja stanowi solidną podstawę dla bardziej zaawansowanych systemów zarządzania dokumentami lub generatorów raportów. Dla programistów zainteresowanych eksplorowaniem możliwości IronWord, biblioteka oferuje darmowy okres próbny. Po wersji próbnej, licencjonowanie zaczyna się od $999, co czyni go opłacalnym rozwiązaniem dla firm wymagających zaawansowanej funkcjonalności przetwarzania dokumentów Word w swoich aplikacjach webowych.

Często Zadawane Pytania

Jak mogę zaimportować dokumenty Word w aplikacji ASP.NET Core?

Możesz zaimportować dokumenty Word w aplikacji ASP.NET Core, używając IronWord. Umożliwia to dostarczenie obszaru do przesyłania w interfejsie użytkownika, a następnie użycie biblioteki IronWord do przetwarzania dokumentu, wyodrębnienia i wyświetlenia jego zawartości w twojej aplikacji.

Jakie są kroki do eksportowania dokumentu Word w ASP.NET Core?

Aby wyeksportować dokument Word w ASP.NET Core, użyj IronWord do utworzenia nowego dokumentu i dostarczenia użytkownikom funkcji pobierania go. Możesz określić nazwę pliku i używać metod IronWord do zapisu zawartości do pliku Word.

Czy mogę konwertować dokumenty Word do PDF w aplikacjach ASP.NET Core?

Tak, możesz konwertować dokumenty Word do PDF używając IronWord w aplikacjach ASP.NET Core. IronWord dostarcza metod do łatwego przekształcania dokumentów Word na format PDF, co ułatwia udostępnianie i dostępność.

Jakie formaty plików obsługuje aplikacja do importowania dokumentów Word?

Aplikacja obsługuje importowanie plików w formatach .DOC i .DOCX za pomocą biblioteki IronWord, co umożliwia przetwarzanie i wyświetlanie tych dokumentów w twojej aplikacji ASP.NET Core.

W jaki sposób JavaScript jest używany do ulepszenia aplikacji przetwarzającej dokumenty?

JavaScript jest używany do obsługi przesyłania plików, wysyłania żądań AJAX do serwera w celu przetworzenia dokumentu za pomocą IronWord oraz aktualizacji interfejsu użytkownika przetworzoną zawartością lub komunikatami o błędach, zapewniając płynne doświadczenie użytkownika.

Jakie są wymagania wstępne do rozwoju aplikacji przetwarzającej dokumenty Word w ASP.NET Core?

Aby rozwijać aplikację przetwarzającą dokumenty Word w ASP.NET Core, potrzebujesz podstawowej wiedzy na temat C# i ASP.NET Core, Visual Studio 2019 lub nowsze, lub Visual Studio Code z rozszerzeniem C#, oraz zainstalowany .NET Core SDK 3.1 lub nowszy.

Jak można zaprojektować interfejs użytkownika dla lepszego przetwarzania dokumentów?

Interfejs użytkownika można zaprojektować z obszarem przesyłania do wyboru dokumentów Word i obszarem wyświetlania zawartości do pokazywania przetworzonych treści. Niestandardowe CSS można użyć do ulepszenia projektu, aby stworzyć atrakcyjne i przyjazne dla użytkownika doświadczenie.

Jakie są potencjalne zastosowania integracji przetwarzania dokumentów Word w aplikacjach internetowych?

Potencjalne zastosowania to systemy zarządzania dokumentami i generatory raportów, gdzie integracja możliwości przetwarzania dokumentów Word z użyciem IronWord może usprawnić obsługę, edycję i procesy konwersji dokumentów w aplikacji internetowej.

Curtis Chau
Curtis Chau
  Czat z zespołem inżynierów teraz
Autor tekstów technicznych

Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podrę...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespół wsparcia Iron

Jesteśmy online 24 godziny, 5 dni w tygodniu.
Czat
E-mail
Zadzwoń do mnie