Exemple #1
0
        private void ProcessImport(ExcelWorksheet sheet, CancellationToken?ct = null)
        {
            if (sheet.Dimension == null)
            {
                throw new TableMappingException(string.Format(Strings.XlsxPageEmpty, _sheetName), 0);
            }

            var header = new string[sheet.Dimension.End.Column];

            if (MappingOptions.HasHeader)
            {
                for (var column = 1; column <= sheet.Dimension.End.Column; column++)
                {
                    header[column - 1] = sheet.Cells[1, column]
                                         ?.Text
                                         ?.Replace("\r", string.Empty)
                                         .Replace("\n", string.Empty)
                                         .Trim()
                                         .ToLower() ?? string.Empty;
                }
            }

            int headerCorrect = (MappingOptions.HasHeader ? 1 : 0);
            int startRow      = 1 + headerCorrect;
            int row           = 0;
            int indexRow      = row + headerCorrect;

            for (var rowI = startRow; rowI <= sheet.Dimension.End.Row; rowI++, row++, indexRow++)
            {
                ThrowIfRowsLimitEnabled(indexRow);

                var rowResult = new string[sheet.Dimension.End.Column];

                for (var column = 1; column <= sheet.Dimension.End.Column; column++)
                {
                    var value = sheet.Cells[rowI, column]?.Value?.ToString();

                    if (MappingOptions.Trim)
                    {
                        value = value?.Trim();
                    }

                    rowResult[column - 1] = value;
                }

                var entity = RowMapper.Map(rowResult, header, indexRow, MappingOptions.SuppressConvertTypeErrors);
                ValidateRow(entity, indexRow);
                RowSaver.SaveRow(entity);
            }

            RowSaver.SaveRemainder();
        }
Exemple #2
0
        private void ProcessImport(TextFieldParser parser, CancellationToken?ct = null)
        {
            int row      = 0;
            int indexRow = row + (MappingOptions.HasHeader ? 1 : 0);

            string[] header = { };


            while (!parser.EndOfData)
            {
                if (ct.HasValue && ct.Value.IsCancellationRequested)
                {
                    ct.Value.ThrowIfCancellationRequested();
                }

                ThrowIfRowsLimitEnabled(indexRow);

                if (row == 0)
                {
                    if (MappingOptions.HasHeader)
                    {
                        header = parser.ReadFields();
                        header = header?.Select(x => x.ToLower()).ToArray()
                                 ?? throw new TableMappingException(Strings.HeaderRowIsEmpty, indexRow);
                    }
                }
                else
                {
                    var fields = parser.ReadFields();
                    if (fields == null)
                    {
                        continue;
                    }

                    var entity = RowMapper.Map(fields, header, indexRow, MappingOptions.SuppressConvertTypeErrors);

                    ValidateRow(entity, indexRow);

                    RowSaver.SaveRow(entity);
                }
                row++;
                indexRow++;
            }

            RowSaver.SaveRemainder();
        }