Using word in net

В данной статье поработаем с документами docx при помощи C# и библиотеки DocX.

Для примеров я буду использовать обычное консольное приложение. Библиотеку DocX вы можете добавить при помощи NuGet.

Навигация для удобства:

Работа с текстом
Работа со ссылками
Работа с изображениями
Работа с таблицами
Работа с диаграммами
Защита документа

Работа с текстом:

Будет рассмотрена работа с текстом и его форматирование.

using System;
using System.Drawing;
using Xceed.Words.NET;

namespace Word
{
    class Program
    {
        static void Main(string[] args)
        {
            // путь к документу
            string pathDocument = AppDomain.CurrentDomain.BaseDirectory + "example.docx";

            // создаём документ
            DocX document = DocX.Create(pathDocument);

            // Вставляем параграф и указываем текст
            document.InsertParagraph("Тест");

            // вставляем параграф и передаём текст
            document.InsertParagraph("Тест").
                     // устанавливаем шрифт
                     Font("Calibri").
                     // устанавливаем размер шрифта
                     FontSize(36).
                     // устанавливаем цвет
                     Color(Color.Navy).
                     // делаем текст жирным
                     Bold().
                     // устанавливаем интервал между символами
                     Spacing(15).
                     // выравниваем текст по центру
                     Alignment = Alignment.center;

            // вставляем параграф и добавляем текст
            Paragraph paragraph = document.InsertParagraph();
            // выравниваем параграф по правой стороне
            paragraph.Alignment = Alignment.right;

            // добавляем отдельную строку со своим форматированием
            paragraph.AppendLine("Тест").
                     // устанавливаем размер шрифта
                     FontSize(20).
                     // добавляем курсив
                     Italic().
                     // устанавливаем точечное подчёркивание
                     UnderlineStyle(UnderlineStyle.dotted).
                     // устанавливаем цвет подчёркивания
                     UnderlineColor(Color.DarkOrange).
                     // добавляем выделение текста
                     Highlight(Highlight.yellow);
            // добавляем пустую строку
            paragraph.AppendLine();
            // добавляем ещё одну строку
            paragraph.AppendLine("Тест");

            // сохраняем документ
            document.Save();
        }
    }
}

Результат работы:

Работа со ссылками:

Будет рассмотрена работа со ссылкой и минимальное форматирование её отображения.

using System;
using System.Drawing;
using Xceed.Words.NET;

namespace Word
{
    class Program
    {
        static void Main(string[] args)
        {
            // путь к документу
            string pathDocument = AppDomain.CurrentDomain.BaseDirectory + "example.docx";

            // создаём документ
            DocX document = DocX.Create(pathDocument);

            // создаём ссылку
            Hyperlink hyperlinkBlog = 
                    document.AddHyperlink("progtask.ru", new Uri("https://progtask.ru"));

            // создаём параграф
            Paragraph paragraph = document.InsertParagraph();
            // центрируем содержимое
            paragraph.Alignment = Alignment.center;
            // добавляем текст
            paragraph.InsertText("Blog - ");
            // добавляем ссылку
            paragraph.AppendHyperlink(hyperlinkBlog)
                     // меняем цвет
                     .Color(Color.BlueViolet).
                     // устанавливаем вид подчёркивания
                     UnderlineStyle(UnderlineStyle.singleLine).
                     // устанавливаем размер шрифта
                     FontSize(16);

            // сохраняем документ
            document.Save();
        }
    }
}

Результат работы:

Работа с изображениями:

Будет рассмотрена вставка изображения в документ.

using System;
using Xceed.Words.NET;

namespace Word
{
    class Program
    {
        static void Main(string[] args)
        {
            // путь к документу
            string pathDocument = AppDomain.CurrentDomain.BaseDirectory + "example.docx";
            string pathImage = AppDomain.CurrentDomain.BaseDirectory + "image.jpg";

            // создаём документ
            DocX document = DocX.Create(pathDocument);

            // загрузка изображения
            Image image = document.AddImage(pathImage);

            // создание параграфа
            Paragraph paragraph = document.InsertParagraph();
            // вставка изображения в параграф
            paragraph.AppendPicture(image.CreatePicture());
            // выравнивание параграфа по центру
            paragraph.Alignment = Alignment.center;

            // сохраняем документ
            document.Save();
        }
    }
}

Результат работы:

Работа с таблицами:

Будет рассмотрен простой пример таблицы.

using System;
using System.Drawing;
using Xceed.Words.NET;

namespace Word
{
    class Program
    {
        static void Main(string[] args)
        {
            // путь к документу
            string pathDocument = AppDomain.CurrentDomain.BaseDirectory + "example.docx";

            // создаём документ
            DocX document = DocX.Create(pathDocument);

            // создаём таблицу с 3 строками и 2 столбцами
            Table table = document.AddTable(3, 2);
            // располагаем таблицу по центру
            table.Alignment = Alignment.center;
            // меняем стандартный дизайн таблицы
            table.Design = TableDesign.TableGrid;

            // заполнение ячейки текстом
            table.Rows[0].Cells[0].Paragraphs[0].Append("Тест");
            // заполнение ячейки ссылкой
            Hyperlink hyperlinkBlog =
                    document.AddHyperlink("progtask.ru", new Uri("https://progtask.ru"));

            table.Rows[0].Cells[1].Paragraphs[0].AppendHyperlink(hyperlinkBlog).
                                                 UnderlineStyle(UnderlineStyle.singleLine);

            // объединяем 2 ячейки
            table.Rows[1].MergeCells(0, 1);
            // заполняем полученную ячейку
            table.Rows[1].Cells[0].Paragraphs[0].Append("Тест").
                                            // устанавливаем размер текста
                                            FontSize(26).
                                            // выравниваем текст по центру ячейки
                                            Alignment = Alignment.center;

            // заполняем ячейку, меняя цвет текста и его размер
            table.Rows[2].Cells[0].Paragraphs[0].Append("Тест").
                                                 Color(Color.Green).
                                                 FontSize(20);
            // удаляем ячейку
            table.DeleteAndShiftCellsLeft(2, 1);

            // создаём параграф и вставляем таблицу
            document.InsertParagraph().InsertTableAfterSelf(table);

            // сохраняем документ
            document.Save();
        }
    }
}

Результат работы:

Работа с диаграммами:

Будут рассмотрены линейная, круговая и столбцовая диаграммы.

using System;
using System.Collections.Generic;
using Xceed.Words.NET;

namespace Word
{
    class Program
    {
        static void Main(string[] args)
        {
            // путь к документу
            string pathDocument = AppDomain.CurrentDomain.BaseDirectory + "example.docx";

            // создаём документ
            DocX document = DocX.Create(pathDocument);

            // добавляем линейную диаграмму
            document.InsertChart(CreateLineChart());
            // добавляем круговую диаграмму
            document.InsertChart(CreatePieChart());
            // добавляем столбцовую диаграмму
            document.InsertChart(CreateBarChart());
            // добавляем столбцовую диаграмму с 3d эффектом
            document.InsertChart(Create3DBarChart());

            // сохраняем документ
            document.Save();
        }

        private static Chart CreateLineChart()
        {
            // создаём линейную диаграмму
            LineChart lineChart = new LineChart();
            // добавляем легенду вниз диаграммы
            lineChart.AddLegend(ChartLegendPosition.Bottom, false);

            // создаём набор данных и добавляем на диаграмму
            lineChart.AddSeries(TestData.GetSeriesFirst());
            // добавляем ещё один набор
            lineChart.AddSeries(TestData.GetSeriesSecond());

            return lineChart;
        }

        private static Chart CreatePieChart()
        {
            // создаём круговую диаграмму
            PieChart pieChart = new PieChart();
            // добавляем легенду слева от диаграммы
            pieChart.AddLegend(ChartLegendPosition.Left, false);

            // создаём набор данных и добавляем на диаграмму
            pieChart.AddSeries(TestData.GetSeriesFirst());

            return pieChart;
        }

        private static Chart CreateBarChart()
        {
            // создаём столбцовую диаграмму
            BarChart barChart = new BarChart();
            // отображаем легенду сверху диаграммы
            barChart.AddLegend(ChartLegendPosition.Top, false);

            // создаём набор данных и добавляем в диаграмму
            barChart.AddSeries(TestData.GetSeriesFirst());
            // создаём набор данных и добавляем в диаграмму
            barChart.AddSeries(TestData.GetSeriesSecond());

            return barChart;
        }

        private static Chart Create3DBarChart()
        {
            // создаём столбцовую диаграмму
            BarChart barChart = new BarChart();
            // отображаем легенду снизу диаграммы
            barChart.AddLegend(ChartLegendPosition.Bottom, false);
            // добавление 3D эффекта
            barChart.View3D = true;

            // создаём набор данных и добавляем в диаграмму
            barChart.AddSeries(TestData.GetSeriesFirst());
            // создаём набор данных и добавляем в диаграмму
            barChart.AddSeries(TestData.GetSeriesSecond());

            return barChart;
        }
    }

    // класс с тестовыми данными
    class TestData
    {
        public string name { get; set; }
        public int value { get; set; }

        private static List<TestData> GetTestDataFirst()
        {
            List<TestData> testDataFirst = new List<TestData>();

            testDataFirst.Add(new TestData() { name = "1", value = 1 });
            testDataFirst.Add(new TestData() { name = "10", value = 10 });
            testDataFirst.Add(new TestData() { name = "5", value = 5 });
            testDataFirst.Add(new TestData() { name = "8", value = 8 });
            testDataFirst.Add(new TestData() { name = "5", value = 5 });

            return testDataFirst;
        }

        private static List<TestData> GetTestDataSecond()
        {
            List<TestData> testDataSecond = new List<TestData>();

            testDataSecond.Add(new TestData() { name = "12", value = 12 });
            testDataSecond.Add(new TestData() { name = "3", value = 3 });
            testDataSecond.Add(new TestData() { name = "8", value = 8 });
            testDataSecond.Add(new TestData() { name = "15", value = 15 });
            testDataSecond.Add(new TestData() { name = "1", value = 1 });

            return testDataSecond;
        }

        public static Series GetSeriesFirst()
        {
            // создаём набор данных
            Series seriesFirst = new Series("First");
            // заполняем данными
            seriesFirst.Bind(TestData.GetTestDataFirst(), "name", "value");
            return seriesFirst;
        }

        public static Series GetSeriesSecond()
        {
            // создаём набор данных
            Series seriesSecond = new Series("Second");
            // заполняем данными
            seriesSecond.Bind(TestData.GetTestDataSecond(), "name", "value");
            return seriesSecond;
        }
    }
}

Результат работы:

Защита документа:

Установим ограничение документу только для чтения. Для снятия его необходимо будет ввести пароль, который мы установим.

using System;
using System.Drawing;
using Xceed.Words.NET;

namespace Word
{
    class Program
    {
        static void Main(string[] args)
        {
            // путь к документу
            string pathDocument = AppDomain.CurrentDomain.BaseDirectory + "example.docx";
            const string password = "password";

            // создаём документ
            DocX document = DocX.Create(pathDocument);
            // делаем документ, который будет доступен только для чтения
            // для снятия защиты нужно будет ввести пароль
            // если нужно ограничить доступ без пароля, используйте метод AddProtection
            document.AddPasswordProtection(EditRestrictions.readOnly, password);

            // сохраняем документ
            document.Save();
        }
    }
}

Загрузка…

Источник

Microsoft provide a free set of interop assemblies for interacting with the various Office file formats in .NET, the download locations differ depending on which version of Office you are using but a Google search for «Microsoft Office Primary Interop Assemblies» will yield the links for various versions from MSDN such as this one for Office 2007.

As for how to open a Word document (doc or docx) using these interops the following snippet shows how to open a Word document:

_Application WordApp = new Microsoft.Office.Interop.Word.Application();

  object WordFile = "C:\SomeDoc.doc";
  object RdOnly = false;
  object Visible = true;
  object Missing = System.Reflection.Missing.Value;
  Document Doc = WordApp.Documents.Open(ref WordFile, ref Missing, ref RdOnly, ref Missing, ref Missing, 
                                        ref Missing, ref Missing, ref Missing, ref Missing, ref Missing, 
                                        ref Missing, ref Visible, ref Missing, ref Missing, ref Missing, 
                                        ref Missing);

From there you can use Doc to access various parts of the document.

Источник

Table of Contents

Introducing Interop.Word
Working with the Document
- Find and Replace Text
- Find and replace Bookmarks
- Convert a DOC / DOCX file to PDF
- Export a DOC / DOCX file into a PDF
From a Byte Array

If you’re working with ASP.NET C# and you need to open, edit or otherwise access a Microsoft Word DOC or DOCX file, you can easily do that using the Microsoft.Office.Interop.Word library package. This post explains how to do so: you might find it useful in case you need to perform such task or whenever you want to read some insights regarding the process.

Introducing Interop.Word

To access the namespace from your ASP.NET project you have two main choices:

Install the official Microsoft Office primary interop assemblies (PIAs) package on your machine by downloading and executing the runtime installer, then manually add a Reference to the Microsoft.Office.Interop.Word.dll file.
Install the appropriate NuGet package within Visual Studio using the Package Manager Console.

Needless to say, you should really go for the second option, but we’ll leave that to you.

Working with the Document

As soon as you have the namespace available, you can do the following:

// NS alias to avoid writing the required namespace all the time

using word = Microsoft.Office.Interop.Word;

// […]

Application app = new word.Application();

Document doc = app.Documents.Open(filePath);

Once you have the app and the doc objects you can perform a lot of editing task, such as:

Find and Replace Text

var textToFind = «any source text»;

var textToReplace = «any replacement text»;

var matchCase = true;

var matchWholeWord = true;

var matchWildcards = false;

var matchSoundsLike = false;

var matchAllWordForms = false;

var forward = true;

var wrap = 1;

var format = false;

var replace = 2;

app.Selection.Find.Execute(

textToFind,

matchCase,

matchWholeWord,

matchWildcards,

matchSoundsLike,

matchAllWordForms,

forward,

wrap,

format,

textToReplace,

replace);

Find and replace Bookmarks

var bookmarkName = «anyName»;

var bookmarkNewValue = «anyValue»;

if (doc.Bookmarks.Exists(bookmarkName)) {

doc.Bookmarks[bookmarkName].Select();

app.Selection.TypeText(bookmarkNewValue);

}

Convert a DOC / DOCX file to PDF

Surprisingly enough, we can even do that with an one-liner thanks to the native «Save As PDF…» feature introduced with Office 2010.

doc.SaveAs2(«path-to-pdf-file.pdf», word.WdSaveFormat.wdFormatPDF);

Export a DOC / DOCX file into a PDF

This one is almost identical to the previous one in terms of results.

doc.ExportAsFixedFormat(tmpFile, WdExportFormat.wdExportFormatPDF);

… and so on.

For additional info regarding word-to-pdf conversion, you can also read this dedicated post: otherwise, keep reading.

What if you have the DOC or DOCX file stored outside the FileSystem, such as in blob-format within a Database? If that’s the case you need to use a temporary file, because most Office Interop methods do not support working with byte arrays, streams and so on.

Here’s a decent workaround you can use:

// byte[] fileBytes = getFileBytesFromDB();

var tmpFile = Path.GetTempFileName();

File.WriteAllBytes(tmpFile, fileBytes);

Application app = new word.Application();

Document doc = app.Documents.Open(filePath);

// .. do your stuff here …

doc.Close();

app.Quit();

byte[] newFileBytes = File.ReadAllBytes(tmpFile);

File.Delete(tmpFile);

You might notice that we used the

Close()

method in order to close (and thus save) the file. In case you wan’t to save your changes to the DOC / DOCX file you opened, you need to explicitly say it by adding the

WdSaveOptions.wdDoNotSaveChanges

object parameter in the following way:

doc.Close(word.WdSaveOptions.wdDoNotSaveChanges);

IMPORTANT: Do not underestimate the call to

app.Quit()

! If you don’t do that, the MS Word instance will be left open on your server (see this thread on StackOverflow for more info on that issue). If you want to be sure to avoid such dreadful scenario entirely you should strengthen the given implementation adding a try/catch fallback strategy such as the follow:

Application app = null;

Document doc = null;

try

{

app = new word.Application();

doc = Document doc = app.Documents.Open(filePath);

// .. do your stuff here …

doc.Close();

app.Quit();

}

catch (Exception e)

{

if (doc != null) doc.Close();

if (app != null) app.Quit();

}

Unfortunately these objects don’t implement IDisposable, otherwise it would’ve been even easier.

That’s pretty much it: happy coding!

Источник

In previous article, I have mentioned to convert HTML to word document using javascript, now in this article, I have provided working example to create word document or you can say generate word document using DocX library in C#, step by step.

Step 1: We will create a new console application using which we will generate our word document, so Open your Visual Studio and create a new console application by navigating to File-> New -> Project -> Select «Windows desktop» from left pane and Select «Console Application» from right-pane, then name it and Click «Ok».

Step 2: Install DocX library in your console application, using NuGet, navigate to «Tools» -> «NuGet Package Manager console» -> «Manage Nuget Packages for solution «-> Select «Browse» tab and search «DocX», select it and Install it in your project.

Note: DocX is free to use, .NET library that allows developers to manipulate Microsoft Word files, in an easy and intuitive manner. DocX is fast, lightweight and best of all it does not require Microsoft Word or Office to be installed.

Step 3: Navigate to «Program.cs» to use below code


using Xceed.Document.NET;
using Xceed.Words.NET;

namespace CreateWordDocument
{
    class Program
    {
        static void Main(string[] args)
        {
            string fileName = @"E:DocxExamplesampleWordFile.docx";

            var doc = DocX.Create(fileName); //create docx word document

            doc.AddHeaders(); //add header (optional)
            doc.AddFooters(); //add footer in this document (optional code)

            // Force the first page to have a different Header and Footer.
            doc.DifferentFirstPage = true;

            doc.Headers.First.InsertParagraph("This is the ").Append("first").Bold().Append(" page header");// Insert a Paragraph into the first Header.
            doc.Footers.First.InsertParagraph("Page ").AppendPageNumber(PageNumberFormat.normal).Append(" of ").AppendPageCount(PageNumberFormat.normal); // add footer with page number

            doc.InsertParagraph("Hello Word"); // inserts a new paragraph with text

            doc.Save(); // save changes to file
        }
    }
}

In the above code, we are first creating a fileName and then creating .docx word document using DocX NuGet Package.

We are also adding header and footer in the document, this is optional code and we can skip it, but for example purpose I have added the code.

And we are simply adding a paragraph here, then saving the document using «doc.Save()».

Once you will build and run the above code, you can see a new word document is created and can be viewed in your file location ‘E:DocxExamplesampleWordFile.docx’

Here is the document created using above code

Adding Images in Word Document using DocX in C#

In the above code, we are just adding header/footer and a simple paragraph, if you want you can also add a image file into word document using DocX, here is the sample code for it.


using System.IO;
using Xceed.Document.NET;
using Xceed.Words.NET;

namespace CreateWordDocument
{
    class Program
    {
        static void Main(string[] args)
        {
            string fileName = @"E:DocxExamplesampleWordFile.docx";

            var doc = DocX.Create(fileName); //create docx word document

            var url = System.AppContext.BaseDirectory; //return /bin/debug location

            // Add a simple image from disk.
            var image = doc.AddImage(new FileStream(url + "/sample-image.jpg", FileMode.Open, FileAccess.Read) );
            var picture = image.CreatePicture(200f,200f);
            var p = doc.InsertParagraph("Here is a simple picture added from disk");
            p.AppendPicture(picture);



            doc.Save(); // save changes to file
        }
    }
}

once, you will build and run above code in your console application, you will see word document as below

Add table content to Word document using DocX in C#

If you want you can also create table inside word document using DocX, so here is the sample code for it in C#

using System.IO;
using System.Linq;
using Xceed.Document.NET;
using Xceed.Words.NET;

namespace CreateWordDocument
{
    class Program
    {
        static void Main(string[] args)
        {
            string fileName = @"E:DocxExamplesampleWordFile.docx";

            var doc = DocX.Create(fileName);

            //Create Table with 2 rows and 4 columns.  
            Table t = doc.AddTable(2, 4);
            t.Alignment = Alignment.center; //align center

            //Fill first row adding text in four column
            t.Rows[0].Cells[0].Paragraphs.First().Append("AA");
            t.Rows[0].Cells[1].Paragraphs.First().Append("BB");
            t.Rows[0].Cells[2].Paragraphs.First().Append("CC");
            t.Rows[0].Cells[3].Paragraphs.First().Append("DD");

            //second row by adding text in four column
            t.Rows[1].Cells[0].Paragraphs.First().Append("EE");
            t.Rows[1].Cells[1].Paragraphs.First().Append("FF");
            t.Rows[1].Cells[2].Paragraphs.First().Append("GG");
            t.Rows[1].Cells[3].Paragraphs.First().Append("HH");
            //insert table in doc
            doc.InsertTable(t);

            doc.Save(); // save changes to file
        }
    }
}

In the above code, we are first creating table of 2 Rows and 4 Columns, then filling columns row by row using C#.

You may also like to read:

Read Excel using C#

Read PDF using C#

Read text file using C#

Create excel in C# without using interop

Источник

The C# programming language includes capabilities that make working with Microsoft Office API objects easier. With the advent of named and optional arguments, introduction of the dynamic type in .NET, and the ability to pass arguments to the reference parameters in COM methods, C# 4.0 quickly became the language of choice for working with COM and Interop objects.

This article talks about office interop objects in C# and how you can use them to interact with Microsoft Word and Microsoft Excel. Code examples are also provided to illustrate the concepts covered.

Prerequisites for working with Interop Objects

Visual Studio 2019 or Visual Studio 2022 must be installed on your computer to work with the code samples demonstrated in this C# tutorial. In this example, we will be using Visual Studio 2022. If you don’t have it installed in your computer, you can download it from here.

As of this writing, Visual Studio 2022 RC 2 has been released. You should also have Microsoft Office Excel 2007 or Microsoft Office Word 2007 (or their later versions) installed on your computer.

Read: Code Refactoring Tips for C#.

How to Create a New Console Application in Visual Studio

In this section we will examine how we can create a new console application project in Visual Studio 2022. Assuming Visual Studio 2022 is installed on your system, adhere to the steps given below to create a new Console Application project:

Start the Visual Studio 2022 IDE.
Click on “Create new project.”
In the “Create new project” page, select C# in the language drop down list, Windows from the Platforms list and Console from the “Project types” list.
Select Console App (.NET Framework) from the project templates displayed.

Create New Project in Visual Studio

Click Next.
In the “Configure your new project” screen, specify the project’s name and the location where you would want the project to be created.
Before you move on to the next screen, you can optionally select the “Place solution and project in the same directory” checkbox.

Configure Visual Studio Projects

Click Next.
In the Additional Information screen, specify the Framework version you would like to use. We will use .NET Framework 4.8 in this example.

Configure VS Projects

Click Create to complete the process.

This will create a new .NET Framework Console application project in Visual Studio 2022. We will use this project in the sections that follow.

Install NuGet Packages

Install the following libraries from NuGet using the NuGet Package Manager or from the NuGet Package Manager Console:

Microsoft.Office.Interop.Word
Microsoft.Office.Interop.Excel

Read: Working with C# Math Operators.

How to Program Office Interop Objects in C#

In this section we will examine how to work with Office Interop objects and use them to connect to Microsoft Word and Excel and read/write data.

You must add the following using directives in your program for working with Word and Excel respectively when using Office interop objects:

using Microsoft.Office.Interop.Excel;
using Microsoft.Office.Interop.Word;

Working with Excel Interop Objects in C#

To begin, create a new Excel document named Test.xslx as a sample Excel file present in the root directory of the D:> drive. We will use this file in the following example.

You should create an instance of the Application class pertaining to the Microsoft.Office.Interop.Excel library for communicating with Excel. To do this, write the following C# code:

Application excelApplication = new Application();

The next step is to create an instance of the Workbook class to access a Workbook in Excel. You can create an instance of Workbook using the following code:

Workbook excelWorkBook = excel.Workbooks.Open(@"D:Test.xslx");

To read the name of the workbook, you can use the Name property of the workbook instance as shown in the code snippet given below:

string workbookName = excelWorkBook.Name;

The following code listing illustrates how you can display the value of the first cell of the first worksheet of the Excel document:

int worksheetcount = excelWorkBook.Worksheets.Count;
if (worksheetcount > 0) {
  Worksheet worksheet = (Worksheet) excelWorkBook.Worksheets[1];
  string worksheetName = worksheet.Name;
  var data = ((Range) worksheet.Cells[row, column]).Value;
  Console.WriteLine(data);
} else {
  Console.WriteLine("No worksheets available");
}

Here’s the complete code listing for your reference:

using Microsoft.Office.Interop.Excel;
using Microsoft.Office.Interop.Word;
using System;
using System.Runtime.InteropServices;

namespace OfficeInteropDemoApp
{
    class Program
    {
        static void Main(string[] args)
        {
            string filename = @"D:Test.xlsx";
            DisplayExcelCellValue(filename, 1, 1);
            Console.Read();
        }

        static void DisplayExcelCellValue(string filename, 
        int row, int column)
        {
            Microsoft.Office.Interop.Excel.Application 
            excelApplication = null;
            try
            {
                excelApplication = new 
                Microsoft.Office.Interop.Excel.Application();
                Workbook excelWorkBook = 
                excelApplication.Workbooks.Open(filename);
                string workbookName = excelWorkBook.Name;
                int worksheetcount = excelWorkBook.Worksheets.Count;

                if (worksheetcount > 0)
                {
                    Worksheet worksheet = 
                   (Worksheet)excelWorkBook.Worksheets[1];
                    string firstworksheetname = worksheet.Name;
                    var data = ((Microsoft.Office.Interop.Excel.Range)
                    worksheet.Cells[row, column]).Value;
                    Console.WriteLine(data);
                }
                else
                {
                    Console.WriteLine("No worksheets available");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                if (excelApplication != null)
                {
                    excelApplication.Quit();
                    Marshal.FinalReleaseComObject(excelApplication);
                }
            }
        }
    }
}

Refer to the code listing given above. Note, the finally block of the DisplayExcelCellValue method. The Quit method is called on the Excel application instance to stop the application. Finally, a call to Marshall.FinalReleaseComObject sets the reference counter of the Excel application instance to 0.

The following code listing illustrates how you can create a new Excel document using Office Interop in C#. Note how a new workbook has been created:

static void CreateExcelDocument() 
{
	Microsoft.Office.Interop.Excel.Application excelApplication = null;

	try {
		excelApplication = new 
            Microsoft.Office.Interop.Excel.Application();
		Workbook excelWorkBook = excelApplication.Workbooks.Add();
		Worksheet worksheet = (Worksheet) excelWorkBook.Worksheets[1];
		worksheet.Cells[1, 1] = "Product Id";
		worksheet.Cells[1, 2] = "Product Name";
		worksheet.Cells[2, 1] = "1";
		worksheet.Cells[2, 2] = "Lenovo Laptop";
		worksheet.Cells[3, 1] = "2";
		worksheet.Cells[3, 2] = "DELL Laptop";
		excelWorkBook.SaveAs(@"D:Test.xls");
	}
	catch(Exception ex) {
		Console.WriteLine(ex.Message);
	}
	finally {
		if (excelApplication != null) {
			excelApplication.Quit();
			Marshal.FinalReleaseComObject(excelApplication);
		}
	}
}

When you run this code, a new Excel document will be created at the path specified with the following content inside:

C# Interop Objects Tutorial

Read: Working with Strings in C#.

Working with Word Interop Objects in C#

To work with Microsoft Word, you would need to create an instance of Microsoft.Office.Interop.Word.Application. Like Excel, this instance would be used to communicate with a Word document.

Microsoft.Office.Interop.Word.Application wordApplication = new Microsoft.Office.Interop.Word.Application();

The next step is to create a document instance using the Documents property of the Microsoft.Office.Interop.Word.Application instance we just created, as shown in the C# code snippet given below:

wordApplication.Documents.Add();

Next, you can create a paragraph and add some text to it using the as shown in the code snippet shown below:

var paragraph = document.Paragraphs.Add();
paragraph.Range.Text = "This is a sample text to demonstrate how Interop works...";

Then you can save the Word document using this code:

wordApplication.ActiveDocument.SaveAs(@"D:Test.doc", WdSaveFormat.wdFormatDocument);

Here is the complete code listing showing how to work with Microsoft Word Interop Objects in C# for your reference:

using Microsoft.Office.Interop.Excel;
using Microsoft.Office.Interop.Word;
using System;
using System.Runtime.InteropServices;

namespace OfficeInteropDemoApp
{
    class Program
    {
        static void Main(string[] args)
        {
            string filename = @"D:Test.doc";
            CreateWordDocument(filename);
            Console.Read();
        }

        static void CreateWordDocument(string filename)
        {
            Microsoft.Office.Interop.Word.Application 
            wordApplication = null;
            try
            {
                wordApplication = new 
                Microsoft.Office.Interop.Word.Application();
                var document = wordApplication.Documents.Add();
                var paragraph = document.Paragraphs.Add();
                paragraph.Range.Text = "This is a sample text to 
                demonstrate how Interop works...";
                wordApplication.ActiveDocument.SaveAs(filename, 
                WdSaveFormat.wdFormatDocument);
                document.Close();

            }
            finally
            {
                if (wordApplication != null)
                {
                    wordApplication.Quit();
                    Marshal.FinalReleaseComObject(wordApplication);
                }
            }
        }
    }
}

To read a Word document and display each word of the document you can use the following C# code:

static void ReadWordDocument(string filename)
        {
            Microsoft.Office.Interop.Word.Application 
            wordApplication = null;
            try
            {
                wordApplication = new 
                Microsoft.Office.Interop.Word.Application();
                Document document = 
                wordApplication.Documents.Open(filename);

                int count = document.Words.Count;
                for (int i = 1; i <= count; i++)
                {
                    string text = document.Words[i].Text;
                    Console.WriteLine(text);
                }
            }
            catch(Exception ex)
            {
                Console.Write(ex.Message);
            }
            finally
            {
                if (wordApplication != null)
                {
                    wordApplication.Quit();
                    Marshal.FinalReleaseComObject(wordApplication);
                }
            }
        }

Note how the Words property of the Word application instance has been used to retrieve the words contained in the document.

C# Interop Objects Tutorial

In this article we have examined how we can access Microsoft Office Interop objects using C#. Since there is still no support for working with Interop objects in .NET Core, we have created a .NET Framework Console Application in this example.

Источник

<< Back to C-SHARP

Use Microsoft.Office.Interop.Word. Open a DOC file and read the text in it.

Microsoft Word can be used with C# code. You have a Microsoft Word document (.doc) and want to read it in your C# program. With the Microsoft.Office.Interop.Word assembly, we get the contents and formatting from the document.

Tip: Add the Microsoft.Office.Interop.Word assembly to your project. Go to Project -> Add Reference.

Example. First, we show the file we will read. It contains three paragraphs containing one word each. The program first instantiates an Application instance and then we call Documents.Open on that variable.

Next: We loop through the Words collection and read the Text property on each element. We then display and call Quit.

Word document: word.doc

One

Two

three

C# program that uses Microsoft Word interop

using System;
using Microsoft.Office.Interop.Word;

class Program
{
static void Main()
{
// Open a doc file.
Application application = new Application();
Document document = application.Documents.Open(«C:\word.doc»);

// Loop through all words in the document.
int count = document.Words.Count;
for (int i = 1; i <= count; i++)
{
// Write the word.
string text = document.Words[i].Text;
Console.WriteLine(«Word {0} = {1}», i, text);
}
// Close word.
application.Quit();
}
}

Output

Word 1 = One
Word 2 =
Word 3 = Two
Word 4 =
Word 5 = three
Word 6 =

Empty paragraphs. We see that Word 2, Word 4, and Word 6 are empty. The empty paragraphs in the input file are considered words. If you have multiple words in a paragraph, they will each be separate in the Words collection.

So: In Interop.Word, a paragraph is made up of a collection of one or more words.

Quit. Why is the application.Quit statement important? If you don’t include this, the WINWORD.EXE application will remain in the process list. Then, when this program is run again, a new one will be started. This wastes memory.

Note: It is important to iterate on Words from 1 to Count inclusive. Correction suggested by Robert Ford.

Summary. We looked at the Microsoft.Office Interop.Word assembly and learned how to read in data from a Word document. This can be useful when you have DOC or DOCX files and want to programmatically read in data from your C# program.

Навигация для удобства:

Работа с текстом:

Работа со ссылками:

Работа с изображениями:

Работа с таблицами:

Работа с диаграммами:

Защита документа:

Introducing Interop.Word

Working with the Document

Find and Replace Text

Find and replace Bookmarks

Convert a DOC / DOCX file to PDF

Export a DOC / DOCX file into a PDF

Adding Images in Word Document using DocX in C#

Add table content to Word document using DocX in C#

Prerequisites for working with Interop Objects

How to Create a New Console Application in Visual Studio

Install NuGet Packages

How to Program Office Interop Objects in C#

Working with Excel Interop Objects in C#

Working with Word Interop Objects in C#

C# Interop Objects Tutorial

Related Links:

Related Links