public abstract class OpenXmlReaderBase : IDisposable
    {
        protected const string DEFAULT_TRUE_STR = "true";
        protected const string DEFAULT_FALSE_STR = "false";
        protected const string DIGITAL_TRUE_STR = "1";
        protected const string DIGITAL_FALSE_STR = "0";

        protected SpreadsheetDocument Doc { get; set; }
        protected WorkbookPart WorkbookPart { get; set; }
        protected SharedStringTablePart StringTable { get; set; }
        protected Sheet[] Sheets { get; set; }
        protected Sheet CurrentSheet { get; set; }
        protected WorksheetPart CurrentWorksheetPart { get; set; }

        public int GetSheetsCount()
        {
            if (Sheets is null)
                return 0;
            return Sheets.Length;
        }

        public void OpenFile(string path)
        {
            Doc = SpreadsheetDocument.Open(path, false);
            WorkbookPart = Doc.WorkbookPart;
            Sheets = WorkbookPart.Workbook.Descendants<Sheet>().Where(item =>
                    !(item.State != null && item.State.HasValue &&
                      (item.State.Value == SheetStateValues.Hidden || item.State.Value == SheetStateValues.VeryHidden)))
                .ToArray();
            StringTable = WorkbookPart.GetPartsOfType<SharedStringTablePart>().FirstOrDefault();
        }

        public string GetActiveSheetName()
        {
            return CurrentSheet?.Name;
        }

        public abstract bool SetActiveSheet(int idx);
        public abstract Row GetRow(int idx);

        public Cell FindCell(int rowId, string cellReference)
        {
            // получить строку
            var row = GetRow(rowId);
            if (row is null)
                return null;
            // получить ячейку
            if (!row.HasChildren)
                return null;
            var cell = row.ChildElements.Where(x => (x as Cell).CellReference == cellReference).FirstOrDefault();
            return (Cell)cell;
        }

        public Cell FindCellInRow(int rowId, string column)
        {
            // получить строку
            var row = GetRow(rowId);
            if (row is null)
                return null;
            // получить ячейку
            if (!row.HasChildren)
                return null;
            var cell = row.GetCell(column);
            return cell;
        }

        #region get cell value

        public string GetCellValueAsString(Cell cell)
        {
            if (null == cell)
                return string.Empty;
            var value = cell.InnerText;
            if (null == cell.DataType)
                return value;
            switch (cell.DataType.Value)
            {
                case CellValues.String:
                    value = string.IsNullOrEmpty(cell.CellValue?.InnerText) ? cell.InnerText : cell.CellValue.InnerText;
                    break;
                case CellValues.SharedString:
                    if (StringTable != null)
                        value = StringTable.SharedStringTable.ElementAt(int.Parse(value)).InnerText;
                    break;
                case CellValues.Boolean:
                    value = string.Equals(cell.InnerText, DIGITAL_TRUE_STR) ? DEFAULT_TRUE_STR : DEFAULT_FALSE_STR;
                    break;
            }

            return value;
        }

        public bool GetCellValueAsBoolOrDefault(Cell cell)
        {
            if (cell.DataType.HasValue && CellValues.Boolean == cell.DataType.Value)
                return string.Equals(cell.InnerText, DIGITAL_TRUE_STR);
            if (bool.TryParse(cell.InnerText, out var res))
                return res;
            return !string.IsNullOrEmpty(cell.InnerText);
        }

        public bool? GetCellValueAsBoolOrNull(Cell cell, string trueVal = DEFAULT_TRUE_STR)
        {
            if (string.IsNullOrEmpty(cell.InnerText))
                return null;
            if (cell.DataType.HasValue && CellValues.Boolean == cell.DataType.Value)
                return string.Equals(cell.InnerText, DIGITAL_TRUE_STR);
            return string.Equals(cell.InnerText, trueVal);
        }

        public double GetCellValueAsDoubleOrDefault(Cell cell)
        {
            var valStr = string.IsNullOrEmpty(cell.CellValue?.InnerText) ? cell.InnerText : cell.CellValue.InnerText;
            double.TryParse(valStr, NumberStyles.Any, CultureInfo.InvariantCulture, out var result);
            return result;
        }

        public double? GetCellValueAsDoubleOrNull(Cell cell)
        {
            if (string.IsNullOrEmpty(cell.InnerText))
                return null;
            return GetCellValueAsDoubleOrDefault(cell);
        }

        public decimal GetCellValueAsDecimalOrDefault(Cell cell)
        {
            decimal.TryParse(cell.InnerText, NumberStyles.Any, CultureInfo.InvariantCulture, out var result);
            return result;
        }

        public decimal? GetCellValueAsDecimalOrNull(Cell cell)
        {
            if (string.IsNullOrEmpty(cell.InnerText))
                return null;
            return GetCellValueAsDecimalOrDefault(cell);
        }

        public long GetCellValueAsLongOrDefault(Cell cell)
        {
            var result = GetCellValueAsDecimalOrDefault(cell);
            return (long)result;
        }

        public long? GetCellValueAsLongOrNull(Cell cell)
        {
            if (cell == null || string.IsNullOrEmpty(cell.InnerText))
                return null;
            return (long)GetCellValueAsDecimalOrDefault(cell);
        }

        public DateTime GetCellValueAsDateTimeOrDefault(Cell cell)
        {
            var days = GetCellValueAsDoubleOrDefault(cell);
            return CalculateDateTimeFromDaysFromEpoch(days);
        }

        public DateTime? GetCellValueAsDateTimeOrNull(Cell cell)
        {
            if (string.IsNullOrEmpty(cell.InnerText))
                return null;
            return GetCellValueAsDateTimeOrDefault(cell);
        }

        #endregion

        private DateTime CalculateDateTimeFromDaysFromEpoch(double days)
        {
            // Microsoft Excel for Windows uses 1 Jan 1900 as the epoch
            // Microsoft Excel for Macintosh uses 1 Jan 1904 as the epoch
            var for1904Epoch = WorkbookPart.Workbook.WorkbookProperties.Date1904;
            if (for1904Epoch is null)
                for1904Epoch = false;
            var dtEpoch = for1904Epoch ? Epoch1904 : Epoch1900;

            DateTime dt;

            if (for1904Epoch)
                dt = dtEpoch.AddDays(days);
            else
                dt = days < 59 ? dtEpoch.AddDays(days - 1.0) : dt = dtEpoch.AddDays(days - 2.0);

            return dt;
        }

        private static readonly DateTime Epoch1900 = new DateTime(1900, 1, 1);
        private static readonly DateTime Epoch1904 = new DateTime(1904, 1, 1);

        #region IDisposable Support

        private bool disposedValue; // To detect redundant calls

        protected virtual void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                    if (null != Doc)
                    {
                        Doc.Close();
                        Doc.Dispose();
                    }

                Doc = null;
                disposedValue = true;
            }
        }

        // This code added to correctly implement the disposable pattern.
        public void Dispose()
        {
            // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
            Dispose(true);
        }

        #endregion
    }

    public class ExcelReader : OpenXmlReaderBase
    {
        protected const string DEFAULT_TRUE_STR = "true";
        protected const string DEFAULT_FALSE_STR = "false";
        protected const string DIGITAL_TRUE_STR = "1";
        protected const string DIGITAL_FALSE_STR = "0";

        public int RowsCount
        {
            get
            {
                if (rowsCount == -1) rowsCount = GetAllRows().Count;
                rowsCount = GetAllRows().Count;
                return rowsCount;
            }
        }



        private int rowsCount = -1;


        public void OpenFile(Stream stream)
        {
            Doc = SpreadsheetDocument.Open(stream, false);
            WorkbookPart = Doc.WorkbookPart;
            Sheets = WorkbookPart.Workbook.Descendants<Sheet>().Where(item =>
                    !(item.State != null && item.State.HasValue &&
                      (item.State.Value == SheetStateValues.Hidden || item.State.Value == SheetStateValues.VeryHidden)))
                .ToArray();
            StringTable = WorkbookPart.GetPartsOfType<SharedStringTablePart>().FirstOrDefault();
        }

        public void OpenFile(String path)
        {
            Doc = SpreadsheetDocument.Open(path, false);
            WorkbookPart = Doc.WorkbookPart;
            Sheets = WorkbookPart.Workbook.Descendants<Sheet>().Where(item =>
                    !(item.State != null && item.State.HasValue &&
                      (item.State.Value == SheetStateValues.Hidden || item.State.Value == SheetStateValues.VeryHidden)))
                .ToArray();
            StringTable = WorkbookPart.GetPartsOfType<SharedStringTablePart>().FirstOrDefault();
        }

        private static readonly Type ROW_TYPE = typeof(Row);


        public override Row GetRow(int idx)
        {
            var idxStr = idx.ToString();
            //var stream = CurrentWorksheetPart.GetStream();

            using (var reader = OpenXmlReader.Create(CurrentWorksheetPart))
            {
                while (reader.Read())
                    if (ROW_TYPE == reader.ElementType)
                    {
                        do
                        {
                            var rowNum = reader.Attributes.First(a => a.LocalName == "r").Value;
                            if (string.Equals(idxStr, rowNum))
                            {
                                var row = reader.LoadCurrentElement() as Row;
                                return row;
                            }
                        } while (reader.ReadNextSibling());

                        break;
                    }

                reader.Close();
            }

            return null;
        }

        public List<Row> GetAllRows()
        {
            var rows = new List<Row>();

            using (var reader = OpenXmlReader.Create(CurrentWorksheetPart))
            {
                while (reader.Read())
                    if (ROW_TYPE == reader.ElementType)
                    {
                        do
                        {
                            var rowNum = reader.Attributes.First(a => a.LocalName == "r").Value;

                            rows.Add(reader.LoadCurrentElement() as Row);
                        } while (reader.ReadNextSibling());

                        break;
                    }

                reader.Close();
            }

            return rows;
        }

        public Row GetFirstRow()
        {
            using (var reader = OpenXmlReader.Create(CurrentWorksheetPart))
            {
                while (reader.Read())
                    if (ROW_TYPE == reader.ElementType)
                        return reader.LoadCurrentElement() as Row;
            }

            return null;
        }

        public override bool SetActiveSheet(int idx)
        {
            if (Sheets is null || Sheets.Length <= idx)
                return false;
            CurrentSheet = Sheets[idx];
            CurrentWorksheetPart = (WorksheetPart)WorkbookPart.GetPartById(CurrentSheet.Id);
            return true;
        }
    }

    public static class RowExtention
    {
        public static Cell GetCell(this Row row, string clmnRef)
        {
            if (!row.HasChildren)
                return null;
            var cellRef = clmnRef + row.RowIndex;
            var cell = row.ChildElements.Where(x => (x as Cell).CellReference == cellRef).FirstOrDefault();
            return (Cell)cell;
        }

        public static Cell GetCellByRef(this Row row, string cellRef)
        {
            if (!row.HasChildren)
                return null;

            var cell = row.ChildElements.Where(x => (x as Cell).CellReference == cellRef).FirstOrDefault();
            return (Cell)cell;
        }
    }