Input string was not in a correct format

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using System.Web.Mvc;
using CsvHelper;
using CsvHelper.Configuration;
using DetalBmw;
using DetalBmw.Models;
using Nop.Core;
using Nop.Core.Data;
using Nop.Core.Domain.Bmw;
using Nop.Core.Domain.Catalog;
using Nop.Data;
using Nop.Services.Catalog;
using Nop.Services.Logging;
using Nop.Services.Security;
 
namespace Nop.Admin.Controllers
{
    public class DetalBMWController : BaseAdminController
    {
        public const int BATCH_SIZE = 3000;
        public const int BMW_CATEGORY_ID = 17;
        public const int MAX_IMPORT_SIZE = 500000;
 
        private IProductService _productService;
        private ICategoryService _categoryService;
        private IPermissionService _permissionService;
        private IRepository<BmwProduct> _bmwProductRepository;
        private IRepository<Product> _productRepository;
        private ILogger _logger;
 
 
        public DetalBMWController(IProductService productService
            , ICategoryService categoryService
            , ILogger logger
            , IPermissionService permissionService
            , IRepository<BmwProduct> bmwProductRepository
            , IRepository<Product> productRepository
            )
        {
            _productService = productService;
            _categoryService = categoryService;
            _permissionService = permissionService;
            _logger = logger;
            _bmwProductRepository = bmwProductRepository;
            _productRepository = productRepository;
        }
 
        public ActionResult Index()
        {
            if (!_permissionService.Authorize(StandardPermissionProvider.ManageProducts))
                return AccessDeniedView();
 
            return View();
        }
 
        [HttpPost]
        public ActionResult UploadPrice(HttpPostedFileBase pricelist)
        {
            if (pricelist.ContentLength > 0)
            {
                var category = _categoryService.GetCategoryById(BMW_CATEGORY_ID);
                var priceItems = GetPriceItems(pricelist.InputStream);
 
                _logger.Information("load all products");
                var allProducts = _productService.GetProductsByCategoryId(BMW_CATEGORY_ID)
                    .OrderBy(x => x.Sku)
                    .ToArray();
                _logger.Information("loaded products " + allProducts.Count());
 
                var productsToInsert = new List<Product>();
                var productsToUpdate = new List<Product>();
 
                _logger.Information("total items " + priceItems.Count());
 
                var allProductsMap = allProducts.ToDictionary(x => x.Sku, x => x);
                int i = 0;
                foreach (var item in priceItems)
                {
                    i++;
                    Product product;
                    if (allProductsMap.TryGetValue(SparePart.GetSku(item.Code), out product))
                    {
                        if (item.Count != product.StockQuantity
                                                   || item.Price != product.Price
                                                   || item.Price4Days != product.PriceStock
                                                   || item.PriceFast != product.PriceFastStock)
                        {
                            productsToUpdate.Add(UpdateProduct(product, item.Title, item.Count, item.Price, item.Price4Days, item.PriceFast));
                        }
                    }
                    else
                        productsToInsert.Add(CreateProduct(category, SparePart.GetSku(item.Code), item.Title, item.Count, item.Price, item.Price4Days, item.PriceFast));
 
                    if (productsToInsert.Count >= BATCH_SIZE)
                    {
                        _logger.Information($"insert products {productsToInsert.Count}");
                        _productRepository.AddRange(productsToInsert);
                        productsToInsert.Clear();
                    }
 
                    if (productsToUpdate.Count >= BATCH_SIZE)
                    {
                        _logger.Information($"update products {productsToUpdate.Count}");
                        _productRepository.Update(productsToUpdate);
                        productsToUpdate.Clear();
                    }
                }
                _productRepository.AddRange(productsToInsert);
                _productRepository.Update(productsToUpdate);
 
                _logger.Information("price update completed");
            }
 
            return View();
        }
 
        private void UploadProducts(IEnumerable<PriceItem> priceItems)
        {
            var first = priceItems.First();
            var bmwProducts = priceItems.Select(x => new BmwProduct()
            {
                CreatedOnUtc = DateTime.UtcNow,
                Price = x.Price,
                PriceFastStock = x.PriceFast,
                PriceStock = x.Price4Days,
                Sku = x.Code
            }).ToArray();
 
            foreach (var chunk in bmwProducts.Chunk(1000))
            {
                _bmwProductRepository.Insert(chunk);
                _bmwProductRepository.Detach(chunk.ToArray());
            }
        }
 
        private static Product CreateProduct(Nop.Core.Domain.Catalog.Category category, string sku, string title, int amount, decimal price, decimal priceStock, decimal priceFastStock)
        {
            var product = new Product
            {
                Price = price,
                Sku = sku,
                Name = title,
                CreatedOnUtc = DateTime.UtcNow,
                UpdatedOnUtc = DateTime.UtcNow,
                Published = true,
                ProductType = ProductType.SimpleProduct,
                StockQuantity = amount,
                OrderMinimumQuantity = 1,
                OrderMaximumQuantity = amount,
                CustomerEntersPrice = true,
                MinimumCustomerEnteredPrice = 0,
                MaximumCustomerEnteredPrice = int.MaxValue,
                PriceStock = priceStock,
                PriceFastStock = priceFastStock,
                VisibleIndividually = true,
                IsShipEnabled = false,
 
            };
            product.ProductCategories.Add(new ProductCategory { Category = category, Product = product });
 
            return product;
        }
 
        public static Product UpdateProduct(Product product, string title, int amount, decimal price, decimal priceStock, decimal priceFastStock)
        {
            product.Price = price;
            product.Name = title;
            product.UpdatedOnUtc = DateTime.UtcNow;
            product.StockQuantity = amount;
            product.Deleted = false;
            product.PriceStock = priceStock;
            product.PriceFastStock = priceFastStock;
            product.CustomerEntersPrice = true;
            product.MinimumCustomerEnteredPrice = 0;
            product.MaximumCustomerEnteredPrice = int.MaxValue;
            product.OrderMaximumQuantity = amount;
            product.OrderMinimumQuantity = 1;
 
            return product;
        }
 
        public void CreateOrUpdateProduct(ProductCategory category, string sku, string title, int amount, decimal price)
        {
 
            var product = _productService.GetProductBySku(sku);
            if (product == null)
            {
                product = new Product
                {
                    Price = price,
                    Sku = sku,
                    Name = title,
                    CreatedOnUtc = DateTime.UtcNow,
                    UpdatedOnUtc = DateTime.UtcNow,
                    Published = true,
                    ProductType = ProductType.SimpleProduct,
                    StockQuantity = amount,
                    OrderMinimumQuantity = 1
                };
                product.ProductCategories.Add(category);
                _productService.InsertProduct(product);
            }
            else
            {
                product.Price = price;
                product.Name = title;
                product.UpdatedOnUtc = DateTime.UtcNow;
                product.StockQuantity = amount;
                _productService.UpdateProduct(product);
            }
        }
 
        private static int ConvertToInt(string number)
        {
            number = number.Replace(",", "").Replace(".", "");
            return int.Parse(number);
        }
 
        private static decimal ConvertToDecimal(string number)
        {
            var ns = CultureInfo.CurrentCulture.NumberFormat;
            ns.NumberDecimalSeparator = ".";
 
            return decimal.Parse(number, ns);
        }
 
        private static IEnumerable<PriceItem> GetPriceItems(Stream stream)
        {
            int total = 0;
            var result = new List<PriceItem>();
            var ns = CultureInfo.CurrentCulture.NumberFormat;
            ns.NumberDecimalSeparator = ".";
 
            bool skipFirstLine = true;
 
            var cp1251 = Encoding.GetEncoding(1251);
 
            var csvConfig = new CsvConfiguration();
            csvConfig.Encoding = Encoding.GetEncoding("windows-1251");
 
            using (var streamReader = new StreamReader(stream, csvConfig.Encoding))
            {
                using (var reader = new CsvReader(streamReader, csvConfig))
                {
                    while (reader.Read())
                    {
                        if (skipFirstLine)
                        {
                            skipFirstLine = false;
                            continue;
                        }
 
                        var item = new PriceItem();
 
                        item.Code = reader.GetField(0);
                        item.Title = reader.GetField(1);
                        //item.Title = Encoding.Default.GetString(csvConfig.Encoding.GetBytes(item.Title));
 
                        item.Count = ConvertToInt(reader.GetField(2));
                        item.Price = ConvertToDecimal(reader.GetField(4));
                        item.Price4Days = ConvertToDecimal(reader.GetField(5));
                        item.PriceFast = ConvertToDecimal(reader.GetField(6));
 
                        result.Add(item);
 
                        total++;
 
                        if (total == MAX_IMPORT_SIZE)
                            break;
                    }
                }
                /*
                while (!streamReader.EndOfStream)
                {
                    var line = streamReader.ReadLine();
                    if (skipFirstLine)
                    {
                        skipFirstLine = false;
                        continue;
                    }
                    var values = line.Split(',');
                    
                    var item = new PriceItem();
                    
                    item.Code = values[0];
                    item.Title = values[1];
                    item.Count = int.Parse(values[2]);
 
                    item.Price = decimal.Parse(values[4], ns);
                    item.Price4Days = decimal.Parse(values[5], ns);
                    item.PriceFast = decimal.Parse(values[6], ns);
 
                    result.Add(item);
                    total++;
                    if (total >= MaxCount)
                    {
                        break;
                    }
                }
                */
            }
 
            return result.OrderBy(x => x.Code).ToArray();
        }
    }
 
    public class PriceItem
    {
        public string Code { get; set; }
        public decimal Price { get; set; }
        public decimal Price4Days { get; set; }
        public decimal PriceFast { get; set; }
        public string Title { get; set; }
        public int Count { get; set; }
 
    }
}

               _productRepository.AddRange(productsToInsert);
                _productRepository.Update(productsToUpdate);