Обработка больших объемов данных из Excel

using Microsoft.Office.Interop;
using System;
using System.IO;
using Excel = Microsoft.Office.Interop.Excel;
//Добавить пакет Microsoft Office Interop из NuGet 
namespace ns_Read_files
{
    class cl_Read_files
    {
        public static void Read_file_xls()
        {
            string lpath = @"C:\\PROJECTS\\C-Sharp\\Wpf_test\\Wpf_test\in";
 
            DirectoryInfo Dir_in = new DirectoryInfo(lpath);
 
            string lxls_file_name = "";
            int koll_file = 0;
            foreach (var fi in Dir_in.EnumerateFiles("*.xls?"))
            {
                koll_file++;
                lxls_file_name = fi.Name;
                //Console.WriteLine(fi.Name);
            }
 
            lpath = lpath + lxls_file_name;
 
            Excel.Application excelapp = new Excel.Application();
            excelapp.Visible = false; //Скрываем окно EXCEL
 
            //Получаем набор ссылок на объекты Workbook (на созданные книги)
            Excel.Workbooks excelappworkbooks = excelapp.Workbooks;
 
            //Открываем книгу и получаем на нее ссылку excelappworkbook =
            excelapp.Workbooks.Open(lpath,
            Type.Missing, Type.Missing, Type.Missing, Type.Missing,
            Type.Missing, Type.Missing, Type.Missing, Type.Missing,
            Type.Missing, Type.Missing, Type.Missing, Type.Missing,
            Type.Missing, Type.Missing);
 
            //Получаем ссылку на книгу 1 - нумерация от 1
            Excel.Workbook excelappworkbook = excelappworkbooks[1];
 
            Excel.Sheets excelsheets = excelappworkbook.Worksheets;
            //Получаем ссылку на лист 1
            Excel.Worksheet excelworksheet = (Excel.Worksheet)excelsheets.get_Item(1);
 
            //Выбираем ячейку для вывода A1
            Excel.Range excelcells;
 
 
            //string sStr = Convert.ToString(excelcells.Value2);
 
            int i = 13;
            string A, B, G, H, I, J;
            do
            {
 
                excelcells = excelworksheet.get_Range("A" + i, Type.Missing);
 
                A = Convert.ToString(excelworksheet.get_Range("A" + i, Type.Missing).Value2);
                B = Convert.ToString(excelworksheet.get_Range("B" + i, Type.Missing).Value2);
                G = Convert.ToString(excelworksheet.get_Range("G" + i, Type.Missing).Value2);
                H = Convert.ToString(excelworksheet.get_Range("H" + i, Type.Missing).Value2);
                I = Convert.ToString(excelworksheet.get_Range("I" + i, Type.Missing).Value2);
                J = Convert.ToString(excelworksheet.get_Range("J" + i, Type.Missing).Value2);
 
                //li_coll_xls.Add(new cl_Model_for_xls(A, B, G, H, I, J));
 
                i++;
 
            } while (excelcells.Value2 != null);
 
 
            //Закрываем без сохранения 
            excelapp.Quit();
            //MessageBox.Show("Ready!");
        }
    }
}

namespace ExcelRead_ver_0.1.8
{
    public static class ReadTZExcel
    {
        public static void XLReadTZ(FileStream fileStream, ref DataTable tableScenarios)
        {
            SLExcelData mExcelData = new SLExcelData();
            mExcelData = ReadExcel(fileStream, ref tableScenarios);            
        }
 
        private static string GetColumnName(string cellReference)
        {
            var regex = new Regex("[A-Za-z]+");
            var match = regex.Match(cellReference);
 
            return match.Value;
        }
 
        private static 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; // ASCII 'A' = 65
                convertedValue += current * (int)Math.Pow(26, i);
            }
 
            return convertedValue;
        }
 
        private static 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();
        }
 
        private static 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++;
            }
        }
 
        public static SLExcelData ReadExcel(FileStream file, ref DataTable tableScenarios)
        {
            var data = new SLExcelData();
 
            // Открыть excel документ
            WorkbookPart workbookPart; List<Row> rows;
            try
            {
                var document = SpreadsheetDocument.Open(file, 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;
            }
 
            // Прочитать заголовок
            int columnsCount = 0; // Получили колонок в таблице
            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();
                    if (text == "") continue;
                    data.Headers.Add(text);
                    tableScenarios.Columns.Add(text);
                    columnsCount++;
                }
            }
 
            // Прочитать данные
            if (rows.Count > 1)
            {
                string[] rowText = new string[columnsCount];
 
                for (var i = 1; i < rows.Count; i++)
                {
                    var dataRow = new List<string>();
                    data.DataRows.Add(dataRow);
                    var row = rows[i];
                    if (row.InnerText == "") break;
 
                    var cellEnumerator = GetExcelCellEnumerator(row);
                    int tmpCount = 0;
                    while (cellEnumerator.MoveNext())
                    {
                        var cell = cellEnumerator.Current;
                        var text = ReadExcelCell(cell, workbookPart).Trim();
                        dataRow.Add(text);
                        if (((text == "")&&(tmpCount==0)))
                            continue;
 
                        rowText[tmpCount] = text;
                        tmpCount++;
                    }
                    tableScenarios.Rows.Add(rowText);
                    Array.Clear(rowText, 0, rowText.Length);
                }
            }
            return data;
        }
 
    }
}

        internal void ImportFromExcel2003(string filePath)
        {
            HSSFWorkbook workbook;
            using (FileStream file = new FileStream(filePath, FileMode.Open, FileAccess.Read))
            {
                workbook = new HSSFWorkbook(file);
            }
            //work with workbook
        }
 
        internal void ImportFromExcel2007(string filePath)
        {
            XSSFWorkbook workbook;
            using (FileStream file = new FileStream(filePath, FileMode.Open, FileAccess.Read))
            {
                workbook = new XSSFWorkbook(file);
                //work with workbook
            }
        }

using NPOI.SS.UserModel;
 
    internal static class ExcelUtils
    {
        static readonly List<string> _supportedFormats = new List<string>()
        {
            ".xls", ".xlsx"
        };
 
        internal static IWorkbook OpenWorkbook(string filePath)
        {
            string ext = Path.GetExtension(filePath);
            if (!_supportedFormats.Contains(ext, StringComparer.InvariantCultureIgnoreCase))
            {
                throw new Exception("Тип документа не поддерживается");
            }
 
            IWorkbook workbook;
            using (FileStream file = new FileStream(filePath, FileMode.Open, FileAccess.Read))
            {
                workbook = WorkbookFactory.Create(file);
            }
 
            return workbook;
        }
    }