Документ open xml microsoft excel

Время на прочтение
13 мин

Количество просмотров 50K

Решил написать статью, о том, как сделать выгрузку данных в Excel файл по шаблону и считывать данные из Excel.
Началось всё с того, что на работе, дали указание, уйти от MS Office, на бесплатные аналоги.
У нас уже была система выгрузки, основанная на библиотеке “Microsoft.Office. Interop.Excel” и много готовых шаблонов, для выгрузки тех или иных отчётов.
Поэтому надо было найти бесплатную библиотеку, работающую с офисом. И сделать так, чтоб выгрузка работала по той же системе, что и раньше. Ибо переделывать все шаблоны и структуру, не хотелось.
Вот я и наткнулся на OpenXML. И думал, сейчас по быстрому найду решение в интернете и всё готово (т.к. на это было выделено мало времени). Но подходящего решения так и не нашёл, поэтому и решил написать эту статью, для тех у кого будет, такая же проблема.
Саму библиотеку, можно скачать бесплатно с сайта Micrisoft (я использовал в проекте OpenXML sdk 2.5 “ OpenXMLSDKV25.msi ”)
здесь.
После скачивания “OpenXMLSDKV25.msi ”, устанавливаем и заходим в папку
“C:Program FilesOpen XML SDKV2.5lib” там лежит библиотека, которая нам понадобится, мы её подключим к проекту (ниже будет описано, как).
Проект был написан на Visual Studio 2010 (Framework 4.0).
Ниже пример шаблона (сделан для теста) “C:Templatestemplate.xlsx”.

И пример выгруженных данных (как это будет выглядеть в итоге, после выгрузки).

Ключевые слова:
DataField: — Означает, что на этом месте будут выведены наши банные из DataTable.
DataField:[название выводимого поля]
Label: — Означает, что на этом месте будут выводиться данные, которые надо вставить однократно из словаря
Label:[название ключа в словаре]
А это файл из которого мы будем считывать данные “C:LoadingReadMePlease.xlsx”.

Теперь создадим в VS2010, Решение в котором будет 4 проекта:
1) OpenXmlPrj – это консольный проект, для запуска теста.
2) Interfaces – это проект типа “Библиотека классов”, будет хранить наши интерфейсы данных для выгрузки.
3) Framework — это проект типа “Библиотека классов”, тут и будет происходить вся работа с Excel-ем.
4) Converter — это проект типа “Библиотека классов”, для конвертирования наших данных в DataTable (т.к. работа происходит с DataTable).

Теперь в проекте “Framework” создаём две папки и подключим ссылку на библиотеку OpenXML и WindowsBase:
“Create” – для работы с выгрузкой данных.
“Load” – для работы с загрузкой данных.
“lib” – в папку, добавим библиотеку OpenXML.
В папке “Create” создаём 4 класса.
1) Worker – это будет наш главный обработчик.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Spreadsheet;

namespace Framework.Create
{
    /// <summary>
    /// Создание Excel файла
    /// </summary>
    public class Worker
    {
        /// <summary>
        /// путь к папке с шаблонами 
        /// </summary>
        private const String TemplateFolder = "C:\Templates\";

        /// <summary>
        /// имя листа шаблона (с которым мы будем работать) 
        /// </summary>
        private const String SheetName = "Лист1";

        /// <summary>
        /// тип документа
        /// </summary>
        private const String FileType = ".xlsx";

        /// <summary>
        /// Папка, для хранения выгруженных файлов
        /// </summary>
        public static String Directory
        {
            get
            {
                const string excelFilesPath = @"C:xlsx_repository";
                if (System.IO.Directory.Exists(excelFilesPath) == false)
                {
                    System.IO.Directory.CreateDirectory(excelFilesPath);
                }

                return excelFilesPath;
            }
        }

        public void Export(System.Data.DataTable dataTable, System.Collections.Hashtable hashtable, String templateName)
        {
            var filePath = CreateFile(templateName);

            OpenForRewriteFile(filePath, dataTable, hashtable);

            OpenFile(filePath);
        }

        private String CreateFile(String templateName)
        {
            var templateFelePath = String.Format("{0}{1}{2}", TemplateFolder, templateName, FileType);
            var templateFolderPath = String.Format("{0}{1}", Directory, templateName);
            if (!File.Exists(String.Format("{0}{1}{2}", TemplateFolder, templateName, FileType)))
            {
                throw new Exception(String.Format("Не удалось найти шаблон документа n"{0}{1}{2}"!", TemplateFolder, templateName, FileType));
            }

            //Если в пути шаблона (в templateName) присутствуют папки, то при выгрузке, тоже создаём папки
            var index = (templateFolderPath).LastIndexOf("\", System.StringComparison.Ordinal);
            if (index > 0)
            {
                var directoryTest = (templateFolderPath).Remove(index, (templateFolderPath).Length - index);
                if (System.IO.Directory.Exists(directoryTest) == false)
                {
                    System.IO.Directory.CreateDirectory(directoryTest);
                }
            }

            var newFilePath = String.Format("{0}_{1}{2}", templateFolderPath, Regex.Replace((DateTime.Now.ToString(CultureInfo.InvariantCulture)), @"[^a-z0-9]+", ""), FileType);
            File.Copy(templateFelePath, newFilePath, true);
            return newFilePath;
        }

        private void OpenForRewriteFile(String filePath, System.Data.DataTable dataTable, System.Collections.Hashtable hashtable)
        {
            Row rowTemplate = null;
            var footer = new List<Footer>();
            var firsIndexFlag = false;
            using (var document = SpreadsheetDocument.Open(filePath, true))
            {
                Sheet sheet;
                try
                {
                    sheet = document.WorkbookPart.Workbook.GetFirstChild<Sheets>().Elements<Sheet>().SingleOrDefault(s => s.Name == SheetName);
                }
                catch (Exception ex)
                {
                    throw new Exception(String.Format("Возможно в документе существует два листа с названием "{0}"!n",SheetName), ex);
                }

                if (sheet == null)
                {
                    throw new Exception(String.Format("В шаблоне не найден "{0}"!n",SheetName));
                }

                var worksheetPart = (WorksheetPart)document.WorkbookPart.GetPartById(sheet.Id.Value);
                var sheetData = worksheetPart.Worksheet.GetFirstChild<SheetData>();

                var rowsForRemove = new List<Row>();
                var fields = new List<Field>();
                foreach (var row in worksheetPart.Worksheet.GetFirstChild<SheetData>().Elements<Row>())
                {
                    var celsForRemove = new List<Cell>();
                    foreach (var cell in row.Descendants<Cell>())
                    {
                        if (cell == null)
                        {
                            continue;
                        }

                        var value = GetCellValue(cell, document.WorkbookPart);
                        if (value.IndexOf("DataField:", StringComparison.Ordinal) != -1)
                        {
                            if (!firsIndexFlag)
                            {
                                firsIndexFlag = true;
                                rowTemplate = row;
                            }
                            fields.Add(new Field(Convert.ToUInt32(Regex.Replace(cell.CellReference.Value, @"[^d]+", ""))
                                , new string(cell.CellReference.Value.ToCharArray().Where(p => !char.IsDigit(p)).ToArray())
                                , value.Replace("DataField:", "")));

                        }

                        if (value.IndexOf("Label:", StringComparison.Ordinal) != -1 && rowTemplate == null)
                        {
                            var labelName = value.Replace("Label:", "").Trim();
                            if (!hashtable.ContainsKey(labelName))
                            {
                                throw new Exception(String.Format("Нет такого лэйбла "{0}"", labelName));
                            }
                            cell.CellValue = new CellValue(hashtable[labelName].ToString());
                            cell.DataType = new EnumValue<CellValues>(CellValues.String);

                        }

                        if (rowTemplate == null || row.RowIndex <= rowTemplate.RowIndex || String.IsNullOrWhiteSpace(value))
                        {
                            continue;
                        }
                        var item = footer.SingleOrDefault(p => p._Row.RowIndex == row.RowIndex);
                        if (item == null)
                        {
                            footer.Add(new Footer(row, cell, value.IndexOf("Label:", StringComparison.Ordinal) != -1 ? hashtable[value.Replace("Label:", "").Trim()].ToString() : value));
                        }
                        else
                        {
                            item.AddMoreCell(cell, value.IndexOf("Label:", StringComparison.Ordinal) != -1 ? hashtable[value.Replace("Label:", "").Trim()].ToString() : value);
                        }
                        celsForRemove.Add(cell);
                    }

                    foreach (var cell in celsForRemove)
                    {
                        cell.Remove();
                    }

                    if (rowTemplate != null && row.RowIndex != rowTemplate.RowIndex)
                    {
                        rowsForRemove.Add(row);
                    }
                }

                if (rowTemplate == null || rowTemplate.RowIndex == null || rowTemplate.RowIndex < 0)
                {
                    throw new Exception("Не удалось найти ни одного поля, для заполнения!");
                }

                foreach (var row in rowsForRemove)
                {
                    row.Remove();
                }

                var index = rowTemplate.RowIndex;
                foreach (var row in from System.Data.DataRow item in dataTable.Rows select CreateRow(rowTemplate, index, item, fields))
                {
                    sheetData.InsertBefore(row, rowTemplate);
                    index++;
                }

                foreach (var newRow in footer.Select(item => CreateLabel(item, (UInt32)dataTable.Rows.Count)))
                {
                    sheetData.InsertBefore(newRow, rowTemplate);
                }

                rowTemplate.Remove();
            }
        }

        private Row CreateLabel(Footer item, uint count)
        {
            var row = item._Row;
            row.RowIndex = new UInt32Value(item._Row.RowIndex + (count - 1));
            foreach (var cell in item.Cells)
            {
                cell._Cell.CellReference = new StringValue(cell._Cell.CellReference.Value.Replace(Regex.Replace(cell._Cell.CellReference.Value, @"[^d]+", ""), row.RowIndex.ToString()));
                cell._Cell.CellValue = new CellValue(cell.Value);
                cell._Cell.DataType = new EnumValue<CellValues>(CellValues.String);
                row.Append(cell._Cell);
            }
            return row;
        }

        private Row CreateRow(Row rowTemplate, uint index, System.Data.DataRow item, List<Field> fields)
        {
            var newRow = (Row)rowTemplate.Clone();
            newRow.RowIndex = new UInt32Value(index);

            foreach (var cell in newRow.Elements<Cell>())
            {
                cell.CellReference = new StringValue(cell.CellReference.Value.Replace(Regex.Replace(cell.CellReference.Value, @"[^d]+", ""), index.ToString(CultureInfo.InvariantCulture)));
                foreach (var fil in fields.Where(fil => cell.CellReference == fil.Column + index))
                {
                    cell.CellValue = new CellValue(item[fil._Field].ToString());
                    cell.DataType = new EnumValue<CellValues>(CellValues.String);
                }
            }
            return newRow;
        }


        private string GetCellValue(Cell cell, WorkbookPart wbPart)
        {
            var value = cell.InnerText;

            if (cell.DataType == null)
            {
                return value;
            }
            switch (cell.DataType.Value)
            {
                case CellValues.SharedString:

                    var stringTable = wbPart.GetPartsOfType<SharedStringTablePart>().FirstOrDefault();

                    if (stringTable != null)
                    {
                        value = stringTable.SharedStringTable.ElementAt(int.Parse(value)).InnerText;
                    }
                    break;
            }

            return value;
        }

        private void OpenFile(string filePath)
        {
            if (!File.Exists(filePath))
            {
                throw new Exception(String.Format("Не удалось найти файл "{0}"!", filePath));
            }

            var process = Process.Start(filePath);
            if (process != null)
            {
                process.WaitForExit();
            }
        }
    }
}

2) Footer – будет содержать строки и их ячейки идущие после наших данных.

using System;
using System.Collections.Generic;
using DocumentFormat.OpenXml.Spreadsheet;
namespace Framework.Create
{
    public class Footer
    {
        /// <summary>
        /// строка
        /// </summary>
        public Row _Row { get; private set; }
        /// <summary>
        /// ячейки данной строки
        /// </summary>
        public List<CellForFooter> Cells { get; private set; }

        public Footer(Row row, Cell cell, String cellValue)
        {
            _Row = new Row((Row)row.Clone()) { RowIndex = row.RowIndex };
            var _Cell = (Cell)cell.Clone();
            _Cell.CellReference = cell.CellReference;
            Cells = new List<CellForFooter> { new CellForFooter(_Cell, cellValue) };
        }

        public void AddMoreCell(Cell cell, String cellValue)
        {
            var _Cell = (Cell)cell.Clone();
            _Cell.CellReference = cell.CellReference;
            Cells.Add(new CellForFooter(_Cell, cellValue));
        }
    }
}

3) CellForFooter – содержит в себе координаты ячейки и её значение, используется в Footer-е.

using System;
using DocumentFormat.OpenXml.Spreadsheet;
namespace Framework.Create
{
    public class CellForFooter
    {
        /// <summary>
        /// ячейка
        /// </summary>
        public Cell _Cell { get; private set; }
        /// <summary>
        /// значение
        /// </summary>
        public String Value { get; private set; }

        public CellForFooter(Cell cell, String value)
        {
            _Cell = cell;
            Value = value;
        }
    }
}

4) Field – будет содержать индекс строки, где находится DataField, координаты ячеек с DataField и название поля, значение которого надо вывести.

using System;
namespace Framework.Create
{
    public class Field
    {
        /// <summary>
        /// Индекс строки
        /// </summary>
        public uint Row { get; private set; }
        /// <summary>
        /// координаты колонки
        /// </summary>
        public String Column { get; private set; }
        /// <summary>
        /// название колонки, выводимых данных
        /// </summary>
        public String _Field { get; private set; }

        public Field(uint row, String column, String field)
        {
            Row = row;
            Column = column;
            _Field = field;
        }
    }
}

В папке “Load” создаём 2 класса.
1) Worker – это будет наш главный обработчик.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Spreadsheet;
namespace Framework.Load
{
    /// <summary>
    /// Загрузка данных из Excel
    /// </summary>
    public class Worker
    {
        /// <summary>
        /// имя листа (откуда будем читать данные) 
        /// </summary>
        private const String SheetName = "Лист1";

        /// <summary>
        /// Подавать только файлы в формате .xlsx
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public System.Data.DataTable ReadFile(String path)
        {
            CheckFile(path);
            return OpenDocumentForRead(path);
        }

        private System.Data.DataTable OpenDocumentForRead(string path)
        {
            System.Data.DataTable data = null;
            using (var document = SpreadsheetDocument.Open(path, false))
            {
                Sheet sheet;
                try
                {
                    sheet = document.WorkbookPart.Workbook.GetFirstChild<Sheets>().Elements<Sheet>().SingleOrDefault(s => s.Name == SheetName);
                }
                catch (Exception ex)
                {
                    throw new Exception(String.Format("Возможно в документе существует два листа с названием "{0}"!n", SheetName), ex);
                }

                if (sheet == null)
                {
                    throw new Exception(String.Format("В файле не найден "{0}"!n", SheetName));
                }

                var relationshipId = sheet.Id.Value;
                var worksheetPart = (WorksheetPart)document.WorkbookPart.GetPartById(relationshipId);
                var sheetData = worksheetPart.Worksheet.GetFirstChild<SheetData>();

                var firstRow = true;
                var columsNames = new List<ColumnName>();
                foreach (Row row in sheetData.Elements<Row>())
                {
                    if (firstRow)
                    {
                        columsNames.AddRange(GetNames(row, document.WorkbookPart));
                        data = GetTable(columsNames);
                        firstRow = false;
                        continue;
                    }

                    var item = data.NewRow();
                    foreach (var line in columsNames)
                    {
                        var coordinates = String.Format("{0}{1}", line.Liter, row.RowIndex);
                        var cc = row.Elements<Cell>().SingleOrDefault(p => p.CellReference == coordinates);
                        if (cc == null)
                        {
                            throw new Exception(String.Format("Не удалось найти ячейку "{0}"!", coordinates));
                        }
                        item[line.Name.Trim()] = GetVal(cc, document.WorkbookPart);

                    }
                    data.Rows.Add(item);
                }
            }

            return data;
        }

        private System.Data.DataTable GetTable(IEnumerable<ColumnName> columsNames)
        {
            var teb = new System.Data.DataTable("ExelTable");

            foreach (var col in columsNames.Select(columnName => new System.Data.DataColumn { DataType = typeof(String), ColumnName = columnName.Name.Trim() }))
            {
                teb.Columns.Add(col);
            }

            return teb;
        }

        private IEnumerable<ColumnName> GetNames(Row row, WorkbookPart wbPart)
        {
            return (from cell in row.Elements<Cell>()
                    where cell != null
                    let
                        text = GetVal(cell, wbPart)
                    where !String.IsNullOrWhiteSpace(text)
                    select
                    new ColumnName(text, Regex.Replace(cell.CellReference.Value, @"[-9]", ""))).ToList();
        }

        private string GetVal(Cell cell, WorkbookPart wbPart)
        {
            string value = cell.InnerText;

            if (cell.DataType == null)
            {
                return value;
            }
            switch (cell.DataType.Value)
            {
                case CellValues.SharedString:

                    var stringTable =
                        wbPart.GetPartsOfType<SharedStringTablePart>()
                            .FirstOrDefault();

                    if (stringTable != null)
                    {
                        value =
                            stringTable.SharedStringTable
                                .ElementAt(int.Parse(value)).InnerText;
                    }
                    break;
            }

            return value;
        }

        private void CheckFile(String path)
        {
            if (String.IsNullOrWhiteSpace(path) || !File.Exists(path))
            {
                throw new Exception(String.Format("Такого файла "{0}", не существует!", path));
            }
        }
    }
}

2) ColumnName – будет название колонки, для загружаемых данных.

using System;
namespace Framework.Load
{
    public class ColumnName
    {
        /// <summary>
        /// название колонки, для загружаемых данных
        /// </summary>
        public String Name { get; private set; }
        /// <summary>
        /// буква колонки
        /// </summary>
        public String Liter { get; private set; }

        public ColumnName(string name, string liter)
        {
            Name = name;
            Liter = liter;
        }
    }
}

В проекте “Interfaces” создадим интерфейс наших данных IDataForTest.

using System;
namespace Interfaces
{
    public interface IDataForTest
    {
        String A { get; }
        String B { get; }
        String C { get; }
    }
}

В проекте “Converter” создадим класс
ConvertToDataTable – для конвертирования наших данных в DataTable.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using Interfaces;
namespace Converter
{
    public class ConvertToDataTable
    {
        public DataTable ExcelTableLines(IEnumerable<IDataForTest> lines)
        {
            var dt = CreateTable();
            foreach (var line in lines)
            {
                var row = dt.NewRow();
                row["AAA"] = line.A;
                row["BBB"] = line.B;
                row["CCC"] = line.C;
                dt.Rows.Add(row);
            }
            return dt;
        }

        public Hashtable ExcelTableHeader(Int32 count)
        {
            var head = new Dictionary<String, String> { { "Date", DateTime.Today.Date.ToShortDateString() }, { "Count", count.ToString() } };
            return new Hashtable(head);
        }

        private DataTable CreateTable()
        {
            var dt = new DataTable("ExelTable");
            var col = new DataColumn { DataType = typeof(String), ColumnName = "AAA" };
            dt.Columns.Add(col);
            col = new DataColumn { DataType = typeof(String), ColumnName = "BBB" };
            dt.Columns.Add(col);
            col = new DataColumn { DataType = typeof(String), ColumnName = "CCC" };
            dt.Columns.Add(col);
            return dt;
        }
    }
}

В проекте “OpenXmlPrj”
Будет класс для выполнения программы “Program”.

using System;
using System.Collections.Generic;
using System.Data;
namespace OpenXmlPrj
{
    class Program
    {
        static void Main(string[] args)
        {
            //заполняем тестовыми данными
            var myData = new List<DataForTest>
            {
                new DataForTest("a1","b1","c1"),
                new DataForTest("a2","b2","c2"),
                new DataForTest("a3","b3","c3"),
                new DataForTest("a4","b4","c4"),
                new DataForTest("a5","b5","c5")
            };

            var ex = new Converter.ConvertToDataTable();
            //ex.ExcelTableLines(myData) - конвертируем наши данные в DataTable
            //ex.ExcelTableHeader(myData.Count) - формируем данные для Label
            //template - указываем название нашего файла  - шаблона
            new Framework.Create.Worker().Export(ex.ExcelTableLines(myData), ex.ExcelTableHeader(myData.Count), "template");

            Console.WriteLine("Excel File Has Created!nFor Read Data From Excel, press any key!");
            Console.ReadKey();
            //"C:\Loading\ReadMePlease.xlsx" - путь к файлу, с которого будем считывать данные (возвращяет нам DataTable)
            var dt = new Framework.Load.Worker().ReadFile("C:\Loading\ReadMePlease.xlsx");
            var myDataFromExcel = new List<DataForTest>();
            //Заполняем наш объект, считанными данными из DataTable
            foreach (DataRow item in dt.Rows)
            {
                myDataFromExcel.Add(new DataForTest(item));
            }

            Console.WriteLine("---------- Data ---------------------");
            //Выводим считанные данные
            foreach (var line in myDataFromExcel)
            {
                Console.WriteLine("{0} | {1} | {2}", line.A, line.B, line.C);
            }

            Console.WriteLine("Done. Press any key, for exit!");
            Console.ReadKey();
        }
    }
}

И класс для наших данных “DataForTest”.

using System;
using System.Data;
using Interfaces;
namespace OpenXmlPrj
{
    public class DataForTest : IDataForTest
    {
        public String A { get; private set; }
        public String B { get; private set; }
        public String C { get; private set; }

        public DataForTest(String a, String b, String c)
        {
            A = a;
            B = b;
            C = c;
        }

        public DataForTest(DataRow item)
        {
            A = item["MyFieldA"].ToString();
            B = item["MyFieldB"].ToString();
            C = item["MyFieldC"].ToString();
        }
    }
}

И проекте “OpenXmlPrj” надо подключить ссылки на следующие проекты: Interfaces, Framework, Converter
Условия для создания шаблона:
1. Excel лист, обязательно должен называться “Лист1” (ну или если захотите переименовать, то в коде надо будет изменить название тоже).
2. Названия после DataField: должны строго совпадать с названиями колонок в DataTable.
3. Шаблон должен быть сохранён в формате “.xlsx”.
Условия для файла, с которого мы будем считывать данные:
1. Excel лист, обязательно должен называться “Лист1” (ну или если захотите переименовать, то в коде надо будет изменить название тоже).
2. Первая строка, должна содержать названия колонок, по которым мы потом будем парсить данные.

Ссылка на исходник, в GitHub-е.

• Download StudentExcelFile.zip 
• Download OpenXMLExcel.zip 

Introduction 

This article presents an example on how to read and write Microsoft Excel with Open XML SDK. 

Background       

In the Information Technology, it is very common that the users will give us the following requests: 

• Given some data in the database or any other data storage, you will be asked to create an Excel file with the data and present the Excel file to the users;
• Given an Excel file, you will be asked to read the data and process it in your program. 

The article will show you an example to read from and write to Microsoft Excel files with the Open XML SDK. The example is a MVC 2 web application written in Visual Studio 2010. To keep things simple, the example only reads the first sheet of the Excel files, and the Excel files created by the example also have only a single sheet.  

I am well aware that the current version of the ASP.Net MVC is 4. I am also aware that not all the people are using the most recent version. The purpose to keep the example application in a lower version MVC and Visual Studio 2010 is to make the readers easier to download and run the example, because a lot of the readers do not have the most recent version of the Visual Studio. 

• The «ControllersHomeController.cs» is the application’s controller; 
• The «ViewsHomeIndex.aspx» is the application’s view;
• The 3 files in the «SLExcelUtility» folder implements the data and utility classes to read from and write to the Excel files.

You can download the complete Open XML SDK from here. The attached Visual Studio solution comes with the core SDK «DocumentFormat.OpenXml.dll», so you can simply download the attached solution and open it in your Visual Studio and compile to run the example application. 

The Example Excel File  

The following picture shows the example Excel file attached in this article, which has the information of 1000 randomly generated students.  

The purpose of the example web application is to allow users to upload the Excel file to the web server. When the Excel file is uploaded, the application will read the data in the file and save the data in the web session. The web application then shows the users a hyperlink. If the users click on the link, the web application will use the data in the session to recreate an Excel file and download it back to the user. So this example web application shows you both reading from and writing to Excel files.   

The Excel Utility Classes    

The «SLExcelUtilitySLExcelData.cs» file implements the data class to keep the data in the Excel file. 

using System.Collections.Generic;
using DocumentFormat.OpenXml.Spreadsheet;
	
namespace OpenXMLExcel.SLExcelUtility
{
    public class SLExcelStatus
    {
        public string Message { get; set; }
        public bool Success
        {
            get { return string.IsNullOrWhiteSpace(Message); }
        }
    }
	
    public class SLExcelData
    {
        public SLExcelStatus Status { get; set; }
        public Columns ColumnConfigurations { get; set; }
        public List<string> Headers { get; set; }
        public List<List<string>> DataRows { get; set; }
        public string SheetName { get; set; }
	
        public SLExcelData()
        {
            Status = new SLExcelStatus();
            Headers = new List<string>();
            DataRows = new List<List<string>>();
        }
    }
} 

The «SLExcelData» class is used to store the data read from the Excel file. 

• The «Status» property keeps any possible errors when reading the Excel file;
• The «Headers» property keeps the data in the first row of the Excel sheet; 
• The «DataRows» property keeps the data for the rest of the rows of the Excel sheet;
• The «SheetName» property keeps the name of the Excel sheet;
• The «ColumnConfigurations» property keeps the configuration information of the columns in the Excel sheet. 

The «SLExcelUtilitySLExcelReader.cs» implements the class to read the Excel file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Web;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Spreadsheet;
	
namespace OpenXMLExcel.SLExcelUtility
{
    public class SLExcelReader
    {
        private string GetColumnName(string cellReference)
        {
            var regex = new Regex("[A-Za-z]+");
            var match = regex.Match(cellReference);
	
            return match.Value;
        }
	
        private int ConvertColumnNameToNumber(string columnName)
        {
            var alpha = new Regex("^[A-Z]+$");
            if (!alpha.IsMatch(columnName)) throw new ArgumentException();
	
            char[] colLetters = columnName.ToCharArray();
            Array.Reverse(colLetters);
	
            var convertedValue = 0;
            for (int i = 0; i < colLetters.Length; i++)
            {
                char letter = colLetters[i];
                
                int current = i == 0 ? letter - 65 : letter - 64;
                convertedValue += current * (int)Math.Pow(26, i);
            }
	
            return convertedValue;
        }
	
        private IEnumerator<Cell> GetExcelCellEnumerator(Row row)
        {
            int currentCount = 0;
            foreach (Cell cell in row.Descendants<Cell>())
            {
                string columnName = GetColumnName(cell.CellReference);
	
                int currentColumnIndex = ConvertColumnNameToNumber(columnName);
	
                for (; currentCount < currentColumnIndex; currentCount++)
                {
                    var emptycell = new Cell()
                    {
                        DataType = null, CellValue = new CellValue(string.Empty)
                    };
                    yield return emptycell;
                }
	
                yield return cell;
                currentCount++;
            }
        }
	
        private string ReadExcelCell(Cell cell, WorkbookPart workbookPart)
        {
            var cellValue = cell.CellValue;
            var text = (cellValue == null) ? cell.InnerText : cellValue.Text;
            if ((cell.DataType != null) && (cell.DataType == CellValues.SharedString))
            {
                text = workbookPart.SharedStringTablePart.SharedStringTable
                    .Elements<SharedStringItem>().ElementAt(
                        Convert.ToInt32(cell.CellValue.Text)).InnerText;
            }
	
            return (text ?? string.Empty).Trim();
        }
	
        public SLExcelData ReadExcel(HttpPostedFileBase file)
        {
            var data = new SLExcelData();
	
            
            if (file.ContentLength <= 0)
            {
                data.Status.Message = "You uploaded an empty file";
                return data;
            }
	
            if (file.ContentType 
                != "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
            {
                data.Status.Message
                    = "Please upload a valid excel file of version 2007 and above";
                return data;
            }
	
            
            WorkbookPart workbookPart; List<Row> rows;
            try
            {
                var document = SpreadsheetDocument.Open(file.InputStream, false);
                workbookPart = document.WorkbookPart;
	
                var sheets = workbookPart.Workbook.Descendants<Sheet>();
                var sheet = sheets.First();
                data.SheetName = sheet.Name;
	
                var workSheet = ((WorksheetPart)workbookPart
                    .GetPartById(sheet.Id)).Worksheet;
                var columns = workSheet.Descendants<Columns>().FirstOrDefault();
                data.ColumnConfigurations = columns;
	
                var sheetData = workSheet.Elements<SheetData>().First();
                rows = sheetData.Elements<Row>().ToList();
            }
            catch (Exception e)
            {
                data.Status.Message = "Unable to open the file";
                return data;
            }
	
            
            if (rows.Count > 0)
            {
                var row = rows[0];
                var cellEnumerator = GetExcelCellEnumerator(row);
                while (cellEnumerator.MoveNext())
                {
                    var cell = cellEnumerator.Current;
                    var text = ReadExcelCell(cell, workbookPart).Trim();
                    data.Headers.Add(text);
                }
            }
	
            
            if (rows.Count > 1)
            {
                for (var i = 1; i < rows.Count; i++)
                {
                    var dataRow = new List<string>();
                    data.DataRows.Add(dataRow);
                    var row = rows[i];
                    var cellEnumerator = GetExcelCellEnumerator(row);
                    while (cellEnumerator.MoveNext())
                    {
                        var cell = cellEnumerator.Current;
                        var text = ReadExcelCell(cell, workbookPart).Trim();
                        dataRow.Add(text);
                    }
                }
            }
	
            return data;
        }
    }
} 

The «ReadExcel» method takes the Excel file as input and returns an object of the «SLExcelData» class. If the read is successful, the returned «SLExcelData» object will have the data in the Excel sheet. You may pay some attention on the two private methods. 

• The «ReadExcelCell» method read the data in an Excel cell. When the cell is a «SharedString», we will need to get the data from a shared location; 
• The «GetExcelCellEnumerator» method turns the Excel row into an Enumerator. The reason why we need this enumerator is that when an Excel cell is empty, the cell simply does not exist in the Open XML «Row».  

The «SLExcelWriter.cs» class implements the class to create an Excel file from a «SLExcelData» object. 

using System;
using System.IO;
using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Spreadsheet;
	
namespace OpenXMLExcel.SLExcelUtility
{
    public class SLExcelWriter
    {
        private string ColumnLetter(int intCol)
        {
            var intFirstLetter = ((intCol) / 676) + 64;
            var intSecondLetter = ((intCol % 676) / 26) + 64;
            var intThirdLetter = (intCol % 26) + 65;
	
            var firstLetter = (intFirstLetter > 64)
                ? (char)intFirstLetter : ' ';
            var secondLetter = (intSecondLetter > 64)
                ? (char)intSecondLetter : ' ';
            var thirdLetter = (char)intThirdLetter;
	
            return string.Concat(firstLetter, secondLetter,
                thirdLetter).Trim();
        }
	
        private Cell CreateTextCell(string header, UInt32 index,
            string text)
        {
            var cell = new Cell
            {
                DataType = CellValues.InlineString,
                CellReference = header + index
            };
	
            var istring = new InlineString();
            var t = new Text { Text = text };
            istring.AppendChild(t);
            cell.AppendChild(istring);
            return cell;
        }
	
        public byte[] GenerateExcel(SLExcelData data)
        {
            var stream = new MemoryStream();
            var document = SpreadsheetDocument
                .Create(stream, SpreadsheetDocumentType.Workbook);
	
            var workbookpart = document.AddWorkbookPart();
            workbookpart.Workbook = new Workbook();
            var worksheetPart = workbookpart.AddNewPart<WorksheetPart>();
            var sheetData = new SheetData();
	
            worksheetPart.Worksheet = new Worksheet(sheetData);
	
            var sheets = document.WorkbookPart.Workbook.
                AppendChild<Sheets>(new Sheets());
	
            var sheet = new Sheet() { Id = document.WorkbookPart
                .GetIdOfPart(worksheetPart),
                SheetId = 1, Name = data.SheetName??"Sheet 1" };
            sheets.AppendChild(sheet);
	
            
            UInt32 rowIdex = 0;
            var row = new Row { RowIndex = ++rowIdex };
            sheetData.AppendChild(row);
            var cellIdex = 0;
	
            foreach (var header in data.Headers)
            {
                row.AppendChild(CreateTextCell(ColumnLetter(cellIdex++),
                    rowIdex, header??string.Empty));
            }
            if (data.Headers.Count > 0)
            {
                
                if (data.ColumnConfigurations != null)
                {
                    var columns = (Columns)data.ColumnConfigurations.Clone();
                    worksheetPart.Worksheet
                        .InsertAfter(columns, worksheetPart
                        .Worksheet.SheetFormatProperties);
                }
            }
	
            
            foreach (var rowData in data.DataRows)
            {
                cellIdex = 0;
                row = new Row { RowIndex = ++rowIdex };
                sheetData.AppendChild(row);
                foreach (var callData in rowData)
                {
                    var cell = CreateTextCell(ColumnLetter(cellIdex++),
                        rowIdex, callData??string.Empty);
                    row.AppendChild(cell);
                }
            }
	
            workbookpart.Workbook.Save();
            document.Close();
	
            return stream.ToArray();
        }
    }
} 

The «GenerateExcel» method takes an object of type «SLExcelData» and put the data into an Excel sheet. The Excel file is returned in the form of a byte array. 

The MVC Application  

Built upon the Excel utility classes, the MVC application is pretty simple. 

The «ControllersHomeController.cs» is implemented as the following:  

using System.Web;
using System.Web.Mvc;
using OpenXMLExcel.SLExcelUtility;
	
namespace OpenXMLExcel.Controllers
{
    public class HomeController : Controller
    {
        private const string SessionExcelData = "SessionExcelData";
	
        public ActionResult Index()
        {
            return View();
        }
	
        public ActionResult UploadFile(HttpPostedFileBase excelFile)
        {
            var data = (new SLExcelReader()).ReadExcel(excelFile);
            Session[SessionExcelData] = data;
	
            return View("Index", data.Status);
        }
	
        public ActionResult DownloadFile()
        {
            var data = (SLExcelData) Session[SessionExcelData];
            if (data == null)
            {
                ViewData["RedirectUrl"] = Url.Action("Index");
                return View("SessionExpired");
            }
	
            var file = (new SLExcelWriter()).GenerateExcel(data);
            Response.AddHeader("Content-Disposition",
                "attachment; filename=ExcelFile.xlsx");
            return new FileContentResult(file,
                "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
        }
    }
}  

• The action method «Index» loads the view page;
• The action method «UploadFile» uses the «SLExcelReader» class to read the uploaded Excel file and keeps the «SLExcelData» object in the web session; 
• The action method «DownloadFile» uses the «SLExcelWriter» to create an Excel file based on the «SLExcelData» object in the web session.  

The «ViewsHomeIndex.aspx» file is implemented as the following: 

<%@ Page Language="C#"
    Inherits="System.Web.Mvc.ViewPage<OpenXMLExcel.SLExcelUtility.SLExcelStatus>" %>
	
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
	
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Upload & Download Excel Example</title>
    <link href="<%=Url.Content("~/Content/AppStyle.css") %>" rel="stylesheet"
        type="text/css" />
    <script type="text/javascript"
        src="<%=Url.Content("~/Scripts/jquery-2.0.3.min.js") %>"></script>
    <script type="text/javascript"
        src="<%=Url.Content("~/Scripts/OpenXMLExcelAppScript.js") %>"></script>
</head>
<body>
<form action="<%=Url.Action("UploadFile") %>"
    enctype="multipart/form-data" method="post">
    <div style="margin: 10px">
        <%if (Model != null)
          {%>
            <p>
                <%if (Model.Success)
                  {%>
                    <a href="<%= Url.Action("DownloadFile") %>">
                        Excel file is uploaded successfully, let us download it back
                    </a>
                <% }
                  else
                  {%>
                    <label class="errorMsg"><%=Model.Message %></label>
                <% } %>
            </p>
        <% } %>
        <p>
            <button type="button" id="btnSubmit">Submit</button>
            <input type="file" name="excelFile"/>
        </p>
    </div>
</form>
</body>
</html>  

The JavaScript code used by the view page is the following: 

$(document).ready(function () {
    $('#btnSubmit').click(function () {
        var fileName = $('[name="excelFile"]').val().trim();
        var pos = fileName.lastIndexOf('.');
        var extension = (pos <= 0) ? '' : fileName.substring(pos);
        if (extension != '.xlsx') {
            alert('Please browse a correct excel file to upload');
            return;
        }
        $('form').submit();
    });
}); 

Run the Application  

We now finish this simple example application, we can then test run it. When the web application first launches, it show us the buttons to allow use to browse the Excel file and upload it to the server. 

We can then choose the attached Excel file in this article and upload it. When the upload succeeds, we will have a download link. 

If we click on the download link, an Excel file is generated by the data in the file that we just uploaded. 

We can open this file and compare with the file that we just uploaded. We should see that the two Excel files have the same data. You do not have to upload the Excel file comes with this article, you can actually upload any Excel file and see how the program works. You should keep in the following in mind though,

• The Excel utility classes in the article only process the first sheet of the Excel file. If you have more than 1 sheet, it only reads the first sheet and the generated Excel has only the data of the first sheet of the Excel file uploaded.  
• The Excel utility classes only process the data in the Excel files. If you have a fancy Excel sheet that has a lot of beautiful formatting and pictures, they are not processed by the utility classes.  

Points of Interest  

• This article presents an example on how to read and write Microsoft Excel with Open XML SDK.
• The Excel utility classes in the article only process the first sheet of the Excel file. If you have more than 1 sheet, it only reads the first sheet and the generated Excel has only the data of the first sheet of the Excel file uploaded. If you need to handle multiple sheets, you can easily extend these classes to do it. 
• The Excel utility classes only process the data in the Excel files. If you have a fancy Excel sheet that has a lot of beautiful formatting and pictures, they are not processed by the utility classes.  
• You do not need to use the Excel file attached in this article to test the application, you can choose any excel file to see how it works.
• I have tested this example multiple times, but my own test is really limited. If you find any problems when you test it, please do not hesitate to let me know. I will make my effort to make it to work better, if I have some time to spare. 
• I hope you like my postings and I hope this article can help you one way or the other.  

History 

Исходный адрес:Как работать с документами в формате Office Open XML (очередь)

Содержание этой страницы

	Обзор
	Создание файла в формате Office Open XML
	Обзор файлов формата Office Open XML
	Редактировать документы, созданные в формате Office Open XML, вручную
	Работа с документами в формате Office Open XML с помощью программирования
	в заключении
	Дополнительные ресурсы

Обзор

В более ранних версиях Microsoft Office файлы, созданные в Microsoft Office Excel, Microsoft Office PowerPoint и Microsoft Office Word, сохранялись в уникальном едином файловом формате и назывались двоичными файлами. Выпуск Microsoft Office System 2007 представил новый формат файлов для Microsoft Office Excel 2007, Microsoft Office PowerPoint 2007 и Microsoft Office Word 2007: формат Office Open XML.

Формат Office Open XML основан на технологии архивов XML и ZIP. Как и в более ранних версиях Microsoft Office, документы 2007 хранятся в одном файле или контейнере, поэтому процесс управления этими документами по-прежнему прост. Однако, в отличие от более ранних файлов, файлы в формате Office Open XML могут открываться компонентами на дисплее, что позволяет получить доступ к структуре этого файла.

В этой статье вы можете вручную открыть файл и просмотреть каждую часть документа, чтобы просмотреть файл формата Office Open XML. Кроме того, вы также можете запрограммировать этот документ. Файлы, применимые в этой статье, можно получить, загрузив,2007OfficeManipulatingOpenXMLFilesSample.exe.Если вы не можете загрузить, вы можете вместо этого использовать свои собственные программные файлы и файлы изображений.

Создание файла в формате Office Open XML

В этом разделе вы обнаружите формат файла XML образца документа Word 2007, содержащего текст, изображения и атрибуты.

вWordСоздать вOffice Open XML Форматировать документ

Обзор файлов формата Office Open XML

В этом разделе вы просмотрите только что созданный образец документа.

Просмотр документов в формате Office Open XML

Редактировать документы, созданные в формате Office Open XML, вручную

Формат Office Open XML имеет множество преимуществ. Одним из преимуществ является возможность использовать документы, созданные в системе Office 2007, без программ Office. Это позволяет создавать серверные решения для сбора, доступа и редактирования документов в масштабируемой среде.

На следующих шагах вы вручную отредактируете документ Word 2007. Обратите внимание, что эти сценарии — лишь небольшой пример этого нового формата файла. В большинстве случаев пользователи не будут вручную редактировать документы таким образом. Но для разработчиков просмотр документов, созданных Office 2007 без написания кода, принесет большие преимущества, особенно при разработке решений или написании моделей программ. Как вы видели ранее, после доступа к файлу-контейнеру этого документа вы можете легко просматривать отдельные компоненты. Это также означает, что вы можете редактировать, заменять или даже добавлять компоненты. Обычно вы можете изменять примечания к документу и обновлять свойства документа.

использоватьXMLмодифицироватьOffice Open XMLФорматировать документ

<w:t>A study of the bald eagle</w:t>

<w:t>A detailed study of the bald eagle</w:t>

<dc:creator>Nancy Davolio</dc:creator>

На предыдущих шагах вы изменили документ, отредактировав компонент XML в документе. В новом формате файла вы также можете заменить весь компонент документа, чтобы изменить его содержимое, формат или атрибуты. Это позволяет использовать существующие компоненты документа для обновления отдельных документов или обновления целых библиотек документов.

Примером использования существующих компонентов для изменения документа является изменение стиля, используемого в документе. Этот метод полезен, если вам нужно управлять стилями нескольких документов, но вы хотите сохранить физическую версию. Чтобы изменить все типы, используемые в документе, нужно заменить компонент styles.xml.

Этот сценарий позволяет вам скомпилировать набор компонентов стиля для всех документов, а затем создать приложение, которое позволяет пользователям автоматически выбирать разные стили. В фоновом режиме ваше приложение может заменить один готовый компонент другим. На следующих шагах вы выполните эту операцию вручную.

Измените один, заменив существующие компонентыOffice Open XMLФорматировать документ

Другой аспект этой сцены стиля — использование компонента документа верхнего и нижнего колонтитула для быстрого копирования тех же параметров из документа Word 2007 в один или несколько документов Word 2007. Компоненты верхнего и нижнего колонтитула можно изменить вручную, об этом вы узнаете позже. Конечно, этот процесс также можно автоматизировать с помощью кода. Это полезно для организаций, которые хотят использовать стандартные верхние и нижние колонтитулы документов и не должны оплачивать административные задачи в каждом базовом документе. Кроме того, если изменить формат вашего верхнего и нижнего колонтитула, очень легко заменить верхний и нижний колонтитулы.

На следующих шагах вы добавите простой заголовок в SampleWordDocument.docx. Затем обновите его заголовком, отличным от документа AnotherSampleWordDocument.docx.

ОбновитьOffice Open XML Форматировать заголовок документа

Документы также могут содержать двоичные компоненты, такие как файлы изображений или проекты Microsoft VBA, к которым вы можете легко получить доступ как к компонентам XML. Замена двоичных компонентов принесет некоторые интересные вещи. Например, вы можете заменить двоичные компоненты, чтобы заменить целые объекты OLE, такие как изображения Microsoft Office Visio. Ручные операции не имеют значения. Вам необходимо рассмотреть сценарий, который позволяет автоматически обновлять изображения с сервера. Написать инструмент для выполнения таких операций относительно просто. На следующих шагах вы будете использовать изображение для обмена двоичным файлом изображения в документе AnotherSampleWordDocument.docx.

вOffice Open XMLОбмен двоичными компонентами в файлах формата

Некоторые компоненты необходимы в документах системы Microsoft Office, например, компонент document.xml в Word 2007. Однако некоторые компоненты являются необязательными и существуют только тогда, когда требуются определенные функции. Это означает, что если вам не нужны определенные функции, вы можете удалить эти компоненты и связанные отношения. Документ Office 2007, содержащий код проекта, называется документом с поддержкой макросов (расширение .docm для Word 2007, расширение .xlsm для Excel 2007 и расширение .pptm для PowerPoint 2007). В отличие от документов, не содержащих макросов, документы с поддержкой макросов хранят код в компонентах. Тип компонента зависит от типа кода в документе. Например, документ с поддержкой макросов, содержащий код VBA, хранит свои данные в двоичном компоненте vbaProject.bin.

Другие типы проектов включают книги Excel 2007 с использованием макросов в стиле Excel 4.0 (макросы XLM) или слайд-шоу PowerPoint 2007 с командными кнопками. Эти функции расположены в отдельных компонентах, поэтому их можно легко идентифицировать и удалять.

На следующих шагах вы создадите простой документ с поддержкой макросов и продемонстрируете его возможности. Затем вы удалите компонент vbaProject.bin и его взаимосвязь из документа и увидите его эффект. Обратите внимание, что вы также можете удалить компоненты проекта из файла с поддержкой макросов, щелкнув «Сохранить как» в меню «Файл» или сохранив файл как файл без макросов (.docx, .pptx или .xlsx). Однако для этого необходимо открыть этот документ в программе Система Office 2007. Выполните действия, описанные в следующей процедуре, чтобы выйти из проекта без использования программ Office.

ИзOffice Open XMLФорматировать документ удаленVBAпроект

Sub SampleCode()
        Msgbox("Hello World")
        End Sub

<Relationship Id="rId1" Type="http://schemas.microsoft.com/office/2006/relationships/vbaProject" Target="vbaProject.bin"/>

Работа с документами в формате Office Open XML с помощью программирования

Важное значение формата Office Open XML — его безграничный потенциал для индивидуальных решений. Вы можете получить доступ и изменить содержимое документа с помощью инструментов, которые могут обрабатывать файлы XML или ZIP на любой платформе. Например, вы можете использовать управляемый код в Microsoft Visual Studio для написания серверного приложения для сохранения документов системы 2007 Office. Вы можете использовать мощную библиотеку классов XML Microsoft .NET Framework для редактирования любого компонента документа XML, содержащегося в файле формата Office Open XML.

Мощный способ манипулировать компонентами документа и их отношениями — использовать пространство имен System.IO.Packaging, которое входит в состав Microsoft Windows Software Development Kit. Пространство имен System.IO.Packaging будет подробно рассмотрено позже.

Замечания:

Вы можете загрузить предварительную версию программного обеспечения Microsoft WinFX Runtime Components — Beta2 из центра загрузок Microsoft.

На следующих шагах вы разработаете консольное приложение для изменения стиля форматирования без использования Word 2007. Этот проект завершается заменой компонентов стиля в документе Word 2007 на компоненты стиля, извлеченные из документа. В результате целевой документ принимает тот же стиль, что и документ, извлекший этот стиль.

Замечания:

Таких примеров кода здесь много, вы можете скачать их. После загрузки этих готовых примеров кода вы сможете использовать эти функции Code Snippet Manager в Microsoft Visual Studio 2005 (в меню «Инструменты»), чтобы вставить их в свой проект. Вы можете скачать2007 Office System Sample: Open XML File Format Code Snippets for Visual Studio 2005.

Выполните следующие шаги, чтобы изменить формат документа.

вOffice Open XMLИзменить стиль в формате документа

using System.IO; 
        using System.IO.Packaging;

private static String stylePath = @"C:"WordOpenXMLFormatSample"NewStylePart"styles.xml";
        private static String packagePath = @"C:"WordOpenXMLFormatSample"SampleWordDocument.docx.zip";

SwapStylePart(packagePath, stylePath);

static void SwapStylePart(String packagePath, String stylePath)
        { }

using (Package package = Package.Open(packagePath, FileMode.Open, FileAccess.ReadWrite))
        { }

// Set the URI for the styles document part (/word/styles.xml). 
        Uri uriPartTarget = new Uri("/word/styles.xml", UriKind.Relative);

// Delete the existing document part (/word/styles.xml).
        package.DeletePart(uriPartTarget);

// Recreate a new document part for styles(/word/styles.xml). PackagePart
        packagePartReplacement = package.CreatePart(uriPartTarget, "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml");

using (FileStream fileStream = new FileStream(stylePath, FileMode.Open, FileAccess.Read))
        {// Load the new styles.xml
        using a stream.CopyStream(fileStream,packagePartReplacement.GetStream());
        }

private static void CopyStream(Stream source, Stream target)
        {
        const int bufSize = 0x1000;
        const int bufSize = 1024;
        byte[] buf = new byte[bufSize];
        int bytesRead = 0;
        while ((bytesRead = source.Read(buf, 0, bufSize)) > 0)
        {
        target.Write(buf, 0, (int)bytesRead);
        }
        source.Close();
        target.Close();
        }

В следующем упражнении показано, как использовать настраиваемое приложение для выполнения пакетных операций с файлами формата Office Open XML без Word 2007. В этом упражнении вы создадите размещенную программу, которая будет искать нужные файлы в папках и подпапках, соответствующих определенным критериям. Приложение определяет компоненты документа на наличие терминов и содержащие файлы данных. Вы можете представить себе использование этой программы для идентификации документов, содержащих конкретные имена клиентов, или документов, содержащих конкретные наименования продуктов. Вы также можете добавить в приложение дополнительную логику и использовать другие термины для замены существующих, по сути копируя функцию «Найти-заменить» в Word 2007 без использования приложения.

Поиск в группе по ключевым словамOffice Open XMLФорматировать файл

using System.Xml; using System.IO; using System.IO.Packaging;

FileInfo[] tempfiles; List<FileInfo> files = new List<FileInfo>();

Boolean match = false; // Ensure that the user added a search term.
        if (txtTerm.Text == "")
        {
        MessageBox.Show("Don't forget the search term.");
        }
        List<FileInfo> returnedFiles; // Get the starting directory. 
        DirectoryInfo dir = new DirectoryInfo(txtPath.Text); // Get the list of files.
        returnedFiles = GetDirFiles(dir); // Loop through the file list.
        foreach(FileInfo file in returnedFiles)
        {
        match = GetDocPart(file);
        }
        if(!match)
        { // No matching files were found.
        lbxResults.Items.Add("No matches.");
        }

public List<FileInfo> GetDirFiles(DirectoryInfo dir)
        { // Get all files for the current directory.
        Object selectedItem = cboMask.SelectedItem;
        tempfiles = dir.GetFiles(selectedItem.ToString());// Add these files to the returned file list.
        foreach (FileInfo file1 in tempfiles)
        {
        files.Add(file1);
        }// Search subfolders if requested.
        if (ckbSubfolders.Checked)
        {// Get subfolders for the current directory.
        DirectoryInfo[] dirs = dir.GetDirectories("*.*");
        foreach (DirectoryInfo directory in dirs)
        {
        GetDirFiles(directory);
        }
        }
        return files;
        }

private Boolean GetDocPart(FileInfo file)
        { // Retrieve the start part for the input file.
        Boolean fileFound = false;
        const String documentRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
        const String dcPropertiesSchema = "http://purl.org/dc/elements/1.1/";// Open the package with read access.
        using (Package myPackage = Package.Open(file.DirectoryName + """" + file.Name, FileMode.Open, FileAccess.Read))
        { // Get the main document part (document.xml).
        foreach (PackageRelationship relationship in myPackage.GetRelationshipsByType(documentRelationshipType))
        { // There should be only one document part in the package.
        Uri documentUri = PackUriHelper.ResolvePartUri(new Uri("/", UriKind.Relative), relationship.TargetUri);
        PackagePart documentPart = myPackage.GetPart(documentUri);
        NameTable nt = new NameTable();
        XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
        nsmgr.AddNamespace("w", dcPropertiesSchema);
        XmlDocument doc = new XmlDocument(nt);
        doc.Load(documentPart.GetStream());
        if (doc.OuterXml.IndexOf(txtTerm.Text) >= 1)
        {
        lbxResults.Items.Add(file.DirectoryName + """" + file.Name);
        fileFound = true;
        }// There is only one document part, so exit the loop. break;
        }
        }
        if (lbxResults.Items.Count >0)
        {
        return true;
        }
        else
        {
        return false;
        }
        }

Close();

Это весь код, который вам нужен для поиска в документе, в этом случае вам не нужно использовать Word 2007. Вам нужно добавить несколько небольших функций: подсчитать количество документов для поиска, добавить функции замены или поиск других компонентов.

в заключении

В этой статье вы знакомы со структурой файлов формата Office Open XML. Вы просмотрели формат файла и продемонстрировали, как легко открывать и редактировать документы Microsoft Office 2007 с помощью стандартных технологий XML и ZIP. Вы также узнали, как управлять файлами формата Office Open XML вручную и с помощью программирования. Благодаря этому контенту у вас есть основа для создания пользовательских приложений для вашей организации.

Укажите адрес статьи:Как работать с документами в формате Office Open XML (очередь)

In this example, let’s create a demo console project in Visual Studio by selecting File -> New -> Project. From the project window, select Console template and type name and select path for the project, as shown below.

After creating the project, create a Model Class and give a name as TestModel, as shown below.

Create one more class and give name as TestModelList.

Let’s add some hard coded data into this model. For that, write the below code in the main method of Program.cs file.

Now, we have got a Model ready. So, let’s start writing functions for creating an Excel file using OpenXml. For this, add OpenXml from NuGet Packages by right-clicking the project and selecting «Manage NuGet Package» and search openxml. From the list, select DocumentFormat.OpenXml as shown below and install it.

Next, create functions for creating an Excel package using OpenXml as shown below.

• First, import OpenXml packages as shown below.
  1. using DocumentFormat.OpenXml;  
  2. using DocumentFormat.OpenXml.Packaging;  
  3. using DocumentFormat.OpenXml.Spreadsheet;  
  4. using X14 = DocumentFormat.OpenXml.Office2010.Excel;  
  5. using X15 = DocumentFormat.OpenXml.Office2013.Excel;  

  Then, add the below code for creating an Excel file into given path.

  1. public void CreateExcelFile(TestModelList data, string OutPutFileDirectory)  
  2. {  
  3.     var datetime = DateTime.Now.ToString().Replace(«/», «_»).Replace(«:», «_»);  
  4.    
  5.     string fileFullname = Path.Combine(OutPutFileDirectory, «Output.xlsx»);  
  6.    
  7.     if (File.Exists(fileFullname))  
  8.     {  
  9.         fileFullname = Path.Combine(OutPutFileDirectory, «Output_» + datetime + «.xlsx»);  
  10.     }  
  11.    
  12.     using (SpreadsheetDocument package = SpreadsheetDocument.Create(fileFullname, SpreadsheetDocumentType.Workbook))  
  13.     {  
  14.         CreatePartsForExcel(package, data);  
  15.     }  
  16. }  

• Write functions for creating workbook and worksheet into Excel.
  1. private void CreatePartsForExcel(SpreadsheetDocument document, TestModelList data)  
  2. {  
  3.     SheetData partSheetData = GenerateSheetdataForDetails(data);  
  4.    
  5.     WorkbookPart workbookPart1 = document.AddWorkbookPart();  
  6.     GenerateWorkbookPartContent(workbookPart1);  
  7.    
  8.     WorkbookStylesPart workbookStylesPart1 = workbookPart1.AddNewPart<WorkbookStylesPart>(«rId3»);  
  9.     GenerateWorkbookStylesPartContent(workbookStylesPart1);  
  10.    
  11.     WorksheetPart worksheetPart1 = workbookPart1.AddNewPart<WorksheetPart>(«rId1»);  
  12.     GenerateWorksheetPartContent(worksheetPart1, partSheetData);  
  13. }  
• Write functions for creating workbook and work sheet content in Excel, as shown below.
  1. private void GenerateWorkbookPartContent(WorkbookPart workbookPart1)  
  2. {  
  3.     Workbook workbook1 = new Workbook();  
  4.     Sheets sheets1 = new Sheets();  
  5.     Sheet sheet1 = new Sheet() { Name = «Sheet1», SheetId = (UInt32Value)1U, Id = «rId1» };  
  6.     sheets1.Append(sheet1);  
  7.     workbook1.Append(sheets1);  
  8.     workbookPart1.Workbook = workbook1;  
  9. }  
  10.   
  11. private void GenerateWorksheetPartContent(WorksheetPart worksheetPart1, SheetData sheetData1)  
  12. {  
  13.     Worksheet worksheet1 = new Worksheet() { MCAttributes = new MarkupCompatibilityAttributes() { Ignorable = «x14ac» } };  
  14.     worksheet1.AddNamespaceDeclaration(«r», «http://schemas.openxmlformats.org/officeDocument/2006/relationships»);  
  15.     worksheet1.AddNamespaceDeclaration(«mc», «http://schemas.openxmlformats.org/markup-compatibility/2006»);  
  16.     worksheet1.AddNamespaceDeclaration(«x14ac», «http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac»);  
  17.     SheetDimension sheetDimension1 = new SheetDimension() { Reference = «A1» };  
  18.    
  19.     SheetViews sheetViews1 = new SheetViews();  
  20.    
  21.     SheetView sheetView1 = new SheetView() { TabSelected = true, WorkbookViewId = (UInt32Value)0U };  
  22.     Selection selection1 = new Selection() { ActiveCell = «A1», SequenceOfReferences = new ListValue<StringValue>() { InnerText = «A1» } };  
  23.    
  24.     sheetView1.Append(selection1);  
  25.    
  26.     sheetViews1.Append(sheetView1);  
  27.     SheetFormatProperties sheetFormatProperties1 = new SheetFormatProperties() { DefaultRowHeight = 15D, DyDescent = 0.25D };  
  28.    
  29.     PageMargins pageMargins1 = new PageMargins() { Left = 0.7D, Right = 0.7D, Top = 0.75D, Bottom = 0.75D, Header = 0.3D, Footer = 0.3D };  
  30.     worksheet1.Append(sheetDimension1);  
  31.     worksheet1.Append(sheetViews1);  
  32.     worksheet1.Append(sheetFormatProperties1);  
  33.     worksheet1.Append(sheetData1);  
  34.     worksheet1.Append(pageMargins1);  
  35.     worksheetPart1.Worksheet = worksheet1;  
  36. }  

• Write code for workbook styles by giving your own font size, color, font name, border properties, cell style formats etc. as shown below.
  1. private void GenerateWorkbookStylesPartContent(WorkbookStylesPart workbookStylesPart1)  
  2. {  
  3.     Stylesheet stylesheet1 = new Stylesheet() { MCAttributes = new MarkupCompatibilityAttributes() { Ignorable = «x14ac» } };  
  4.     stylesheet1.AddNamespaceDeclaration(«mc», «http://schemas.openxmlformats.org/markup-compatibility/2006»);  
  5.     stylesheet1.AddNamespaceDeclaration(«x14ac», «http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac»);  
  6.    
  7.     Fonts fonts1 = new Fonts() { Count = (UInt32Value)2U, KnownFonts = true };  
  8.    
  9.     Font font1 = new Font();  
  10.     FontSize fontSize1 = new FontSize() { Val = 11D };  
  11.     Color color1 = new Color() { Theme = (UInt32Value)1U };  
  12.     FontName fontName1 = new FontName() { Val = «Calibri» };  
  13.     FontFamilyNumbering fontFamilyNumbering1 = new FontFamilyNumbering() { Val = 2 };  
  14.     FontScheme fontScheme1 = new FontScheme() { Val = FontSchemeValues.Minor };  
  15.    
  16.     font1.Append(fontSize1);  
  17.     font1.Append(color1);  
  18.     font1.Append(fontName1);  
  19.     font1.Append(fontFamilyNumbering1);  
  20.     font1.Append(fontScheme1);  
  21.    
  22.     Font font2 = new Font();  
  23.     Bold bold1 = new Bold();  
  24.     FontSize fontSize2 = new FontSize() { Val = 11D };  
  25.     Color color2 = new Color() { Theme = (UInt32Value)1U };  
  26.     FontName fontName2 = new FontName() { Val = «Calibri» };  
  27.     FontFamilyNumbering fontFamilyNumbering2 = new FontFamilyNumbering() { Val = 2 };  
  28.     FontScheme fontScheme2 = new FontScheme() { Val = FontSchemeValues.Minor };  
  29.    
  30.     font2.Append(bold1);  
  31.     font2.Append(fontSize2);  
  32.     font2.Append(color2);  
  33.     font2.Append(fontName2);  
  34.     font2.Append(fontFamilyNumbering2);  
  35.     font2.Append(fontScheme2);  
  36.    
  37.     fonts1.Append(font1);  
  38.     fonts1.Append(font2);  
  39.    
  40.     Fills fills1 = new Fills() { Count = (UInt32Value)2U };  
  41.    
  42.     Fill fill1 = new Fill();  
  43.     PatternFill patternFill1 = new PatternFill() { PatternType = PatternValues.None };  
  44.    
  45.     fill1.Append(patternFill1);  
  46.    
  47.     Fill fill2 = new Fill();  
  48.     PatternFill patternFill2 = new PatternFill() { PatternType = PatternValues.Gray125 };  
  49.    
  50.     fill2.Append(patternFill2);  
  51.    
  52.     fills1.Append(fill1);  
  53.     fills1.Append(fill2);  
  54.    
  55.     Borders borders1 = new Borders() { Count = (UInt32Value)2U };  
  56.    
  57.     Border border1 = new Border();  
  58.     LeftBorder leftBorder1 = new LeftBorder();  
  59.     RightBorder rightBorder1 = new RightBorder();  
  60.     TopBorder topBorder1 = new TopBorder();  
  61.     BottomBorder bottomBorder1 = new BottomBorder();  
  62.     DiagonalBorder diagonalBorder1 = new DiagonalBorder();  
  63.    
  64.     border1.Append(leftBorder1);  
  65.     border1.Append(rightBorder1);  
  66.     border1.Append(topBorder1);  
  67.     border1.Append(bottomBorder1);  
  68.     border1.Append(diagonalBorder1);  
  69.    
  70.     Border border2 = new Border();  
  71.    
  72.     LeftBorder leftBorder2 = new LeftBorder() { Style = BorderStyleValues.Thin };  
  73.     Color color3 = new Color() { Indexed = (UInt32Value)64U };  
  74.    
  75.     leftBorder2.Append(color3);  
  76.    
  77.     RightBorder rightBorder2 = new RightBorder() { Style = BorderStyleValues.Thin };  
  78.     Color color4 = new Color() { Indexed = (UInt32Value)64U };  
  79.    
  80.     rightBorder2.Append(color4);  
  81.    
  82.     TopBorder topBorder2 = new TopBorder() { Style = BorderStyleValues.Thin };  
  83.     Color color5 = new Color() { Indexed = (UInt32Value)64U };  
  84.    
  85.     topBorder2.Append(color5);  
  86.    
  87.     BottomBorder bottomBorder2 = new BottomBorder() { Style = BorderStyleValues.Thin };  
  88.     Color color6 = new Color() { Indexed = (UInt32Value)64U };  
  89.    
  90.     bottomBorder2.Append(color6);  
  91.     DiagonalBorder diagonalBorder2 = new DiagonalBorder();  
  92.    
  93.     border2.Append(leftBorder2);  
  94.     border2.Append(rightBorder2);  
  95.     border2.Append(topBorder2);  
  96.     border2.Append(bottomBorder2);  
  97.     border2.Append(diagonalBorder2);  
  98.    
  99.     borders1.Append(border1);  
  100.     borders1.Append(border2);  
  101.    
  102.     CellStyleFormats cellStyleFormats1 = new CellStyleFormats() { Count = (UInt32Value)1U };  
  103.     CellFormat cellFormat1 = new CellFormat() { NumberFormatId = (UInt32Value)0U, FontId = (UInt32Value)0U, FillId = (UInt32Value)0U, BorderId = (UInt32Value)0U };  
  104.    
  105.     cellStyleFormats1.Append(cellFormat1);  
  106.    
  107.     CellFormats cellFormats1 = new CellFormats() { Count = (UInt32Value)3U };  
  108.     CellFormat cellFormat2 = new CellFormat() { NumberFormatId = (UInt32Value)0U, FontId = (UInt32Value)0U, FillId = (UInt32Value)0U, BorderId = (UInt32Value)0U, FormatId = (UInt32Value)0U };  
  109.     CellFormat cellFormat3 = new CellFormat() { NumberFormatId = (UInt32Value)0U, FontId = (UInt32Value)0U, FillId = (UInt32Value)0U, BorderId = (UInt32Value)1U, FormatId = (UInt32Value)0U, ApplyBorder = true };  
  110.            CellFormat cellFormat4 = new CellFormat() { NumberFormatId = (UInt32Value)0U, FontId = (UInt32Value)1U, FillId = (UInt32Value)0U, BorderId = (UInt32Value)1U, FormatId = (UInt32Value)0U, ApplyFont = true, ApplyBorder = true };  
  111.    
  112.     cellFormats1.Append(cellFormat2);  
  113.     cellFormats1.Append(cellFormat3);  
  114.     cellFormats1.Append(cellFormat4);  
  115.    
  116.     CellStyles cellStyles1 = new CellStyles() { Count = (UInt32Value)1U };  
  117.     CellStyle cellStyle1 = new CellStyle() { Name = «Normal», FormatId = (UInt32Value)0U, BuiltinId = (UInt32Value)0U };  
  118.    
  119.     cellStyles1.Append(cellStyle1);  
  120.     DifferentialFormats differentialFormats1 = new DifferentialFormats() { Count = (UInt32Value)0U };  
  121.    TableStyles tableStyles1 = new TableStyles() { Count = (UInt32Value)0U, DefaultTableStyle = «TableStyleMedium2», DefaultPivotStyle = «PivotStyleLight16» };  
  122.    
  123.     StylesheetExtensionList stylesheetExtensionList1 = new StylesheetExtensionList();  
  124.    
  125.     StylesheetExtension stylesheetExtension1 = new StylesheetExtension() { Uri = «{EB79DEF2-80B8-43e5-95BD-54CBDDF9020C}» };  
  126.     stylesheetExtension1.AddNamespaceDeclaration(«x14», «http://schemas.microsoft.com/office/spreadsheetml/2009/9/main»);  
  127.            X14.SlicerStyles slicerStyles1 = new X14.SlicerStyles() { DefaultSlicerStyle = «SlicerStyleLight1» };  
  128.    
  129.     stylesheetExtension1.Append(slicerStyles1);  
  130.    
  131.     StylesheetExtension stylesheetExtension2 = new StylesheetExtension() { Uri = «{9260A510-F301-46a8-8635-F512D64BE5F5}» };  
  132.     stylesheetExtension2.AddNamespaceDeclaration(«x15», «http://schemas.microsoft.com/office/spreadsheetml/2010/11/main»);  
  133.     X15.TimelineStyles timelineStyles1 = new X15.TimelineStyles() { DefaultTimelineStyle = «TimeSlicerStyleLight1» };  
  134.    
  135.     stylesheetExtension2.Append(timelineStyles1);  
  136.    
  137.     stylesheetExtensionList1.Append(stylesheetExtension1);  
  138.     stylesheetExtensionList1.Append(stylesheetExtension2);  
  139.    
  140.     stylesheet1.Append(fonts1);  
  141.     stylesheet1.Append(fills1);  
  142.     stylesheet1.Append(borders1);  
  143.     stylesheet1.Append(cellStyleFormats1);  
  144.     stylesheet1.Append(cellFormats1);  
  145.     stylesheet1.Append(cellStyles1);  
  146.     stylesheet1.Append(differentialFormats1);  
  147.     stylesheet1.Append(tableStyles1);  
  148.     stylesheet1.Append(stylesheetExtensionList1);  
  149.    
  150.     workbookStylesPart1.Stylesheet = stylesheet1;  
  151. }  
• Write a function for generating workbook content, as shown below.
  1. private void GenerateWorkbookPartContent(WorkbookPart workbookPart1)  
  2. {  
  3.     Workbook workbook1 = new Workbook();  
  4.     Sheets sheets1 = new Sheets();  
  5.     Sheet sheet1 = new Sheet() { Name = «Sheet1», SheetId = (UInt32Value)1U, Id = «rId1» };  
  6.     sheets1.Append(sheet1);  
  7.     workbook1.Append(sheets1);  
  8.     workbookPart1.Workbook = workbook1;  
  9. }  

Now, let’s call the main function for generating Excel file into main method with passing our model into it.

Output of the Excel file would be similar to the below image.