EF 通用数据层 增删改查操作，泛型类

using System;
using System.Collections.Generic;
using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;

namespace DAL
{
/// MSSql 数据库 数据层 父类
/// 
/// 
public class BaseDAL where T : class,new()
{
/// 
/// EF 上下文对象
/// 
DbContext db = new DBContextFactory().GetDbContext();

//增
#region 1.0 新增实体，返回受影响的行数 + int Add(T model)
/// 
/// 1.0 新增实体，返回受影响的行数
/// 
/// 
/// 返回受影响的行数
public int Add(T model)
{
db.Set().Add(model);
//保存成功后，会将自增的id设置给model的主键属性，并返回受影响的行数。
return db.SaveChanges();
}
#endregion
#region 1.1 新增实体，返回对应的实体对象 + T AddReturnModel(T model)
/// 
/// 1.1 新增实体，返回对应的实体对象
/// 
/// 
/// 
public T AddReturnModel(T model)
{
db.Set().Add(model);
db.SaveChanges();
return model;
}
#endregion

//删
#region 2.0 根据id删除 + int Del(T model)
/// 
/// 2.0 根据id删除
/// 
/// 必须包含要删除id的对象
/// 
public int Del(T model)
{
db.Set().Attach(model);
db.Set().Remove(model);
return db.SaveChanges();
}
#endregion
#region 2.1 根据条件删除 + int DelBy(Expression<Func<T, bool>> delWhere)
/// 
/// 2.1 根据条件删除
/// 
/// 
/// 返回受影响的行数
public int DelBy(Expression<Func<T, bool>> delWhere)
{
//2.1.1 查询要删除的数据
List listDeleting = db.Set().Where(delWhere).ToList();
//2.1.2 将要删除的数据 用删除方法添加到 EF 容器中
listDeleting.ForEach(u =>
{
db.Set().Attach(u); //先附加到EF 容器
db.Set().Remove(u); //标识为删除状态
});
//2.1.3 一次性生成sql语句 到数据库执行删除
return db.SaveChanges();
}
#endregion

//改
#region 3.0 修改实体 + int Modify(T model)
/// 
/// 修改实体
/// 
/// 
/// 
public int Modify(T model)
{
DbEntityEntry entry = db.Entry(model);
entry.State = EntityState.Modified;
return db.SaveChanges();
}
#endregion
#region 3.1 修改实体，可修改指定属性 + int Modify(T model, params string[] propertyNames)
/// 
/// 3.1 修改实体，可修改指定属性
/// 
/// 
/// 
/// 
public int Modify(T model, params string[] propertyNames)
{
//3.1.1 将对象添加到EF中
DbEntityEntry entry = db.Entry(model);
//3.1.2 先设置对象的包装状态为 Unchanged
entry.State = EntityState.Unchanged;
//3.1.3 循环被修改的属性名数组
foreach (string propertyName in propertyNames)
{
//将每个被修改的属性的状态设置为已修改状态；这样在后面生成的修改语句时，就只为标识为已修改的属性更新
entry.Property(propertyName).IsModified = true;
}
return db.SaveChanges();
}
#endregion
#region 3.2 批量修改 + int ModifyBy(T model, Expression<Func<T, bool>> whereLambda, params string[] modifiedPropertyNames)
/// 
/// 3.2 批量修改
/// 
/// 
/// 
/// 
/// 
public int ModifyBy(T model, Expression<Func<T, bool>> whereLambda, params string[] modifiedPropertyNames)
{
//3.2.1 查询要修改的数据
List listModifing = db.Set().Where(whereLambda).ToList();
//3.2.2 获取实体类类型对象
Type t = typeof(T);
//3.2.3 获取实体类所有的公共属性
List propertyInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
//3.2.4 创建实体属性字典集合
Dictionary<string, PropertyInfo> dicPropertys = new Dictionary<string, PropertyInfo>();
//3.2.5 将实体属性中要修改的属性名 添加到字典集合中 键：属性名 值：属性对象
propertyInfos.ForEach(p =>
{
if (modifiedPropertyNames.Contains(p.Name))
{
dicPropertys.Add(p.Name, p);
}
});
//3.2.6 循环要修改的属性名
foreach (string propertyName in modifiedPropertyNames)
{
//判断要修改的属性名是否在实体类的属性集合中存在
if (dicPropertys.ContainsKey(propertyName))
{
//如果存在，则取出要修改的属性对象
PropertyInfo proInfo = dicPropertys[propertyName];
//取出要修改的值
object newValue = proInfo.GetValue(model, null);
//批量设置要修改对象的属性
foreach (T item in listModifing)
{
//为要修改的对象的要修改的属性设置新的值
proInfo.SetValue(item, newValue, null);
}
}
}
//一次性生成sql语句 到数据库执行
return db.SaveChanges();
}
#endregion

//查，查单个model
#region 4.0 根据条件查询单个model + T GetModel(Expression<Func<T, bool>> whereLambda)
/// 
/// 4.0 根据条件查询单个model
/// 
/// 
/// 
public T GetModel(Expression<Func<T, bool>> whereLambda)
{
return db.Set().Where(whereLambda).AsNoTracking().FirstOrDefault();
}
#endregion
#region 4.1 根据条件查询单个model并排序 + T GetModel(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
/// 
/// 4.1 根据条件查询单个model并排序
/// 
/// 
/// 
/// 
/// 
/// 
public T GetModel(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
{
if (isAsc)
{
return db.Set().Where(whereLambda).OrderBy(orderLambda).AsNoTracking().FirstOrDefault();
}
else
{
return db.Set().Where(whereLambda).OrderByDescending(orderLambda).AsNoTracking().FirstOrDefault();
}
}
#endregion

//查，查List
#region 5.0 根据条件查询 + List GetListBy(Expression<Func<T, bool>> whereLambda)
/// 
/// 5.0 根据条件查询
/// 
/// 
/// 
public List GetListBy(Expression<Func<T, bool>> whereLambda)
{
return db.Set().Where(whereLambda).AsNoTracking().ToList();
}
#endregion
#region 5.1 根据条件查询，并排序 + List GetListBy(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
/// 
/// 5.1 根据条件查询，并排序
/// 
/// 
/// 
/// 
/// 
/// 
public List GetListBy(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
{
if (isAsc)
{
return db.Set().Where(whereLambda).OrderBy(orderLambda).AsNoTracking().ToList();
}
else
{
return db.Set().Where(whereLambda).OrderByDescending(orderLambda).AsNoTracking().ToList();
}
}
#endregion
#region 5.2 根据条件查询Top多少个，并排序 + List GetListBy(int top, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
/// 
/// 5.2 根据条件查询Top多少个，并排序
/// 
/// 
/// 
/// 
/// 
/// 
/// 
public List GetListBy(int top, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
{
if (isAsc)
{
return db.Set().Where(whereLambda).OrderBy(orderLambda).Take(top).AsNoTracking().ToList();
}
else
{
return db.Set().Where(whereLambda).OrderByDescending(orderLambda).Take(top).AsNoTracking().ToList();
}
}
#endregion
#region 5.3 根据条件排序查询 双排序 + List GetListBy<TKey1, TKey2>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey1>> orderLambda1, Expression<Func<T, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
/// 
/// 5.3 根据条件排序查询 双排序
/// 
/// 
/// 
/// 
/// 
/// 
/// 
/// 
/// 
public List GetListBy<TKey1, TKey2>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey1>> orderLambda1, Expression<Func<T, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
{
if (isAsc1)
{
if (isAsc2)
{
return db.Set().Where(whereLambda).OrderBy(orderLambda1).ThenBy(orderLambda2).AsNoTracking().ToList();
}
else
{
return db.Set().Where(whereLambda).OrderBy(orderLambda1).ThenByDescending(orderLambda2).AsNoTracking().ToList();
}
}
else
{
if (isAsc2)
{
return db.Set().Where(whereLambda).OrderByDescending(orderLambda1).ThenBy(orderLambda2).AsNoTracking().ToList();
}
else
{
return db.Set().Where(whereLambda).OrderByDescending(orderLambda1).ThenByDescending(orderLambda2).AsNoTracking().ToList();
}
}
}
#endregion
#region 5.3 根据条件排序查询Top个数 双排序 + List GetListBy<TKey1, TKey2>(int top, Expression<Func<T, bool>> whereLambda, System.Linq.Expressions.Expression<Func<T, TKey1>> orderLambda1, Expression<Func<T, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
/// 
/// 5.3 根据条件排序查询Top个数 双排序
/// 
/// 
/// 
/// 
/// 
/// 
/// 
/// 
/// 
/// 
public List GetListBy<TKey1, TKey2>(int top, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey1>> orderLambda1, Expression<Func<T, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
{
if (isAsc1)
{
if (isAsc2)
{
return db.Set().Where(whereLambda).OrderBy(orderLambda1).ThenBy(orderLambda2).Take(top).AsNoTracking().ToList();
}
else
{
return db.Set().Where(whereLambda).OrderBy(orderLambda1).ThenByDescending(orderLambda2).Take(top).AsNoTracking().ToList();
}
}
else
{
if (isAsc2)
{
return db.Set().Where(whereLambda).OrderByDescending(orderLambda1).ThenBy(orderLambda2).Take(top).AsNoTracking().ToList();
}
else
{
return db.Set().Where(whereLambda).OrderByDescending(orderLambda1).ThenByDescending(orderLambda2).Take(top).AsNoTracking().ToList();
}
}
}
#endregion

//查，带分页查询
#region 6.0 分页查询 + List GetPagedList
/// 
/// 分页查询 + List GetPagedList
/// 
/// 
/// 页码
/// 页容量
/// 条件 lambda表达式
/// 排序 lambda表达式
/// 
public List GetPagedList(int pageIndex, int pageSize, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderByLambda, bool isAsc = true)
{
// 分页 一定注意： Skip 之前一定要 OrderBy
if (isAsc)
{
return db.Set().Where(whereLambda).OrderBy(orderByLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
}
else
{
return db.Set().Where(whereLambda).OrderByDescending(orderByLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
}
}
#endregion
#region 6.1分页查询 带输出 +List GetPagedList
/// 
/// 分页查询 带输出
/// 
/// 
/// 
/// 
/// 
/// 
/// 
/// 
/// 
public List GetPagedList(int pageIndex, int pageSize, ref int rowCount, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderByLambda, bool isAsc = true)
{
rowCount = db.Set().Where(whereLambda).Count();
if (isAsc)
{
return db.Set().OrderBy(orderByLambda).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
}
else
{
return db.Set().OrderByDescending(orderByLambda).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
}
}
#endregion
#region 6.2 分页查询 带输出 并支持双字段排序
/// 
/// 分页查询 带输出 并支持双字段排序
/// 
/// 
/// 
/// 
/// 
/// 
/// 
/// 
/// 
/// 
/// 
public List GetPagedList<TKey1, TKey2>(int pageIndex, int pageSize, ref int rowCount, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey1>> orderByLambda1, Expression<Func<T, TKey2>> orderByLambda2, bool isAsc1 = true, bool isAsc2 = true)
{
rowCount = db.Set().Where(whereLambda).Count();
if (isAsc1)
{
if (isAsc2)
{
return db.Set().OrderBy(orderByLambda1).ThenBy(orderByLambda2).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
}
else
{
return db.Set().OrderBy(orderByLambda1).ThenByDescending(orderByLambda2).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
}
}
else
{
if (isAsc2)
{
return db.Set().OrderByDescending(orderByLambda1).ThenBy(orderByLambda2).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
}
else
{
return db.Set().OrderByDescending(orderByLambda1).ThenByDescending(orderByLambda2).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
}
}
}
#endregion
}
}
--------------------- 
原文：https://blog.csdn.net/weixin_44277627/article/details/88251217