String[] a = myString.split('|');

String[] b = a[20].split(':');

var row1 = Decimal.parse([5]);
var row2 = Datetime.parse([10]);

lock (lockObject)
{
DataRow row = table.NewRow() 
row[0] = a[1];
row[1] = row1;
row[2] = row2;

row[3] = b[0];
row[4] = b[30];

table.Add(row);
}

                    using (StreamReader sr = new StreamReader(args[4]))
                    {

                        StartTimer = DateTime.Now;
                        IndexOfRecords = 0;

                        Action<object> taskAction = (object obj) =>
                        {
                            importRecord((Int32)obj);
                        };
                        

                        while ((Records[IndexOfRecords] = sr.ReadLine()) != null)
                        {

                            tasks[IndexOfRecords] = Task.Factory.StartNew(taskAction, IndexOfRecords);


                            if ((IndexOfRecords + 1) % ReadBatchSize == 0)
                            {
                                Task.WaitAll(tasks);
                                Records = new String[ReadBatchSize];
                                IndexOfRecords = 0;
                            }
                            else
                            {
                                IndexOfRecords++;
                            }

                            if ((++TotalRecords) % WriteBatchSize == 0)
                            {
                                Task.WaitAll(tasks);
                                bulkCopy.WriteToServer(table);
                                table.Clear();
                                Console.WriteLine("Records: {0} CurrentTime: {1}", TotalRecords, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                            }
                        }
                    }
                    if (IndexOfRecords % ReadBatchSize != 0)
                    {
                        Task.WaitAll(tasks);
                        bulkCopy.WriteToServer(table);
                    }

                    bulkCopy.Close();
                    table.Clear();

                    EndTimer = DateTime.Now;

        private static void importRecord(Int32 Index)
        {
            String[] Columns = new String[11];
            Int32[] Value_ID = new Int32[20];
            Decimal[] Value_Changes = new Decimal[20];

            fSplit(Records[Index], '|', Columns);
            Records[Index] = null;
            
            String[] Values = Columns[10].Split(']'); 

            Int32 Id = 0;

            foreach(String Value in Values)
            {
                if(!String.IsNullOrEmpty(Value))
                {
                    String[] Value_structure = Value.Split('~');
                    Value_ID[Id] = Int32.Parse(Value_structure[0].Remove(0, 1));
                    Value_Changes[Id] = Decimal.Parse(Value_structure[2], ci);
                    Id++;
                }
            }

            var row1 = Convert.ToDateTime(Columns[1], ruRuCulture);
            var row4 = Decimal.Parse(Columns[4], ci);
            var row5 = Decimal.Parse(Columns[5], ci);
            var row6 = Decimal.Parse(Columns[6], ci);
            var row9 = String.IsNullOrEmpty(Columns[9]) ? Convert.DBNull : Decimal.Parse(Columns[9], ci);

            lock (ObjectLock)
            {
                
                DataRow row = table.NewRow();
                row[0] = Columns[0]; 
                row[1] = row1; 
                row[2] = Columns[2]; 
                row[3] = Columns[3]; 
                row[4] = row4; 
                row[5] = row5; 
                row[6] = row6; 
                row[7] = Columns[7]; 
                row[8] = Columns[8]; 
                row[9] = row9; 

                for (Int32 i = 0; i < Id; i++)
                {
                    row[i + 10] = Value_ID[i];
                    row[i + 30] = Value_Changes[i];
                } 
                
                table.Rows.Add(row);
            }
        }

        private static void fSplit(String src, char delim, String[] output)
        {
            int index = 0;
            int lindex = 0;
            int columnID = 0;
            int arrayID = 0;
            int[] array = { 0, 1, 3, 4, 5, 12, 16, 23, 25, 27, 30 };
            int i;

            while ((index = src.IndexOf(delim, lindex)) != -1)
            {
                for (i = 0; i < 11 && array[i] != columnID; i++) ;
                if (i < 11) output[arrayID++] = src.Substring(lindex, index - lindex);
                if (columnID >= 30) break;
                lindex = index + 1;
                index++;
                columnID++;
            }
        } 

class Program
{
    private static Object ObjectLock = new Object();

    private static DataTable table;
    private static SqlBulkCopy bulkCopy;
    private static String[] Records;
    private static CultureInfo ruRuCulture;
    private static CultureInfo ci;

    private static DataRow[] rows;

    private class Variables
    {
        public Int32 IndexOfRead { get; set; }
        public Int32 IndexOfWrite { get; set; }
    }


    static void Main(string[] args)
    {

        String SqlServer, SqlDatabase;

        Int32 ReadBatchSize, WriteBatchSize;
        Int32 IndexOfReadRecords, IndexOfWriteRecords;
        Int64 TotalRecords;
        Task[] tasks;

        DateTime StartTimer;
        DateTime EndTimer;

        try
        {

            ci = CultureInfo.InvariantCulture.Clone() as CultureInfo;
            ci.NumberFormat.NumberDecimalSeparator = ".";
            ruRuCulture = CultureInfo.GetCultureInfo("ru-Ru");

            SqlServer = args[0];
            SqlDatabase = args[1];

            table = new DataTable();
            bulkCopy = new SqlBulkCopy(GetConnectionString(SqlServer, SqlDatabase));

            SqlServer = args[0];
            SqlDatabase = args[1];

            ReadBatchSize = Convert.ToInt32(args[2]);
            WriteBatchSize = Convert.ToInt32(args[3]);
            Records = new String[ReadBatchSize];
            tasks = new Task[ReadBatchSize];

            MakeTable(ref table);
            ColumnMappings(ref bulkCopy);

            TotalRecords = 0;

            using (bulkCopy)
            {

                using (StreamReader sr = new StreamReader(args[4]))
                {

                    StartTimer = DateTime.Now;
                    IndexOfReadRecords = 0;
                    IndexOfWriteRecords = 0;

                    Action<object> taskAction = (object obj) => { importRecord((Variables)obj); };

                    rows = new DataRow[WriteBatchSize];
                    for (Int32 i = 0; i < WriteBatchSize; i++) { rows[i] = table.NewRow(); }

                    while ((Records[IndexOfReadRecords] = sr.ReadLine()) != null)
                    {

                        Variables Indexes = new Variables();
                        Indexes.IndexOfRead = IndexOfReadRecords;
                        Indexes.IndexOfWrite = IndexOfWriteRecords;

                        tasks[IndexOfReadRecords] = Task.Factory.StartNew(taskAction, Indexes);

                        if ((IndexOfReadRecords + 1) >= ReadBatchSize)
                        {
                            Task.WaitAll(tasks);
                            Records = new String[ReadBatchSize];
                            IndexOfReadRecords = 0;
                        }
                        else
                            IndexOfReadRecords++;

                        TotalRecords++;

                        if ((IndexOfWriteRecords + 1) >= WriteBatchSize)
                        {
                            Task.WaitAll(tasks);
                            bulkCopy.WriteToServer(rows);
                            Console.WriteLine("Records: {0} CurrentTime: {1}", TotalRecords, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                            IndexOfWriteRecords = 0;
                        }
                        else
                            IndexOfWriteRecords++;

                    }

                }
                if (IndexOfWriteRecords > 0)
                {
                    Task.WaitAll(tasks);
                    Array.Resize(ref rows, IndexOfWriteRecords);
                    bulkCopy.WriteToServer(rows);
                }

                bulkCopy.Close();

                EndTimer = DateTime.Now;
                Console.WriteLine("Records: {0}\nStartTime: {1}\nExecution Time: {2}", TotalRecords, StartTimer.ToString("yyyy-MM-dd HH:mm:ss"), new TimeSpan(EndTimer.Ticks - StartTimer.Ticks));
                Console.ReadKey();

            }
        }
        catch (AggregateException ae)
        {
            foreach (var e in ae.InnerExceptions)
            {
                Console.WriteLine("Import error:");
                Console.WriteLine(e.Message);
                Console.ReadKey();
            }
        }
        catch (Exception e)
        {
            Console.WriteLine("Import error:");
            Console.WriteLine(e.Message);
            Console.ReadKey();
        }

    }


    private static void importRecord(Variables objIndexes)
    {
        Int32 IndexRead = objIndexes.IndexOfRead;
        Int32 IndexWrite = objIndexes.IndexOfWrite;

        Object[] rowArray = new Object[50];
        String[] Columns = new String[11];
        Int32[] Value_ID = new Int32[20];
        Decimal[] Value_Changes = new Decimal[20];

        fSplit(Records[IndexRead], '|', Columns);
        Records[IndexRead] = null;

        rowArray[0] = Columns[0]; 
        rowArray[1] = Convert.ToDateTime(Columns[1], ruRuCulture); 
        rowArray[2] = Columns[2]; 
        rowArray[3] = Columns[3]; 
        rowArray[4] = Decimal.Parse(Columns[4], ci); 
        rowArray[5] = Decimal.Parse(Columns[5], ci); 
        rowArray[6] = Decimal.Parse(Columns[6], ci); 
        rowArray[7] = Columns[7]; 
        rowArray[8] = Columns[8]; 
        rowArray[9] = String.IsNullOrEmpty(Columns[9]) ? Convert.DBNull : Decimal.Parse(Columns[9], ci); 

        String[] Values = Columns[10].Split(']'); 

        Int32 Id = 10;

        foreach (String Value in Values)
        {
            if (!String.IsNullOrEmpty(Value))
            {
                String[] Value_structure = Value.Split('~');
                rowArray[Id + 0] = Int32.Parse(Value_structure[0].Remove(0, 1));
                rowArray[Id + 20] = Decimal.Parse(Value_structure[2], ci);
                Id++;
            }
        }

        lock (ObjectLock)
        {
            rows[IndexWrite].ItemArray = rowArray;
        }
    }

    private static void fSplit(String src, char delim, String[] output)
    {
        int index = 0;
        int lindex = 0;
        int columnID = 0;
        int arrayID = 0;
        int[] array = { 0, 1, 3, 4, 5, 12, 16, 23, 25, 27, 30 };
        int i;

        while ((index = src.IndexOf(delim, lindex)) != -1)
        {
            for (i = 0; i < 11 && array[i] != columnID; i++) ;
            if (i < 11) output[arrayID++] = src.Substring(lindex, index - lindex);
            if (columnID >= 30) break;
            lindex = index + 1;
            index++;
            columnID++;
        }
    }


}

Task.WaitAll(tasks); // подождем пока все разберется, при этом ничего другого не делаем (почему)
bulkCopy.WriteToServer(rows); // теперь запишем все на сервер, в это время ничего другого не делаем (почему)