Не хватает памяти

Task<ObservableCollection<RecordRegZhur>> task_get_data = new Task<ObservableCollection<RecordRegZhur>>(()=> db_work.GetDataFromFile());
task_get_data.Start();
CollectionData = task_get_data.Result;

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations.Schema;
using System.Data;
using System.Data.Entity;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApp12
{
    class Program
    {
        const int COUNT_RECORD = 10_000_000;
 
        static DatabaseContext context = new DatabaseContext();
        static Random rnd = new Random();
 
        static void Main(string[] args)
        {
            Console.OutputEncoding = Encoding.UTF8;
 
            CheckTableIsEmpty();
 
            //Загружаем всю таблицу в память
            context.Records.Load();
            //Получаем таблицу в виде ObservableCollection<RecordDb>, ее можно менять как угодно context.SaveChanges() синхронизирует ее с базой данных.
            var ourCollection = context.Records.Local;
 
        }
 
        private static void CheckTableIsEmpty()
        {
            if (!context.Records.Any())
            {
                Console.WriteLine($"Таблица пуста. Генерируем {COUNT_RECORD} записей...");
 
                var alpabet = "qwertyuioplkjhgfdsazxcvbnmMNBVCXZASDFGHJKLPOIUYTREWQ";
                var buffer = new BlockingCollection<RecordDb>(COUNT_RECORD);
 
                Parallel.For(0, COUNT_RECORD, i =>
                {
                    buffer.Add(new RecordDb()
                    {
                        Id = Guid.NewGuid(),
                        Field1 = $"Record {i}",
                        Field2 = string.Join("", alpabet.OrderBy(x => rnd.Next()).Take(6)),
                        Field3 = string.Join("", alpabet.OrderBy(x => rnd.Next()).Take(12)),
                    });
                });
 
                Console.WriteLine("Сохранение...");
 
                var objBulk = new BulkUploadToSql<RecordDb>()
                {
                    InternalStore = buffer.ToList(),
                    TableName = "RecordDbs",
                    CommitBatchSize = 1000,
                    ConnectionString = context.Database.Connection.ConnectionString
                };
 
                objBulk.Commit();
                Console.WriteLine("Готово.");
            }
        }
    }
 
    public class RecordDb
    {
        public Guid Id { get; set; }
        public string Field1 { get; set; }
        public string Field2 { get; set; }
        public string Field3 { get; set; }
    }
 
    public class DatabaseContext : DbContext
    {
        public DbSet<RecordDb> Records { get; set; }
 
        public DatabaseContext() : base("DatabaseContext") { }
 
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
 
            modelBuilder.Entity<RecordDb>().HasKey(x => x.Id).Property(x => x.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
        }
    }
 
    #region SqlBulkUpload
    public class BulkUploadToSql<T>
    {
        public IList<T> InternalStore { get; set; }
        public string TableName { get; set; }
        public int CommitBatchSize { get; set; } = 1000;
        public string ConnectionString { get; set; }
 
        public void Commit()
        {
            if (InternalStore.Count > 0)
            {
                DataTable dt;
                int numberOfPages = (InternalStore.Count / CommitBatchSize) + (InternalStore.Count % CommitBatchSize == 0 ? 0 : 1);
                for (int pageIndex = 0; pageIndex < numberOfPages; pageIndex++)
                {
                    dt = InternalStore.Skip(pageIndex * CommitBatchSize).Take(CommitBatchSize).ToDataTable();
                    BulkInsert(dt);
                }
            }
        }
 
        public void BulkInsert(DataTable dt)
        {
            using (SqlConnection connection = new SqlConnection(ConnectionString))
            {
                SqlBulkCopy bulkCopy = new SqlBulkCopy(connection, SqlBulkCopyOptions.TableLock | SqlBulkCopyOptions.FireTriggers | SqlBulkCopyOptions.UseInternalTransaction, null)
                {
                    DestinationTableName = TableName
                };
 
                connection.Open();
                bulkCopy.WriteToServer(dt);
                connection.Close();
            }
        }
    }
 
    public static class BulkUploadToSqlHelper
    {
        public static DataTable ToDataTable<T>(this IEnumerable<T> data)
        {
            PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(typeof(T));
            DataTable table = new DataTable();
            foreach (PropertyDescriptor prop in properties)
                table.Columns.Add(prop.Name, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType);
            foreach (T item in data)
            {
                DataRow row = table.NewRow();
                foreach (PropertyDescriptor prop in properties)
                    row[prop.Name] = prop.GetValue(item) ?? DBNull.Value;
                table.Rows.Add(row);
            }
            return table;
        }
    }
    #endregion
 
}