第十五節：EF Core大數據量處理(一)之EFCore.BulkExtensions

一. 各種性能測試

 　　這里分享EF、EFCore、EF Core調用SQL語句 分別在1000條、1w、4w、10w下的增刪改查需要的時間。（括號里代表的都是對應的range方法）

1. EF測試 

 2. EFCore測試

  3. EF Core調用SQL語句

 4.  EFCore組裝成SQL語句，insert組裝成單條。

 

二. EFCore.BulkExtensions用法和性能測試

1. 說明

【該組件已收費，后續不再更新和使用】

　　通過Nuget安裝程序集【EFCore.BulkExtensions】，該程序集目前版本【3.1.0】，支持CRUD操作，支持的數據庫僅有：SQLServer和SQLite，它是免費開源的。

　　GitHub地址：https://github.com/borisdj/EFCore.BulkExtensions

2. 用法說明

(1).Bulk相關(一條操作一個事務，均是傳入實體)

　A.增加：BulkInsert

　B.修改：BulkUpdate，需要傳入完整實體,不傳的字段就會被更新為空

　C.增加或修改：BulkInsertOrUpdate (主鍵存在執行update，不存在執行insert)

　D.刪除：BulkDelete 和 Truncate(刪除整張表)

PS：以上方法均支持Async異步方法。

              //1. 增加
                List<T_UserInfor> ulist1 = new List<T_UserInfor>();
                for (int i = 0; i < 100; i++)
                {
                    T_UserInfor userInfor = new T_UserInfor()
                    {
                        id = i.ToString(),
                        userName = "ypf",
                        userSex = "男",
                        userAge = 111,
                        addTime = DateTime.Now
                    };
                    ulist1.Add(userInfor);
                }
                dbContext.BulkInsert(ulist1);

                //2. 修改
                List<T_UserInfor> ulist2 = new List<T_UserInfor>();
                for (int i = 0; i < 100; i++)
                {
                    //此處不寫的字段就會被更新成null了
                    T_UserInfor userInfor = new T_UserInfor()
                    {
                        id = i.ToString(),
                        userName = "ypf1",
                    };
                    ulist2.Add(userInfor);
                }
                dbContext.BulkUpdate(ulist2);

                //3. 刪除
                List<T_UserInfor> ulist3 = new List<T_UserInfor>();
                for (int i = 0; i < 100; i++)
                {
                    //此處不寫的字段就會被更新成null了
                    T_UserInfor userInfor = new T_UserInfor()
                    {
                        id = i.ToString(),
                    };
                    ulist3.Add(userInfor);
                }
                dbContext.BulkDelete(ulist3);

(2).Batch相關

　A.條件刪除：BatchDelete

　B.條件更新：BatchUpdate （可以基於原有數據）

PS：以上方法均支持Async異步方法。

 //4.條件刪除
 int count1 = dbContext.T_UserInfor.Where(u => u.id.StartsWith("2")).BatchDelete();

  //5. 條件更新
  //5.1 基於原有數據改
  int count2 = dbContext.T_UserInfor.Where(u => u.id.StartsWith("2")).BatchUpdate(a => new T_UserInfor() { userAge = a.userAge + 1 });
  //5.2 直接改成新數據
  int count3 = dbContext.T_UserInfor.Where(u => u.id.StartsWith("2")).BatchUpdate(new T_UserInfor() { userSex = "女" });

(3).事務

　　和正常用法一樣， using(var transaction = dbContext.Database.BeginTransaction())包裹，有using的情況下， catch中不用寫rollback，走完using如果報錯會自動回滾。

 這種寫法僅支持SQLServer，Sqlite中寫法不一樣

                using (var transaction = dbContext.Database.BeginTransaction())
                {
                    try
                    {
                        List<T_UserInfor> ulist1 = new List<T_UserInfor>();
                        for (int i = 0; i < 100; i++)
                        {
                            T_UserInfor userInfor = new T_UserInfor()
                            {
                                id = i.ToString(),
                                userName = "ypf",
                                userSex = "男",
                                userAge = 111,
                                addTime = DateTime.Now
                            };
                            ulist1.Add(userInfor);
                        }
                        dbContext.BulkInsert(ulist1);
                        int count2 = dbContext.T_UserInfor.Where(u => u.id.StartsWith("2")).BatchUpdate(a => new T_UserInfor() { id = a.id + "fsdfsdfsdfsfdsadfsadfsdfsfsafsfsdfsdfsdfsdf" });
                        //統一提交
                        transaction.Commit();
                    }
                    catch (Exception ex)
                    {
                        //using包裹不需要手寫rollback
                        Console.WriteLine(ex.Message);
                    }
                }

(4).相關配置

　　可以配置的參數有：PreserveInsertOrder, SetOutputIdentity, BatchSize, NotifyAfter, BulkCopyTimeout, EnableStreaming, UseTempDB, TrackingEntities,UseOnlyDataTable, WithHoldlock, CalculateStats, StatsInfo, PropertiesToInclude, PropertiesToExclude, UpdateByProperties, SqlBulkCopyOptions . 根據自己的情況選擇使用吧

3.性能測試

　　　　　　1000條 　　 1w條 　　 4w條 　　 　　10w條

增加 　　　　 0.7s 　　　 0.8s 　　 1.2s左右   　　1.6s左右

條件修改 　　　　　　　　　　 　　　　　　    　　1.2s左右

刪除 　　　　　　　　　　　　　　　　　　　 　　1.9s左右

說明：其他不進行測試了，上述結果足可以看出來很快。

4.封裝到框架里面

using EFCore.BulkExtensions;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using YpfCore.Data.Entity;
using YpfCore.IService;
using YpfCore.IService.BaseInterface;
using YpfCore.Utils;
using YpfCore.Utils.Extensions;

namespace YpfCore.Service.BaseClass
{
    /// <summary>
    /// 泛型方法，直接注入EF上下文
    /// </summary>
    public class BaseService : IBaseService, ISupport
    {
        public DbContext db;

        /// <summary>
        /// 在使用的時候，自動注入db上下文
        /// </summary>
        /// <param name="db"></param>
        public BaseService(CoreFrameDBContext db)
        {
            this.db = db;

            //關閉全局追蹤的代碼
            //db.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
        }

        /****************************************下面進行方法的封裝（同步）***********************************************/
        //1. 直接提交數據庫

        #region 01-數據源
        public IQueryable<T> Entities<T>() where T : class
        {
            return db.Set<T>();
        }
        #endregion

        #region 02-新增
        public int Add<T>(T model) where T : class
        {
            db.Entry(model).State = EntityState.Added;
            return db.SaveChanges();

        }
        #endregion

        #region 03-刪除
        /// <summary>
        /// 刪除
        /// </summary>
        /// <param name="model">需要刪除的實體</param>
        /// <returns></returns>
        public int Del<T>(T model) where T : class
        {
            db.Entry(model).State = EntityState.Deleted;
            return db.SaveChanges();
        }
        #endregion

        #region 04-根據條件刪除(支持批量刪除)
        /// <summary>
        /// 根據條件刪除(支持批量刪除)
        /// </summary>
        /// <param name="delWhere">傳入Lambda表達式(生成表達式目錄樹)</param>
        /// <returns></returns>
        public int DelBy<T>(Expression<Func<T, bool>> delWhere) where T : class
        {
            List<T> listDels = db.Set<T>().Where(delWhere).ToList();
            listDels.ForEach(model =>
            {
                db.Entry(model).State = EntityState.Deleted;
            });
            return db.SaveChanges();
        }
        #endregion

        #region 05-單實體修改
        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="model">修改后的實體</param>
        /// <returns></returns>
        public int Modify<T>(T model) where T : class
        {
            db.Entry(model).State = EntityState.Modified;
            return db.SaveChanges();
        }
        #endregion

        #region 06-批量修改（非lambda）
        /// <summary>
        /// 批量修改（非lambda）
        /// </summary>
        /// <param name="model">要修改實體中 修改后的屬性 </param>
        /// <param name="whereLambda">查詢實體的條件</param>
        /// <param name="proNames">lambda的形式表示要修改的實體屬性名</param>
        /// <returns></returns>
        public int ModifyBy<T>(T model, Expression<Func<T, bool>> whereLambda, params string[] proNames) where T : class
        {
            List<T> listModifes = db.Set<T>().Where(whereLambda).ToList();
            Type t = typeof(T);
            List<PropertyInfo> proInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
            Dictionary<string, PropertyInfo> dicPros = new Dictionary<string, PropertyInfo>();
            proInfos.ForEach(p =>
            {
                if (proNames.Contains(p.Name))
                {
                    dicPros.Add(p.Name, p);
                }
            });
            foreach (string proName in proNames)
            {
                if (dicPros.ContainsKey(proName))
                {
                    PropertyInfo proInfo = dicPros[proName];
                    object newValue = proInfo.GetValue(model, null);
                    foreach (T m in listModifes)
                    {
                        proInfo.SetValue(m, newValue, null);
                    }
                }
            }
            return db.SaveChanges();
        }
        #endregion

        #region 07-根據條件查詢
        /// <summary>
        /// 根據條件查詢
        /// </summary>
        /// <param name="whereLambda">查詢條件(lambda表達式的形式生成表達式目錄樹)</param>
        /// <returns></returns>
        public List<T> GetListBy<T>(Expression<Func<T, bool>> whereLambda) where T : class
        {
            return db.Set<T>().Where(whereLambda).ToList();
        }
        #endregion

        #region 08-根據條件排序和查詢
        /// <summary>
        /// 根據條件排序和查詢
        /// </summary>
        /// <typeparam name="Tkey">排序字段類型</typeparam>
        /// <param name="whereLambda">查詢條件</param>
        /// <param name="orderLambda">排序條件</param>
        /// <param name="isAsc">升序or降序</param>
        /// <returns></returns>
        public List<T> GetListBy<T, Tkey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, Tkey>> orderLambda, bool isAsc = true) where T : class
        {
            List<T> list = null;
            if (isAsc)
            {
                list = db.Set<T>().Where(whereLambda).OrderBy(orderLambda).ToList();
            }
            else
            {
                list = db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda).ToList();
            }
            return list;
        }
        #endregion

        #region 09-分頁查詢(根據Lambda排序)
        /// <summary>
        /// 根據條件排序和查詢
        /// </summary>
        /// <typeparam name="Tkey">排序字段類型</typeparam>
        /// <param name="pageIndex">頁碼</param>
        /// <param name="pageSize">頁容量</param>
        /// <param name="whereLambda">查詢條件</param>
        /// <param name="orderLambda">排序條件</param>
        /// <param name="isAsc">升序or降序</param>
        /// <returns></returns>
        public List<T> GetPageList<T, Tkey>(int pageIndex, int pageSize, Expression<Func<T, bool>> whereLambda, Expression<Func<T, Tkey>> orderLambda, bool isAsc = true) where T : class
        {

            List<T> list = null;
            if (isAsc)
            {
                list = db.Set<T>().Where(whereLambda).OrderBy(orderLambda)
               .Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
            }
            else
            {
                list = db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda)
              .Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
            }
            return list;
        }
        #endregion

        #region 10-分頁查詢(根據名稱排序)
        /// <summary>
        /// 分頁查詢輸出總行數（根據名稱排序）
        /// </summary>
        /// <param name="pageIndex">頁碼</param>
        /// <param name="rowCount">輸出的總數量</param>
        /// <param name="whereLambda">查詢條件</param>
        /// <param name="sortName">排序名稱</param>
        /// <param name="sortDirection">asc 或 desc</param>
        /// <returns></returns>
        public List<T> GetPageListByName<T>(int pageIndex, int pageSize, Expression<Func<T, bool>> whereLambda, string sortName, string sortDirection) where T : class
        {

            List<T> list = db.Set<T>().Where(whereLambda).DataSorting(sortName, sortDirection)
                 .Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
            return list;
        }
        #endregion

        #region 11-分頁查詢輸出總行數（根據Lambda排序）
        /// <summary>
        /// 根據條件排序和查詢
        /// </summary>
        /// <typeparam name="Tkey">排序字段類型</typeparam>
        /// <param name="pageIndex">頁碼</param>
        /// <param name="pageSize">頁容量</param>
        /// <param name="whereLambda">查詢條件</param>
        /// <param name="orderLambda">排序條件</param>
        /// <param name="isAsc">升序or降序</param>
        /// <returns></returns>
        public List<T> GetPageList<T, Tkey>(int pageIndex, int pageSize, out int rowCount, Expression<Func<T, bool>> whereLambda, Expression<Func<T, Tkey>> orderLambda, bool isAsc = true) where T : class
        {
            int count = 0;
            List<T> list = null;
            count = db.Set<T>().Where(whereLambda).Count();
            if (isAsc)
            {
                var iQueryList = db.Set<T>().Where(whereLambda).OrderBy(orderLambda)
                   .Skip((pageIndex - 1) * pageSize).Take(pageSize);

                list = iQueryList.ToList();
            }
            else
            {
                var iQueryList = db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda)
                 .Skip((pageIndex - 1) * pageSize).Take(pageSize);
                list = iQueryList.ToList();
            }
            rowCount = count;
            return list;
        }
        #endregion

        #region 12-分頁查詢輸出總行數（根據名稱排序）
        /// <summary>
        /// 分頁查詢輸出總行數（根據名稱排序）
        /// </summary>
        /// <param name="pageIndex">頁碼</param>
        /// <param name="pageSize">頁容量</param>
        /// <param name="rowCount">輸出的總數量</param>
        /// <param name="whereLambda">查詢條件</param>
        /// <param name="sortName">排序名稱</param>
        /// <param name="sortDirection">asc 或 desc</param>
        /// <returns></returns>
        public List<T> GetPageListByName<T>(int pageIndex, int pageSize, out int rowCount, Expression<Func<T, bool>> whereLambda, string sortName, string sortDirection) where T : class
        {
            int count = 0;
            count = db.Set<T>().Where(whereLambda).Count();

            List<T> list = db.Set<T>().Where(whereLambda).DataSorting(sortName, sortDirection)
                 .Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();

            rowCount = count;
            return list;
        }
        #endregion


        //2. SaveChange剝離出來，處理事務

        #region 01-批量處理SaveChange()
        /// <summary>
        /// 事務批量處理
        /// </summary>
        /// <returns></returns>
        public int SaveChange()
        {
            return db.SaveChanges();
        }
        #endregion

        #region 02-新增
        /// <summary>
        /// 新增
        /// </summary>
        /// <param name="model">需要新增的實體</param>
        public void AddNo<T>(T model) where T : class
        {
            db.Entry(model).State = EntityState.Added;
        }
        #endregion

        #region 03-刪除
        /// <summary>
        /// 刪除
        /// </summary>
        /// <param name="model">需要刪除的實體</param>
        public void DelNo<T>(T model) where T : class
        {
            db.Entry(model).State = EntityState.Deleted;
        }
        #endregion

        #region 04-根據條件刪除
        /// <summary>
        /// 條件刪除
        /// </summary>
        /// <param name="delWhere">需要刪除的條件</param>
        public void DelByNo<T>(Expression<Func<T, bool>> delWhere) where T : class
        {
            List<T> listDels = db.Set<T>().Where(delWhere).ToList();
            listDels.ForEach(model =>
            {
                db.Entry(model).State = EntityState.Deleted;
            });
        }
        #endregion

        #region 05-修改
        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="model">修改后的實體</param>
        public void ModifyNo<T>(T model) where T : class
        {
            db.Entry(model).State = EntityState.Modified;
        }
        #endregion


        //3. EF調用sql語句

        #region 01-執行增加,刪除,修改操作(或調用相關存儲過程)
        /// <summary>
        /// 執行增加,刪除,修改操作(或調用存儲過程)
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="pars"></param>
        /// <returns></returns>
        public int ExecuteSql(string sql, params SqlParameter[] pars)
        {
            return db.Database.ExecuteSqlRaw(sql, pars);
        }

        #endregion

        #region 02-執行查詢操作（調用查詢類的存儲過程）
        /// <summary>
        /// 執行查詢操作
        /// 注：查詢必須返回實體的所有屬性字段；結果集中列名必須與屬性映射的項目匹配；查詢中不能包含關聯數據
        /// 除Select以外其他的SQL語句無法執行
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sql"></param>
        /// <param name="isTrack">是否跟蹤狀態，默認是跟蹤的</param>
        /// <param name="pars"></param>
        /// <returns></returns>
        public List<T> ExecuteQuery<T>(string sql, bool isTrack = true, params SqlParameter[] pars) where T : class
        {
            if (isTrack)
            {
                //表示跟蹤狀態（默認是跟蹤的）
                return db.Set<T>().FromSqlRaw(sql, pars).ToList();
            }
            else
            {
                //表示不跟蹤狀態
                return db.Set<T>().FromSqlRaw(sql, pars).AsNoTracking().ToList();
            }
        }
        #endregion

        #region 03-執行查詢操作（與Linq相結合）
        /// <summary>
        /// 執行查詢操作
        /// 注：查詢必須返回實體的所有屬性字段；結果集中列名必須與屬性映射的項目匹配；查詢中不能包含關聯數據
        /// 除Select以外其他的SQL語句無法執行
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sql"></param>
        ///  <param name="whereLambda">查詢條件</param>
        /// <param name="isTrack">是否跟蹤狀態，默認是跟蹤的</param>
        /// <param name="pars"></param>
        /// <returns></returns>
        public List<T> ExecuteQueryWhere<T>(string sql, Expression<Func<T, bool>> whereLambda, bool isTrack = true, params SqlParameter[] pars) where T : class
        {
            if (isTrack)
            {
                //表示跟蹤狀態（默認是跟蹤的）
                return db.Set<T>().FromSqlRaw(sql, pars).Where(whereLambda).ToList();
            }
            else
            {
                //表示不跟蹤狀態
                return db.Set<T>().FromSqlRaw(sql, pars).Where(whereLambda).AsNoTracking().ToList();
            }
        }
        #endregion


        /****************************************下面進行方法的封裝（異步）***********************************************/
        //1. 直接提交數據庫

        #region 01-新增
        public async Task<int> AddAsync<T>(T model) where T : class
        {
            await db.AddAsync(model);
            return await db.SaveChangesAsync();

        }
        #endregion

        #region 02-刪除
        /// <summary>
        /// 刪除
        /// </summary>
        /// <param name="model">需要刪除的實體</param>
        /// <returns></returns>
        public async Task<int> DelAsync<T>(T model) where T : class
        {
            db.Entry(model).State = EntityState.Deleted;
            return await db.SaveChangesAsync();
        }
        #endregion

        #region 03-根據條件刪除(支持批量刪除)
        /// <summary>
        /// 根據條件刪除(支持批量刪除)
        /// </summary>
        /// <param name="delWhere">傳入Lambda表達式(生成表達式目錄樹)</param>
        /// <returns></returns>
        public async Task<int> DelByAsync<T>(Expression<Func<T, bool>> delWhere) where T : class
        {
            List<T> listDels = db.Set<T>().Where(delWhere).ToList();
            listDels.ForEach(model =>
            {
                db.Entry(model).State = EntityState.Deleted;
            });
            return await db.SaveChangesAsync();
        }
        #endregion

        #region 04-單實體修改
        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="model">修改后的實體</param>
        /// <returns></returns>
        public async Task<int> ModifyAsync<T>(T model) where T : class
        {

            db.Entry(model).State = EntityState.Modified;
            return await db.SaveChangesAsync();
        }
        #endregion


        //2. SaveChange剝離出來，處理事務

        #region 01-批量處理SaveChange()
        /// <summary>
        /// 事務批量處理
        /// </summary>
        /// <returns></returns>
        public async Task<int> SaveChangeAsync()
        {
            return await db.SaveChangesAsync();
        }
        #endregion

        #region 02-新增
        /// <summary>
        /// 新增
        /// </summary>
        /// <param name="model">需要新增的實體</param>
        public async void AddNoAsync<T>(T model) where T : class
        {
            await db.AddAsync(model);
        }
        #endregion


        //3. EF調用sql語句

        #region 01-執行增加,刪除,修改操作(或調用存儲過程)
        /// <summary>
        /// 執行增加,刪除,修改操作(或調用存儲過程)
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="pars"></param>
        /// <returns></returns>
        public async Task<int> ExecuteSqlAsync(string sql, params SqlParameter[] pars)
        {
            return await db.Database.ExecuteSqlRawAsync(sql, pars);
        }
        #endregion


        /****************************************下面是基於【EFCore.BulkExtensions】大數據的處理***********************************************/

        #region 01-增加
        /// <summary>
        /// 增加
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list"></param>
        public void BulkInsert<T>(List<T> list) where T : class
        {
            db.BulkInsert<T>(list);
        }
        #endregion

        #region 02-修改
        /// <summary>
        /// 修改
        /// PS：傳入的實體如果不賦值,則更新為null,即傳入的實體每個字段都要有值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list"></param>
        public void BulkUpdate<T>(List<T> list) where T : class
        {
            db.BulkUpdate<T>(list);
        }
        #endregion

        #region 03-刪除
        /// <summary>
        /// 刪除
        /// PS：傳入的list中的實體僅需要主鍵有值,它是根據主鍵刪除的
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list"></param>
        public void BulkDelete<T>(List<T> list) where T : class
        {
            db.BulkDelete<T>(list);
        }
        #endregion

        #region 04-條件刪除
        /// <summary>
        /// 條件刪除
        /// </summary>
        /// <param name="delWhere">需要刪除的條件</param>
        public int BatchDelete<T>(Expression<Func<T, bool>> delWhere) where T : class
        {
            return db.Set<T>().Where(delWhere).BatchDelete();
        }
        #endregion

        #region 05-條件更新1
        /// <summary>
        /// 條件更新
        /// PS：要更新哪幾個字段，就給傳入的實體中的哪幾個字段賦值
        /// </summary>
        /// <param name="delWhere">需要更新的條件</param>
        /// <param name="model">更新為的實體</param>
        public int BatchUpdate<T>(Expression<Func<T, bool>> delWhere, T model) where T : class, new()
        {
            return db.Set<T>().Where(delWhere).BatchUpdate<T>(model);
        }
        #endregion

        #region 06-條件更新2
        /// <summary>
        /// 條件更新
        /// PS：要更新哪幾個字段，就給傳入的實體中的哪幾個字段賦值
        /// </summary>
        /// <param name="delWhere">需要更新的條件</param>
        /// <param name="model">更新為的實體</param>
        public int BatchUpdate2<T>(Expression<Func<T, bool>> delWhere, Expression<Func<T, T>> modelWhere) where T : class, new()
        {
            return db.Set<T>().Where(delWhere).BatchUpdate<T>(modelWhere);
        } 
        #endregion



    }
}

 

 

 

 

 

 

 

!

• 作       者 : Yaopengfei(姚鵬飛)
• 博客地址 : http://www.cnblogs.com/yaopengfei/
• 聲     明1 : 本人才疏學淺，用郭德綱的話說“我是一個小學生”，如有錯誤，歡迎討論，請勿謾罵^_^。
• 聲     明2 : 原創博客請在轉載時保留原文鏈接或在文章開頭加上本人博客地址，否則保留追究法律責任的權利。