第十五节：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               //1. 增加
 2                 List ulist1 = new List();
 3                 for (int i = 0; i < 100; i++)
 4                 {
 5                     T_UserInfor userInfor = new T_UserInfor()
 6                     {
 7                         id = i.ToString(),
 8                         userName = "ypf",
 9                         userSex = "男",
10                         userAge = 111,
11                         addTime = DateTime.Now
12                     };
13                     ulist1.Add(userInfor);
14                 }
15                 dbContext.BulkInsert(ulist1);
16 
17                 //2. 修改
18                 List ulist2 = new List();
19                 for (int i = 0; i < 100; i++)
20                 {
21                     //此处不写的字段就会被更新成null了
22                     T_UserInfor userInfor = new T_UserInfor()
23                     {
24                         id = i.ToString(),
25                         userName = "ypf1",
26                     };
27                     ulist2.Add(userInfor);
28                 }
29                 dbContext.BulkUpdate(ulist2);
30 
31                 //3. 删除
32                 List ulist3 = new List();
33                 for (int i = 0; i < 100; i++)
34                 {
35                     //此处不写的字段就会被更新成null了
36                     T_UserInfor userInfor = new T_UserInfor()
37                     {
38                         id = i.ToString(),
39                     };
40                     ulist3.Add(userInfor);
41                 }
42                 dbContext.BulkDelete(ulist3);

(2).Batch相关

　A.条件删除：BatchDelete

　B.条件更新：BatchUpdate （可以基于原有数据）

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

1  //4.条件删除
2  int count1 = dbContext.T_UserInfor.Where(u => u.id.StartsWith("2")).BatchDelete();
3 
4   //5. 条件更新
5   //5.1 基于原有数据改
6   int count2 = dbContext.T_UserInfor.Where(u => u.id.StartsWith("2")).BatchUpdate(a => new T_UserInfor() { userAge = a.userAge + 1 });
7   //5.2 直接改成新数据
8   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中写法不一样

 1                 using (var transaction = dbContext.Database.BeginTransaction())
 2                 {
 3                     try
 4                     {
 5                         List ulist1 = new List();
 6                         for (int i = 0; i < 100; i++)
 7                         {
 8                             T_UserInfor userInfor = new T_UserInfor()
 9                             {
10                                 id = i.ToString(),
11                                 userName = "ypf",
12                                 userSex = "男",
13                                 userAge = 111,
14                                 addTime = DateTime.Now
15                             };
16                             ulist1.Add(userInfor);
17                         }
18                         dbContext.BulkInsert(ulist1);
19                         int count2 = dbContext.T_UserInfor.Where(u => u.id.StartsWith("2")).BatchUpdate(a => new T_UserInfor() { id = a.id + "fsdfsdfsdfsfdsadfsadfsdfsfsafsfsdfsdfsdfsdf" });
20                         //统一提交
21                         transaction.Commit();
22                     }
23                     catch (Exception ex)
24                     {
25                         //using包裹不需要手写rollback
26                         Console.WriteLine(ex.Message);
27                     }
28                 }

(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.封装到框架里面

  1 using EFCore.BulkExtensions;
  2 using Microsoft.EntityFrameworkCore;
  3 using System;
  4 using System.Collections.Generic;
  5 using System.Data.SqlClient;
  6 using System.Linq;
  7 using System.Linq.Expressions;
  8 using System.Reflection;
  9 using System.Text;
 10 using System.Threading.Tasks;
 11 using YpfCore.Data.Entity;
 12 using YpfCore.IService;
 13 using YpfCore.IService.BaseInterface;
 14 using YpfCore.Utils;
 15 using YpfCore.Utils.Extensions;
 16 
 17 namespace YpfCore.Service.BaseClass
 18 {
 19     /// 
 20     /// 泛型方法，直接注入EF上下文
 21     /// 
 22     public class BaseService : IBaseService, ISupport
 23     {
 24         public DbContext db;
 25 
 26         /// 
 27         /// 在使用的时候，自动注入db上下文
 28         /// 
 29         /// 
 30         public BaseService(CoreFrameDBContext db)
 31         {
 32             this.db = db;
 33 
 34             //关闭全局追踪的代码
 35             //db.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
 36         }
 37 
 38         /****************************************下面进行方法的封装（同步）***********************************************/
 39         //1. 直接提交数据库
 40 
 41         #region 01-数据源
 42         public IQueryable Entities() where T : class
 43         {
 44             return db.Set();
 45         }
 46         #endregion
 47 
 48         #region 02-新增
 49         public int Add(T model) where T : class
 50         {
 51             db.Entry(model).State = EntityState.Added;
 52             return db.SaveChanges();
 53 
 54         }
 55         #endregion
 56 
 57         #region 03-删除
 58         /// 
 59         /// 删除
 60         /// 
 61         /// 需要删除的实体
 62         /// 
 63         public int Del(T model) where T : class
 64         {
 65             db.Entry(model).State = EntityState.Deleted;
 66             return db.SaveChanges();
 67         }
 68         #endregion
 69 
 70         #region 04-根据条件删除(支持批量删除)
 71         /// 
 72         /// 根据条件删除(支持批量删除)
 73         /// 
 74         /// 传入Lambda表达式(生成表达式目录树)
 75         /// 
 76         public int DelBy(Expressionbool>> delWhere) where T : class
 77         {
 78             List listDels = db.Set().Where(delWhere).ToList();
 79             listDels.ForEach(model =>
 80             {
 81                 db.Entry(model).State = EntityState.Deleted;
 82             });
 83             return db.SaveChanges();
 84         }
 85         #endregion
 86 
 87         #region 05-单实体修改
 88         /// 
 89         /// 修改
 90         /// 
 91         /// 修改后的实体
 92         /// 
 93         public int Modify(T model) where T : class
 94         {
 95             db.Entry(model).State = EntityState.Modified;
 96             return db.SaveChanges();
 97         }
 98         #endregion
 99 
100         #region 06-批量修改（非lambda）
101         /// 
102         /// 批量修改（非lambda）
103         /// 
104         /// 要修改实体中 修改后的属性 
105         /// 查询实体的条件
106         /// lambda的形式表示要修改的实体属性名
107         /// 
108         public int ModifyBy(T model, Expressionbool>> whereLambda, params string[] proNames) where T : class
109         {
110             List listModifes = db.Set().Where(whereLambda).ToList();
111             Type t = typeof(T);
112             List proInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
113             Dictionary<string, PropertyInfo> dicPros = new Dictionary<string, PropertyInfo>();
114             proInfos.ForEach(p =>
115             {
116                 if (proNames.Contains(p.Name))
117                 {
118                     dicPros.Add(p.Name, p);
119                 }
120             });
121             foreach (string proName in proNames)
122             {
123                 if (dicPros.ContainsKey(proName))
124                 {
125                     PropertyInfo proInfo = dicPros[proName];
126                     object newValue = proInfo.GetValue(model, null);
127                     foreach (T m in listModifes)
128                     {
129                         proInfo.SetValue(m, newValue, null);
130                     }
131                 }
132             }
133             return db.SaveChanges();
134         }
135         #endregion
136 
137         #region 07-根据条件查询
138         /// 
139         /// 根据条件查询
140         /// 
141         /// 查询条件(lambda表达式的形式生成表达式目录树)
142         /// 
143         public List GetListBy(Expressionbool>> whereLambda) where T : class
144         {
145             return db.Set().Where(whereLambda).ToList();
146         }
147         #endregion
148 
149         #region 08-根据条件排序和查询
150         /// 
151         /// 根据条件排序和查询
152         /// 
153         /// 排序字段类型
154         /// 查询条件
155         /// 排序条件
156         /// 升序or降序
157         /// 
158         public List GetListBy(Expressionbool>> whereLambda, Expression> orderLambda, bool isAsc = true) where T : class
159         {
160             List list = null;
161             if (isAsc)
162             {
163                 list = db.Set().Where(whereLambda).OrderBy(orderLambda).ToList();
164             }
165             else
166             {
167                 list = db.Set().Where(whereLambda).OrderByDescending(orderLambda).ToList();
168             }
169             return list;
170         }
171         #endregion
172 
173         #region 09-分页查询(根据Lambda排序)
174         /// 
175         /// 根据条件排序和查询
176         /// 
177         /// 排序字段类型
178         /// 页码
179         /// 页容量
180         /// 查询条件
181         /// 排序条件
182         /// 升序or降序
183         /// 
184         public List GetPageList(int pageIndex, int pageSize, Expressionbool>> whereLambda, Expression> orderLambda, bool isAsc = true) where T : class
185         {
186 
187             List list = null;
188             if (isAsc)
189             {
190                 list = db.Set().Where(whereLambda).OrderBy(orderLambda)
191                .Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
192             }
193             else
194             {
195                 list = db.Set().Where(whereLambda).OrderByDescending(orderLambda)
196               .Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
197             }
198             return list;
199         }
200         #endregion
201 
202         #region 10-分页查询(根据名称排序)
203         /// 
204         /// 分页查询输出总行数（根据名称排序）
205         /// 
206         /// 页码
207         /// 输出的总数量
208         /// 查询条件
209         /// 排序名称
210         /// asc 或 desc
211         /// 
212         public List GetPageListByName(int pageIndex, int pageSize, Expressionbool>> whereLambda, string sortName, string sortDirection) where T : class
213         {
214 
215             List list = db.Set().Where(whereLambda).DataSorting(sortName, sortDirection)
216                  .Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
217             return list;
218         }
219         #endregion
220 
221         #region 11-分页查询输出总行数（根据Lambda排序）
222         /// 
223         /// 根据条件排序和查询
224         /// 
225         /// 排序字段类型
226         /// 页码
227         /// 页容量
228         /// 查询条件
229         /// 排序条件
230         /// 升序or降序
231         /// 
232         public List GetPageList(int pageIndex, int pageSize, out int rowCount, Expressionbool>> whereLambda, Expression> orderLambda, bool isAsc = true) where T : class
233         {
234             int count = 0;
235             List list = null;
236             count = db.Set().Where(whereLambda).Count();
237             if (isAsc)
238             {
239                 var iQueryList = db.Set().Where(whereLambda).OrderBy(orderLambda)
240                    .Skip((pageIndex - 1) * pageSize).Take(pageSize);
241 
242                 list = iQueryList.ToList();
243             }
244             else
245             {
246                 var iQueryList = db.Set().Where(whereLambda).OrderByDescending(orderLambda)
247                  .Skip((pageIndex - 1) * pageSize).Take(pageSize);
248                 list = iQueryList.ToList();
249             }
250             rowCount = count;
251             return list;
252         }
253         #endregion
254 
255         #region 12-分页查询输出总行数（根据名称排序）
256         /// 
257         /// 分页查询输出总行数（根据名称排序）
258         /// 
259         /// 页码
260         /// 页容量
261         /// 输出的总数量
262         /// 查询条件
263         /// 排序名称
264         /// asc 或 desc
265         /// 
266         public List GetPageListByName(int pageIndex, int pageSize, out int rowCount, Expressionbool>> whereLambda, string sortName, string sortDirection) where T : class
267         {
268             int count = 0;
269             count = db.Set().Where(whereLambda).Count();
270 
271             List list = db.Set().Where(whereLambda).DataSorting(sortName, sortDirection)
272                  .Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
273 
274             rowCount = count;
275             return list;
276         }
277         #endregion
278 
279 
280         //2. SaveChange剥离出来，处理事务
281 
282         #region 01-批量处理SaveChange()
283         /// 
284         /// 事务批量处理
285         /// 
286         /// 
287         public int SaveChange()
288         {
289             return db.SaveChanges();
290         }
291         #endregion
292 
293         #region 02-新增
294         /// 
295         /// 新增
296         /// 
297         /// 需要新增的实体
298         public void AddNo(T model) where T : class
299         {
300             db.Entry(model).State = EntityState.Added;
301         }
302         #endregion
303 
304         #region 03-删除
305         /// 
306         /// 删除
307         /// 
308         /// 需要删除的实体
309         public void DelNo(T model) where T : class
310         {
311             db.Entry(model).State = EntityState.Deleted;
312         }
313         #endregion
314 
315         #region 04-根据条件删除
316         /// 
317         /// 条件删除
318         /// 
319         /// 需要删除的条件
320         public void DelByNo(Expressionbool>> delWhere) where T : class
321         {
322             List listDels = db.Set().Where(delWhere).ToList();
323             listDels.ForEach(model =>
324             {
325                 db.Entry(model).State = EntityState.Deleted;
326             });
327         }
328         #endregion
329 
330         #region 05-修改
331         /// 
332         /// 修改
333         /// 
334         /// 修改后的实体
335         public void ModifyNo(T model) where T : class
336         {
337             db.Entry(model).State = EntityState.Modified;
338         }
339         #endregion
340 
341 
342         //3. EF调用sql语句
343 
344         #region 01-执行增加,删除,修改操作(或调用相关存储过程)
345         /// 
346         /// 执行增加,删除,修改操作(或调用存储过程)
347         /// 
348         /// 
349         /// 
350         /// 
351         public int ExecuteSql(string sql, params SqlParameter[] pars)
352         {
353             return db.Database.ExecuteSqlRaw(sql, pars);
354         }
355 
356         #endregion
357 
358         #region 02-执行查询操作（调用查询类的存储过程）
359         /// 
360         /// 执行查询操作
361         /// 注：查询必须返回实体的所有属性字段；结果集中列名必须与属性映射的项目匹配；查询中不能包含关联数据
362         /// 除Select以外其他的SQL语句无法执行
363         /// 
364         /// 
365         /// 
366         /// 是否跟踪状态，默认是跟踪的
367         /// 
368         /// 
369         public List ExecuteQuery(string sql, bool isTrack = true, params SqlParameter[] pars) where T : class
370         {
371             if (isTrack)
372             {
373                 //表示跟踪状态（默认是跟踪的）
374                 return db.Set().FromSqlRaw(sql, pars).ToList();
375             }
376             else
377             {
378                 //表示不跟踪状态
379                 return db.Set().FromSqlRaw(sql, pars).AsNoTracking().ToList();
380             }
381         }
382         #endregion
383 
384         #region 03-执行查询操作（与Linq相结合）
385         /// 
386         /// 执行查询操作
387         /// 注：查询必须返回实体的所有属性字段；结果集中列名必须与属性映射的项目匹配；查询中不能包含关联数据
388         /// 除Select以外其他的SQL语句无法执行
389         /// 
390         /// 
391         /// 
392         ///  查询条件
393         /// 是否跟踪状态，默认是跟踪的
394         /// 
395         /// 
396         public List ExecuteQueryWhere(string sql, Expressionbool>> whereLambda, bool isTrack = true, params SqlParameter[] pars) where T : class
397         {
398             if (isTrack)
399             {
400                 //表示跟踪状态（默认是跟踪的）
401                 return db.Set().FromSqlRaw(sql, pars).Where(whereLambda).ToList();
402             }
403             else
404             {
405                 //表示不跟踪状态
406                 return db.Set().FromSqlRaw(sql, pars).Where(whereLambda).AsNoTracking().ToList();
407             }
408         }
409         #endregion
410 
411 
412         /****************************************下面进行方法的封装（异步）***********************************************/
413         //1. 直接提交数据库
414 
415         #region 01-新增
416         public async Task<int> AddAsync(T model) where T : class
417         {
418             await db.AddAsync(model);
419             return await db.SaveChangesAsync();
420 
421         }
422         #endregion
423 
424         #region 02-删除
425         /// 
426         /// 删除
427         /// 
428         /// 需要删除的实体
429         /// 
430         public async Task<int> DelAsync(T model) where T : class
431         {
432             db.Entry(model).State = EntityState.Deleted;
433             return await db.SaveChangesAsync();
434         }
435         #endregion
436 
437         #region 03-根据条件删除(支持批量删除)
438         /// 
439         /// 根据条件删除(支持批量删除)
440         /// 
441         /// 传入Lambda表达式(生成表达式目录树)
442         /// 
443         public async Task<int> DelByAsync(Expressionbool>> delWhere) where T : class
444         {
445             List listDels = db.Set().Where(delWhere).ToList();
446             listDels.ForEach(model =>
447             {
448                 db.Entry(model).State = EntityState.Deleted;
449             });
450             return await db.SaveChangesAsync();
451         }
452         #endregion
453 
454         #region 04-单实体修改
455         /// 
456         /// 修改
457         /// 
458         /// 修改后的实体
459         /// 
460         public async Task<int> ModifyAsync(T model) where T : class
461         {
462 
463             db.Entry(model).State = EntityState.Modified;
464             return await db.SaveChangesAsync();
465         }
466         #endregion
467 
468 
469         //2. SaveChange剥离出来，处理事务
470 
471         #region 01-批量处理SaveChange()
472         /// 
473         /// 事务批量处理
474         /// 
475         /// 
476         public async Task<int> SaveChangeAsync()
477         {
478             return await db.SaveChangesAsync();
479         }
480         #endregion
481 
482         #region 02-新增
483         /// 
484         /// 新增
485         /// 
486         /// 需要新增的实体
487         public async void AddNoAsync(T model) where T : class
488         {
489             await db.AddAsync(model);
490         }
491         #endregion
492 
493 
494         //3. EF调用sql语句
495 
496         #region 01-执行增加,删除,修改操作(或调用存储过程)
497         /// 
498         /// 执行增加,删除,修改操作(或调用存储过程)
499         /// 
500         /// 
501         /// 
502         /// 
503         public async Task<int> ExecuteSqlAsync(string sql, params SqlParameter[] pars)
504         {
505             return await db.Database.ExecuteSqlRawAsync(sql, pars);
506         }
507         #endregion
508 
509 
510         /****************************************下面是基于【EFCore.BulkExtensions】大数据的处理***********************************************/
511 
512         #region 01-增加
513         /// 
514         /// 增加
515         /// 
516         /// 
517         /// 
518         public void BulkInsert(List list) where T : class
519         {
520             db.BulkInsert(list);
521         }
522         #endregion
523 
524         #region 02-修改
525         /// 
526         /// 修改
527         /// PS：传入的实体如果不赋值,则更新为null,即传入的实体每个字段都要有值
528         /// 
529         /// 
530         /// 
531         public void BulkUpdate(List list) where T : class
532         {
533             db.BulkUpdate(list);
534         }
535         #endregion
536 
537         #region 03-删除
538         /// 
539         /// 删除
540         /// PS：传入的list中的实体仅需要主键有值,它是根据主键删除的
541         /// 
542         /// 
543         /// 
544         public void BulkDelete(List list) where T : class
545         {
546             db.BulkDelete(list);
547         }
548         #endregion
549 
550         #region 04-条件删除
551         /// 
552         /// 条件删除
553         /// 
554         /// 需要删除的条件
555         public int BatchDelete(Expressionbool>> delWhere) where T : class
556         {
557             return db.Set().Where(delWhere).BatchDelete();
558         }
559         #endregion
560 
561         #region 05-条件更新1
562         /// 
563         /// 条件更新
564         /// PS：要更新哪几个字段，就给传入的实体中的哪几个字段赋值
565         /// 
566         /// 需要更新的条件
567         /// 更新为的实体
568         public int BatchUpdate(Expressionbool>> delWhere, T model) where T : class, new()
569         {
570             return db.Set().Where(delWhere).BatchUpdate(model);
571         }
572         #endregion
573 
574         #region 06-条件更新2
575         /// 
576         /// 条件更新
577         /// PS：要更新哪几个字段，就给传入的实体中的哪几个字段赋值
578         /// 
579         /// 需要更新的条件
580         /// 更新为的实体
581         public int BatchUpdate2(Expressionbool>> delWhere, Expression> modelWhere) where T : class, new()
582         {
583             return db.Set().Where(delWhere).BatchUpdate(modelWhere);
584         } 
585         #endregion
586 
587 
588 
589     }
590 }

作者 : Yaopengfei(姚鹏飞)
博客地址 : http://www.cnblogs.com/yaopengfei/
声明1 : 本人才疏学浅，用郭德纲的话说“我是一个小学生”，如有错误，欢迎讨论，请勿谩骂^_^。
声明2 : 原创博客请在转载时保留原文链接或在文章开头加上本人博客地址，否则保留追究法律责任的权利。

05-EFCore

第十五节：EF Core大数据量处理(一)之EFCore.BulkExtensions

相关

标签