//Создание нового файла .xls:

string file = "C:\\newdoc.xls";
Workbook workbook = new Workbook();
Worksheet worksheet = new Worksheet("First Sheet");
worksheet.Cells[0, 1] = new Cell((short)1);
worksheet.Cells[2, 0] = new Cell(9999999);
worksheet.Cells[3, 3] = new Cell((decimal)3.45);
worksheet.Cells[2, 2] = new Cell("Text string");
worksheet.Cells[2, 4] = new Cell("Second string");
worksheet.Cells[4, 0] = new Cell(32764.5, "#,##0.00");
worksheet.Cells[5, 1] = new Cell(DateTime.Now, @"YYYY-MM-DD");
worksheet.Cells.ColumnWidth[0, 1] = 3000;
workbook.Worksheets.Add(worksheet);
workbook.Save(file);

// Открытие файла книги xls:
Workbook book = Workbook.Load(file);
Worksheet sheet = book.Worksheets[0];

// Итерация по ячейкам листа:

foreach (Pair, Cell > cell in sheet.Cells)
{
   dgvCells[cell.Left.Right, cell.Left.Left].Value = cell.Right.Value;
}

// Итерация по строкам с использованием индекса:

for (int rowIndex = sheet.Cells.FirstRowIndex;
     rowIndex < = sheet.Cells.LastRowIndex;
     rowIndex++)
{
   Row row = sheet.Cells.GetRow(rowIndex);
   for (int colIndex = row.FirstColIndex;
        colIndex < = row.LastColIndex;
        colIndex++)
   {
      Cell cell = row.GetCell(colIndex);
   }
}

// Создание набора данных (DataSet) и таблицы данных (DataTable):
DataSet ds = new DataSet("New_DataSet");
DataTable dt = new DataTable("New_DataTable");

// Установка локали для них:
ds.Locale = System.Threading.Thread.CurrentThread.CurrentCulture;
dt.Locale = System.Threading.Thread.CurrentThread.CurrentCulture;

// Подключение к базе данных (в этом примере база OleDB)
OleDbConnection con = new OleDbConnection(dbConnectionString);
con.Open();

// Создание таблицы и заполнение её данными из базы:

string sql = "SELECT Whatever FROM MyDBTable;";
OleDbCommand cmd = new OleDbCommand(sql, con);
OleDbDataAdapter adptr = new OleDbDataAdapter();

adptr.SelectCommand = cmd;
adptr.Fill(dt);
con.Close();

// Добавление таблицы к DataSet:
ds.Tables.Add(dt);

ExcelLibrary.DataSetHelper.CreateWorkbook("MyExcelFile.xls", ds);

worksheet.Cells["A1:C1,C3"].Style.Font.Bold = true;

worksheet.Cells["B2:B3"].Style.NumberFormat.Format = "#,##0.00";

worksheet.Cells["C11"].Formula="SUBTOTAL(9,\"C1:C10\")";

using OfficeOpenXml;

using System.IO;  // Для FileInfo

// Создание чистой книги(workbook). Используйте оператор using,

// чтобы удалить пакет по завершению работы.

using (var p = new ExcelPackage())
{
   // Книга должна состоять как минимум из листа и нескольких ячеек.
   // Добавим их.
   var ws=p.Workbook.Worksheets.Add("MySheet");
   // Для  установки значений на листе используется индексатор Cells.
   ws.Cells["A1"].Value = "This is cell A1";
   // Сохранение новой книги. Имя файла не было указано, поэтому
   // используйте метод SaveAs (сохранить как).
   p.SaveAs(new FileInfo(@"c:\workbooks\myworkbook.xlsx"));
}

// Открыть книгу (или создать её, если такого файла нет):

var fi=new FileInfo(@"c:\workbooks\myworkbook.xlsx");

using (var p = new ExcelPackage(fi))
{
   // Получение листа (Worksheet), созданного в предыдущем примере:
   var ws=p.Workbook.Worksheets["MySheet"];
   // Установка значения ячейки с использованием строки и колонки.
   ws.Cells[2, 1].Value = "This is cell A2. It is set to bolds";
   // Объект Style дает доступ к форматированию и стилям содержимого
   // ячеек. В этом примере текст делается "жирным":
   ws.Cells[2, 1].Style.Font.Bold=true;
   // Сохранение файла и закрытие пакета:
   p.Save();
}

// Создание нового экземпляра ExcelPackage:

using (ExcelPackage excelPackage = new ExcelPackage())
{
   // Установка некоторых свойств документа Excel:
   excelPackage.Workbook.Properties.Author = "VDWWD";
   excelPackage.Workbook.Properties.Title = "Title of Document";
   excelPackage.Workbook.Properties.Subject = "EPPlus demo export data";
   excelPackage.Workbook.Properties.Created = DateTime.Now;

   // Создание листа:
   ExcelWorksheet worksheet = excelPackage.Workbook.Worksheets.Add("Sheet 1");

   // Добавление текста в ячейку A1:
   worksheet.Cells["A1"].Value = "My first EPPlus spreadsheet!";

   // Для адресации ячейки можно также использовать нотацию [строка, столбец]:
   worksheet.Cells[1,2].Value = "This is cell B1!";

   // Сохранение файла:
   FileInfo fi = new FileInfo(@"Path\To\Your\File.xlsx");
   excelPackage.SaveAs(fi);
}

// Открытие существующего файла Excel:
FileInfo fi = new FileInfo(@"Path\To\Your\File.xlsx");

using (ExcelPackage excelPackage = new ExcelPackage(fi))
{
   // Получение листа по индексу. Обратите внимание, что EPPlus
   // использует индексы начиная с 1, не с 0!
   ExcelWorksheet firstWorksheet = excelPackage.Workbook.Worksheets[1];
    
   // Получение листа по имени. Если этот worksheet не существует,
   // выбрасывается исключение:
   ExcelWorksheet namedWorksheet = excelPackage.Workbook.Worksheets["SomeWorksheet"];

   // Если неизвестно, существует ли лист, можно использовать LINQ,
   // чтобы не попасть в исключение. Тогда будет возвращен null,
   // если лист не найден:
   ExcelWorksheet anotherWorksheet = 
      excelPackage.Workbook.Worksheets.FirstOrDefault(x=>x.Name=="SomeWorksheet");

   // Получение содержимого ячеек из A1 и B1 в виде строки, с помощью 
   // двух разных нотаций:
   string valA1 = firstWorksheet.Cells["A1"].Value.ToString();
   string valB1 = firstWorksheet.Cells[1,2].Value.ToString();

   // Сохранение файла:
   excelPackage.Save();
}

static string ReadExcel()
{
   DataTable dtTable = new DataTable();
   List< string> rowList = new List< string>();
   ISheet sheet;
   using (var stream = new FileStream("TestData.xlsx", FileMode.Open))
   {
      stream.Position = 0;
      XSSFWorkbook xssWorkbook = new XSSFWorkbook(stream);
      sheet = xssWorkbook.GetSheetAt(0);
      IRow headerRow = sheet.GetRow(0);
      int cellCount = headerRow.LastCellNum;
      for (int j = 0; j < cellCount; j++)
      {
         ICell cell = headerRow.GetCell(j);
         if (cell == null || string.IsNullOrWhiteSpace(cell.ToString())) continue;
         {
            dtTable.Columns.Add(cell.ToString());
         } 
      }
      for (int i = (sheet.FirstRowNum + 1); i < = sheet.LastRowNum; i++)
      {
         IRow row = sheet.GetRow(i);
         if (row == null) continue;
         if (row.Cells.All(d => d.CellType == CellType.Blank)) continue;
         for (int j = row.FirstCellNum; j < cellCount; j++)
         {
            if (row.GetCell(j) != null)
            {
               if (!string.IsNullOrEmpty(row.GetCell(j).ToString()) &&
                   !string.IsNullOrWhiteSpace(row.GetCell(j).ToString()))
               {
                  rowList.Add(row.GetCell(j).ToString());
               }
            }
         }
         if(rowList.Count > 0)
            dtTable.Rows.Add(rowList.ToArray());
         rowList.Clear(); 
      }
   }
   return JsonConvert.SerializeObject(dtTable);
}

static void WriteExcel()
{
   List< UserDetails> persons = new List< UserDetails>()
   {
       new UserDetails() {ID="1001", Name="ABCD", City ="City1", Country="USA"},
       new UserDetails() {ID="1002", Name="PQRS", City ="City2", Country="INDIA"},
       new UserDetails() {ID="1003", Name="XYZZ", City ="City3", Country="CHINA"},
       new UserDetails() {ID="1004", Name="LMNO", City ="City4", Country="UK"},
   };

   // Преобразуем наши данные объектов в таблицу Datatable.
   // Datatable дает простой способ чтения и форматирования
   // сложных типов данных.
   DataTable table = (DataTable)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(persons),
                                                              (typeof(DataTable)));
   var memoryStream = new MemoryStream();
    
   using (var fs = new FileStream("Result.xlsx", FileMode.Create, FileAccess.Write))
   {
      IWorkbook workbook = new XSSFWorkbook();
      ISheet excelSheet = workbook.CreateSheet("Sheet1");
      List< String> columns = new List< string>();
      IRow row = excelSheet.CreateRow(0);
      int columnIndex = 0;
      
      foreach (System.Data.DataColumn column in table.Columns)
      {
         columns.Add(column.ColumnName);
         row.CreateCell(columnIndex).SetCellValue(column.ColumnName);
         columnIndex++;
      }
      int rowIndex = 1;
      foreach (DataRow dsrow in table.Rows)
      {
         row = excelSheet.CreateRow(rowIndex);
         int cellIndex = 0;
         foreach (String col in columns)
         {
            row.CreateCell(cellIndex).SetCellValue(dsrow[col].ToString());
            cellIndex++;
         }
         rowIndex++;
      }
      workbook.Write(fs);
   }
}

static void ReadExcelFile()
{
   try
   {
      // Откроем существующий файл Excel и прочитаем его содержимое.
      using (SpreadsheetDocument doc = SpreadsheetDocument.Open("testdata.xlsx", false))
      {
         // Создадим объект для части книги (класс WorkbookPart):
         WorkbookPart workbookPart = doc.WorkbookPart;
         Sheets thesheetcollection = workbookPart.Workbook.GetFirstChild< Sheets>();
         StringBuilder excelResult = new StringBuilder();

         // Пройдемся в цикле по листу в thesheetcollection:  
         foreach (Sheet thesheet in thesheetcollection)
         {
            excelResult.AppendLine("Excel Sheet Name : " + thesheet.Name);
            excelResult.AppendLine("----------------------------------------------- ");
            // Оператор для получения объекта worksheet по идентификатору листа:
            Worksheet theWorksheet = ((WorksheetPart)workbookPart.GetPartById(thesheet.Id)).Worksheet;

            SheetData thesheetdata = (SheetData)theWorksheet.GetFirstChild< SheetData>();
            foreach (Row thecurrentrow in thesheetdata)
            {
               foreach (Cell thecurrentcell in thecurrentrow)
               {
                  // Оператор для взятия значения целого числа из ячейки:
                  string currentcellvalue = string.Empty;
                  if (thecurrentcell.DataType != null)
                  {
                     if (thecurrentcell.DataType == CellValues.SharedString)
                     {
                        int id;
                        if (Int32.TryParse(thecurrentcell.InnerText, out id))
                        {
                           SharedStringItem item = workbookPart.SharedStringTablePart.
                                    SharedStringTable.Elements< SharedStringItem>().ElementAt(id);
                           if (item.Text != null)
                           {
                              // Код получения значения строки:
                              excelResult.Append(item.Text.Text + " ");
                           }
                           else if (item.InnerText != null)
                           {
                              currentcellvalue = item.InnerText;
                           }
                           else if (item.InnerXml != null)
                           {
                              currentcellvalue = item.InnerXml;
                           }
                        }
                     }
                  }
                  else
                  {
                     excelResult.Append(Convert.ToInt16(thecurrentcell.InnerText) + " ");
                  }
               }
               excelResult.AppendLine();
            }
            excelResult.Append("");
            Console.WriteLine(excelResult.ToString());
            Console.ReadLine();
         }
      }
   }
   catch (Exception)
   {
   }
}

static void WriteExcelFile()
{
   List< UserDetails> persons = new List< UserDetails>()
   {
      new UserDetails() {ID="1001", Name="ABCD", City ="City1", Country="USA"},
      new UserDetails() {ID="1002", Name="PQRS", City ="City2", Country="INDIA"},
      new UserDetails() {ID="1003", Name="XYZZ", City ="City3", Country="CHINA"},
      new UserDetails() {ID="1004", Name="LMNO", City ="City4", Country="UK"},
   };

   DataTable table = (DataTable)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(persons),
                                                              (typeof(DataTable)));
   using (SpreadsheetDocument document = SpreadsheetDocument.Create("TestNewData.xlsx",
                                                     SpreadsheetDocumentType.Workbook))
   {
      WorkbookPart workbookPart = document.AddWorkbookPart();
      workbookPart.Workbook = new Workbook();

      WorksheetPart worksheetPart = workbookPart.AddNewPart< WorksheetPart>();
      var sheetData = new SheetData();
      worksheetPart.Worksheet = new Worksheet(sheetData);

      Sheets sheets = workbookPart.Workbook.AppendChild(new Sheets());
      Sheet sheet = new Sheet()
      {
         Id = workbookPart.GetIdOfPart(worksheetPart),
         SheetId = 1,
         Name = "Sheet1"
      };

      sheets.Append(sheet);
      Row headerRow = new Row();

      List< String> columns = new List< string>();
      foreach (System.Data.DataColumn column in table.Columns)
      {
         columns.Add(column.ColumnName);
         Cell cell = new Cell();
         cell.DataType = CellValues.String;
         cell.CellValue = new CellValue(column.ColumnName);
         headerRow.AppendChild(cell);
      }

      sheetData.AppendChild(headerRow);
      foreach (DataRow dsrow in table.Rows)
      {
         Row newRow = new Row();
         foreach (String col in columns)
         {
            Cell cell = new Cell();
            cell.DataType = CellValues.String;
            cell.CellValue = new CellValue(dsrow[col].ToString());
            newRow.AppendChild(cell);
         }
         sheetData.AppendChild(newRow);
      }
      workbookPart.Workbook.Save();
   }
}