一. 各种性能测试
这里分享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<T_UserInfor> ulist1 = new List<T_UserInfor>(); 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<T_UserInfor> ulist2 = new List<T_UserInfor>(); 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<T_UserInfor> ulist3 = new List<T_UserInfor>(); 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<T_UserInfor> ulist1 = new List<T_UserInfor>(); 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 /// <summary> 20 /// 泛型方法，直接注入EF上下文 21 /// </summary> 22 public class BaseService : IBaseService, ISupport 23 { 24 public DbContext db; 25 26 /// <summary> 27 /// 在使用的时候，自动注入db上下文 28 /// </summary> 29 /// <param name="db"></param> 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<T> Entities<T>() where T : class 43 { 44 return db.Set<T>(); 45 } 46 #endregion 47 48 #region 02-新增 49 public int Add<T>(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 /// <summary> 59 /// 删除 60 /// </summary> 61 /// <param name="model">需要删除的实体</param> 62 /// <returns></returns> 63 public int Del<T>(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 /// <summary> 72 /// 根据条件删除(支持批量删除) 73 /// </summary> 74 /// <param name="delWhere">传入Lambda表达式(生成表达式目录树)</param> 75 /// <returns></returns> 76 public int DelBy<T>(Expression<Func<T, bool>> delWhere) where T : class 77 { 78 List<T> listDels = db.Set<T>().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 /// <summary> 89 /// 修改 90 /// </summary> 91 /// <param name="model">修改后的实体</param> 92 /// <returns></returns> 93 public int Modify<T>(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 /// <summary> 102 /// 批量修改（非lambda） 103 /// </summary> 104 /// <param name="model">要修改实体中 修改后的属性 </param> 105 /// <param name="whereLambda">查询实体的条件</param> 106 /// <param name="proNames">lambda的形式表示要修改的实体属性名</param> 107 /// <returns></returns> 108 public int ModifyBy<T>(T model, Expression<Func<T, bool>> whereLambda, params string[] proNames) where T : class 109 { 110 List<T> listModifes = db.Set<T>().Where(whereLambda).ToList(); 111 Type t = typeof(T); 112 List<PropertyInfo> 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 /// <summary> 139 /// 根据条件查询 140 /// </summary> 141 /// <param name="whereLambda">查询条件(lambda表达式的形式生成表达式目录树)</param> 142 /// <returns></returns> 143 public List<T> GetListBy<T>(Expression<Func<T, bool>> whereLambda) where T : class 144 { 145 return db.Set<T>().Where(whereLambda).ToList(); 146 } 147 #endregion 148 149 #region 08-根据条件排序和查询 150 /// <summary> 151 /// 根据条件排序和查询 152 /// </summary> 153 /// <typeparam name="Tkey">排序字段类型</typeparam> 154 /// <param name="whereLambda">查询条件</param> 155 /// <param name="orderLambda">排序条件</param> 156 /// <param name="isAsc">升序or降序</param> 157 /// <returns></returns> 158 public List<T> GetListBy<T, Tkey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, Tkey>> orderLambda, bool isAsc = true) where T : class 159 { 160 List<T> list = null; 161 if (isAsc) 162 { 163 list = db.Set<T>().Where(whereLambda).OrderBy(orderLambda).ToList(); 164 } 165 else 166 { 167 list = db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda).ToList(); 168 } 169 return list; 170 } 171 #endregion 172 173 #region 09-分页查询(根据Lambda排序) 174 /// <summary> 175 /// 根据条件排序和查询 176 /// </summary> 177 /// <typeparam name="Tkey">排序字段类型</typeparam> 178 /// <param name="pageIndex">页码</param> 179 /// <param name="pageSize">页容量</param> 180 /// <param name="whereLambda">查询条件</param> 181 /// <param name="orderLambda">排序条件</param> 182 /// <param name="isAsc">升序or降序</param> 183 /// <returns></returns> 184 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 185 { 186 187 List<T> list = null; 188 if (isAsc) 189 { 190 list = db.Set<T>().Where(whereLambda).OrderBy(orderLambda) 191 .Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList(); 192 } 193 else 194 { 195 list = db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda) 196 .Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList(); 197 } 198 return list; 199 } 200 #endregion 201 202 #region 10-分页查询(根据名称排序) 203 /// <summary> 204 /// 分页查询输出总行数（根据名称排序） 205 /// </summary> 206 /// <param name="pageIndex">页码</param> 207 /// <param name="rowCount">输出的总数量</param> 208 /// <param name="whereLambda">查询条件</param> 209 /// <param name="sortName">排序名称</param> 210 /// <param name="sortDirection">asc 或 desc</param> 211 /// <returns></returns> 212 public List<T> GetPageListByName<T>(int pageIndex, int pageSize, Expression<Func<T, bool>> whereLambda, string sortName, string sortDirection) where T : class 213 { 214 215 List<T> list = db.Set<T>().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 /// <summary> 223 /// 根据条件排序和查询 224 /// </summary> 225 /// <typeparam name="Tkey">排序字段类型</typeparam> 226 /// <param name="pageIndex">页码</param> 227 /// <param name="pageSize">页容量</param> 228 /// <param name="whereLambda">查询条件</param> 229 /// <param name="orderLambda">排序条件</param> 230 /// <param name="isAsc">升序or降序</param> 231 /// <returns></returns> 232 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 233 { 234 int count = 0; 235 List<T> list = null; 236 count = db.Set<T>().Where(whereLambda).Count(); 237 if (isAsc) 238 { 239 var iQueryList = db.Set<T>().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<T>().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 /// <summary> 257 /// 分页查询输出总行数（根据名称排序） 258 /// </summary> 259 /// <param name="pageIndex">页码</param> 260 /// <param name="pageSize">页容量</param> 261 /// <param name="rowCount">输出的总数量</param> 262 /// <param name="whereLambda">查询条件</param> 263 /// <param name="sortName">排序名称</param> 264 /// <param name="sortDirection">asc 或 desc</param> 265 /// <returns></returns> 266 public List<T> GetPageListByName<T>(int pageIndex, int pageSize, out int rowCount, Expression<Func<T, bool>> whereLambda, string sortName, string sortDirection) where T : class 267 { 268 int count = 0; 269 count = db.Set<T>().Where(whereLambda).Count(); 270 271 List<T> list = db.Set<T>().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 /// <summary> 284 /// 事务批量处理 285 /// </summary> 286 /// <returns></returns> 287 public int SaveChange() 288 { 289 return db.SaveChanges(); 290 } 291 #endregion 292 293 #region 02-新增 294 /// <summary> 295 /// 新增 296 /// </summary> 297 /// <param name="model">需要新增的实体</param> 298 public void AddNo<T>(T model) where T : class 299 { 300 db.Entry(model).State = EntityState.Added; 301 } 302 #endregion 303 304 #region 03-删除 305 /// <summary> 306 /// 删除 307 /// </summary> 308 /// <param name="model">需要删除的实体</param> 309 public void DelNo<T>(T model) where T : class 310 { 311 db.Entry(model).State = EntityState.Deleted; 312 } 313 #endregion 314 315 #region 04-根据条件删除 316 /// <summary> 317 /// 条件删除 318 /// </summary> 319 /// <param name="delWhere">需要删除的条件</param> 320 public void DelByNo<T>(Expression<Func<T, bool>> delWhere) where T : class 321 { 322 List<T> listDels = db.Set<T>().Where(delWhere).ToList(); 323 listDels.ForEach(model => 324 { 325 db.Entry(model).State = EntityState.Deleted; 326 }); 327 } 328 #endregion 329 330 #region 05-修改 331 /// <summary> 332 /// 修改 333 /// </summary> 334 /// <param name="model">修改后的实体</param> 335 public void ModifyNo<T>(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 /// <summary> 346 /// 执行增加,删除,修改操作(或调用存储过程) 347 /// </summary> 348 /// <param name="sql"></param> 349 /// <param name="pars"></param> 350 /// <returns></returns> 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 /// <summary> 360 /// 执行查询操作 361 /// 注：查询必须返回实体的所有属性字段；结果集中列名必须与属性映射的项目匹配；查询中不能包含关联数据 362 /// 除Select以外其他的SQL语句无法执行 363 /// </summary> 364 /// <typeparam name="T"></typeparam> 365 /// <param name="sql"></param> 366 /// <param name="isTrack">是否跟踪状态，默认是跟踪的</param> 367 /// <param name="pars"></param> 368 /// <returns></returns> 369 public List<T> ExecuteQuery<T>(string sql, bool isTrack = true, params SqlParameter[] pars) where T : class 370 { 371 if (isTrack) 372 { 373 //表示跟踪状态（默认是跟踪的） 374 return db.Set<T>().FromSqlRaw(sql, pars).ToList(); 375 } 376 else 377 { 378 //表示不跟踪状态 379 return db.Set<T>().FromSqlRaw(sql, pars).AsNoTracking().ToList(); 380 } 381 } 382 #endregion 383 384 #region 03-执行查询操作（与Linq相结合） 385 /// <summary> 386 /// 执行查询操作 387 /// 注：查询必须返回实体的所有属性字段；结果集中列名必须与属性映射的项目匹配；查询中不能包含关联数据 388 /// 除Select以外其他的SQL语句无法执行 389 /// </summary> 390 /// <typeparam name="T"></typeparam> 391 /// <param name="sql"></param> 392 /// <param name="whereLambda">查询条件</param> 393 /// <param name="isTrack">是否跟踪状态，默认是跟踪的</param> 394 /// <param name="pars"></param> 395 /// <returns></returns> 396 public List<T> ExecuteQueryWhere<T>(string sql, Expression<Func<T, bool>> whereLambda, bool isTrack = true, params SqlParameter[] pars) where T : class 397 { 398 if (isTrack) 399 { 400 //表示跟踪状态（默认是跟踪的） 401 return db.Set<T>().FromSqlRaw(sql, pars).Where(whereLambda).ToList(); 402 } 403 else 404 { 405 //表示不跟踪状态 406 return db.Set<T>().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>(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 /// <summary> 426 /// 删除 427 /// </summary> 428 /// <param name="model">需要删除的实体</param> 429 /// <returns></returns> 430 public async Task<int> DelAsync<T>(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 /// <summary> 439 /// 根据条件删除(支持批量删除) 440 /// </summary> 441 /// <param name="delWhere">传入Lambda表达式(生成表达式目录树)</param> 442 /// <returns></returns> 443 public async Task<int> DelByAsync<T>(Expression<Func<T, bool>> delWhere) where T : class 444 { 445 List<T> listDels = db.Set<T>().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 /// <summary> 456 /// 修改 457 /// </summary> 458 /// <param name="model">修改后的实体</param> 459 /// <returns></returns> 460 public async Task<int> ModifyAsync<T>(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 /// <summary> 473 /// 事务批量处理 474 /// </summary> 475 /// <returns></returns> 476 public async Task<int> SaveChangeAsync() 477 { 478 return await db.SaveChangesAsync(); 479 } 480 #endregion 481 482 #region 02-新增 483 /// <summary> 484 /// 新增 485 /// </summary> 486 /// <param name="model">需要新增的实体</param> 487 public async void AddNoAsync<T>(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 /// <summary> 498 /// 执行增加,删除,修改操作(或调用存储过程) 499 /// </summary> 500 /// <param name="sql"></param> 501 /// <param name="pars"></param> 502 /// <returns></returns> 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 /// <summary> 514 /// 增加 515 /// </summary> 516 /// <typeparam name="T"></typeparam> 517 /// <param name="list"></param> 518 public void BulkInsert<T>(List<T> list) where T : class 519 { 520 db.BulkInsert<T>(list); 521 } 522 #endregion 523 524 #region 02-修改 525 /// <summary> 526 /// 修改 527 /// PS：传入的实体如果不赋值,则更新为null,即传入的实体每个字段都要有值 528 /// </summary> 529 /// <typeparam name="T"></typeparam> 530 /// <param name="list"></param> 531 public void BulkUpdate<T>(List<T> list) where T : class 532 { 533 db.BulkUpdate<T>(list); 534 } 535 #endregion 536 537 #region 03-删除 538 /// <summary> 539 /// 删除 540 /// PS：传入的list中的实体仅需要主键有值,它是根据主键删除的 541 /// </summary> 542 /// <typeparam name="T"></typeparam> 543 /// <param name="list"></param> 544 public void BulkDelete<T>(List<T> list) where T : class 545 { 546 db.BulkDelete<T>(list); 547 } 548 #endregion 549 550 #region 04-条件删除 551 /// <summary> 552 /// 条件删除 553 /// </summary> 554 /// <param name="delWhere">需要删除的条件</param> 555 public int BatchDelete<T>(Expression<Func<T, bool>> delWhere) where T : class 556 { 557 return db.Set<T>().Where(delWhere).BatchDelete(); 558 } 559 #endregion 560 561 #region 05-条件更新1 562 /// <summary> 563 /// 条件更新 564 /// PS：要更新哪几个字段，就给传入的实体中的哪几个字段赋值 565 /// </summary> 566 /// <param name="delWhere">需要更新的条件</param> 567 /// <param name="model">更新为的实体</param> 568 public int BatchUpdate<T>(Expression<Func<T, bool>> delWhere, T model) where T : class, new() 569 { 570 return db.Set<T>().Where(delWhere).BatchUpdate<T>(model); 571 } 572 #endregion 573 574 #region 06-条件更新2 575 /// <summary> 576 /// 条件更新 577 /// PS：要更新哪几个字段，就给传入的实体中的哪几个字段赋值 578 /// </summary> 579 /// <param name="delWhere">需要更新的条件</param> 580 /// <param name="model">更新为的实体</param> 581 public int BatchUpdate2<T>(Expression<Func<T, bool>> delWhere, Expression<Func<T, T>> modelWhere) where T : class, new() 582 { 583 return db.Set<T>().Where(delWhere).BatchUpdate<T>(modelWhere); 584 } 585 #endregion 586 587 588 589 } 590 }
!
- 作 者 : Yaopengfei(姚鹏飞)
- 博客地址 : http://www.cnblogs.com/yaopengfei/
- 声 明1 : 本人才疏学浅，用郭德纲的话说“我是一个小学生”，如有错误，欢迎讨论，请勿谩骂^_^。
- 声 明2 : 原创博客请在转载时保留原文链接或在文章开头加上本人博客地址，否则保留追究法律责任的权利。