自己编写的 entity framwork 6 通用 dal 类 增删改查 多分类字段

public class BaseDAL<T> where T : class,new()
{
string strConn = "";
public BaseDAL(string connString)
{
strConn = connString;
}

/// <summary>
/// 新增
/// </summary>
/// <param name="entity">实体</param>
/// <returns>返回受影响行数</returns>
public bool Add(T entity)
{
using (SysDb db = new SysDb(strConn))
{
db.Entry<T>(entity).State = EntityState.Added;
return db.SaveChanges() > 0;

}
}

/// <summary>
/// 修改
/// </summary>
/// <param name="entity">实体</param>
/// <returns>返回受影响行数</returns>
public bool Update(T entity)
{
using (SysDb db = new SysDb(strConn))
{
db.Set<T>().Attach(entity);
db.Entry<T>(entity).State = EntityState.Modified;
return db.SaveChanges() > 0;
}
}

/// <summary>
/// 删除
/// </summary>
/// <param name="entity">实体</param>
/// <returns>返回受影响行数</returns>
public bool Delete(T entity)
{
using (SysDb db = new SysDb(strConn))
{
db.Set<T>().Attach(entity);
db.Entry<T>(entity).State = EntityState.Deleted;
return db.SaveChanges() > 0;
}
}

/// <summary>
/// 根据条件删除
/// </summary>
/// <param name="deleWhere">删除条件</param>
/// <returns>返回受影响行数</returns>
public bool DeleteByConditon(Expression<Func<T, bool>> deleWhere)
{
using (SysDb db = new SysDb(strConn))
{
List<T> entitys = db.Set<T>().Where(deleWhere).ToList();
entitys.ForEach(m => db.Entry<T>(m).State = EntityState.Deleted);
return db.SaveChanges() > 0;
}
}

/// <summary>
/// 查找单个
/// </summary>
/// <param name="id">主键</param>
/// <returns></returns>
public T GetSingleById(int id)
{
using (SysDb db = new SysDb(strConn))
{
return db.Set<T>().Find(id);
}
}

/// <summary>
/// 查找单个
/// </summary>
/// <param name="seleWhere">查询条件</param>
/// <returns></returns>
public T GetSingle(Expression<Func<T, bool>> seleWhere)
{
using (SysDb db = new SysDb(strConn))
{
return db.Set<T>().AsExpandable().FirstOrDefault(seleWhere);
}
}

/// <summary>
/// 获取所有实体集合
/// </summary>
/// <returns></returns>
public List<T> GetAll()
{
using (SysDb db = new SysDb(strConn))
{
return db.Set<T>().AsExpandable().ToList<T>();
}
}

/// <summary>
/// 获取所有实体集合(单个排序)
/// </summary>
/// <returns></returns>
public List<T> GetAll<Tkey>(Expression<Func<T, Tkey>> orderWhere,bool isDesc)
{
using (SysDb db = new SysDb(strConn))
{
return CommonSort(db.Set<T>().AsExpandable(), orderWhere, isDesc).ToList<T>();
}
}

/// <summary>
/// 获取所有实体集合(多个排序)
/// </summary>
/// <returns></returns>
public List<T> GetAll(params OrderModelField[] orderByExpression)
{
using (SysDb db = new SysDb(strConn))
{
return CommonSort(db.Set<T>().AsExpandable(), orderByExpression).ToList();
}
}

/// <summary>
/// 单个排序通用方法
/// </summary>
/// <typeparam name="Tkey">排序字段</typeparam>
/// <param name="data">要排序的数据</param>
/// <param name="orderWhere">排序条件</param>
/// <param name="isDesc">是否倒序</param>
/// <returns>排序后的集合</returns>
public IQueryable<T> CommonSort<Tkey>(IQueryable<T> data, Expression<Func<T, Tkey>> orderWhere, bool isDesc)
{
if (isDesc)
{
return data.OrderByDescending(orderWhere);
}
else
{
return data.OrderBy(orderWhere);
}
}

/// <summary>
/// 多个排序通用方法
/// </summary>
/// <typeparam name="Tkey">排序字段</typeparam>
/// <param name="data">要排序的数据</param>
/// <param name="orderWhereAndIsDesc">字典集合(排序条件,是否倒序)</param>
/// <returns>排序后的集合</returns>
public IQueryable<T> CommonSort(IQueryable<T> data, params OrderModelField[] orderByExpression)
{
//创建表达式变量参数
var parameter = Expression.Parameter(typeof(T), "o");

if (orderByExpression != null && orderByExpression.Length > 0)
{
for (int i = 0; i < orderByExpression.Length; i++)
{
//根据属性名获取属性
var property = typeof(T).GetProperty(orderByExpression[i].PropertyName);
//创建一个访问属性的表达式
var propertyAccess = Expression.MakeMemberAccess(parameter, property);
var orderByExp = Expression.Lambda(propertyAccess, parameter);

string OrderName = "";
if (i > 0)
{
OrderName = orderByExpression[i].IsDESC ? "ThenByDescending" : "ThenBy";
}
else
OrderName = orderByExpression[i].IsDESC ? "OrderByDescending" : "OrderBy";

MethodCallExpression resultExp = Expression.Call(typeof(Queryable), OrderName, new Type[] { typeof(T), property.PropertyType },
data.Expression, Expression.Quote(orderByExp));

data = data.Provider.CreateQuery<T>(resultExp);
}
}
return data;
}

/// <summary>
/// 根据条件查询实体集合
/// </summary>
/// <param name="seleWhere">查询条件 lambel表达式</param>
/// <returns></returns>
public List<T> GetList(Expression<Func<T, bool>> seleWhere)
{
using (SysDb db = new SysDb(strConn))
{
return db.Set<T>().AsExpandable().Where(seleWhere).ToList();
}
}

/// <summary>
/// 根据条件查询实体集合(单个字段排序)
/// </summary>
/// <param name="seleWhere">查询条件 lambel表达式</param>
/// <returns></returns>
public List<T> GetList<Tkey>(Expression<Func<T, bool>> seleWhere, Expression<Func<T, Tkey>> orderWhere,bool isDesc)
{
using (SysDb db = new SysDb(strConn))
{
return CommonSort(db.Set<T>().AsExpandable().Where(seleWhere),orderWhere,isDesc).ToList();
}
}

/// <summary>
/// 根据条件查询实体集合(多个字段排序)
/// </summary>
/// <param name="seleWhere">查询条件 lambel表达式</param>
/// <returns></returns>
public List<T> GetList(Expression<Func<T, bool>> seleWhere, params OrderModelField[] orderByExpression)
{
using (SysDb db = new SysDb(strConn))
{
return CommonSort(db.Set<T>().AsExpandable().Where(seleWhere), orderByExpression).ToList();
}
}

/// <summary>
/// 获取分页集合(无条件无排序)
/// </summary>
/// <returns></returns>
public List<T> GetListPaged<Tkey>(int pageIndex, int pageSize, out int totalcount)
{
using (SysDb db = new SysDb(strConn))
{
totalcount = db.Set<T>().AsExpandable().Count();//获取总数
//需要增加AsExpandable(),否则查询的是所有数据到内存，然后再排序  AsExpandable是linqkit.dll中的方法
return db.Set<T>().AsExpandable().Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
}
}

/// <summary>
/// 获取分页集合(无条件单个排序)
/// </summary>
/// <returns></returns>
public List<T> GetListPaged<Tkey>(int pageIndex, int pageSize, Expression<Func<T, Tkey>> orderWhere,bool isDesc,out int totalcount)
{
using (SysDb db = new SysDb(strConn))
{
totalcount = db.Set<T>().AsExpandable().Count();//获取总数
//需要增加AsExpandable(),否则查询的是所有数据到内存，然后再排序  AsExpandable是linqkit.dll中的方法
return CommonSort(db.Set<T>().AsExpandable(), orderWhere, isDesc).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
}
}

/// <summary>
/// 获取分页集合(无条件多字段排序)
/// </summary>
/// <returns></returns>
public List<T> GetListPaged(int pageIndex, int pageSize, out int totalcount, params OrderModelField[] orderByExpression)
{
using (SysDb db = new SysDb(strConn))
{
totalcount = db.Set<T>().AsExpandable().Count();//获取总数
//需要增加AsExpandable(),否则查询的是所有数据到内存，然后再排序  AsExpandable是linqkit.dll中的方法
return CommonSort(db.Set<T>().AsExpandable(), orderByExpression).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
}
}

/// <summary>
/// 获取分页集合(有条件无排序)
/// </summary>
/// <returns></returns>
public List<T> GetListPaged<Tkey>(int pageIndex, int pageSize, Expression<Func<T, bool>> seleWhere,out int totalcount)
{
using (SysDb db = new SysDb(strConn))
{
totalcount = db.Set<T>().AsExpandable().Where(seleWhere).Count();//获取总数
//需要增加AsExpandable(),否则查询的是所有数据到内存，然后再排序  AsExpandable是linqkit.dll中的方法
return db.Set<T>().AsExpandable().Where(seleWhere).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
}
}

/// <summary>
/// 获取分页集合(有条件单个排序)
/// </summary>
/// <returns></returns>
public List<T> GetListPaged<Tkey>(int pageIndex, int pageSize, Expression<Func<T, bool>> seleWhere, Expression<Func<T, Tkey>> orderWhere, bool isDesc, out int totalcount)
{
using (SysDb db = new SysDb(strConn))
{
totalcount = db.Set<T>().AsExpandable().Where(seleWhere).Count();//获取总数
//需要增加AsExpandable(),否则查询的是所有数据到内存，然后再排序  AsExpandable是linqkit.dll中的方法
return CommonSort(db.Set<T>().AsExpandable().Where(seleWhere), orderWhere, isDesc).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
}
}

/// <summary>
/// 获取分页集合(有条件多字段排序)
/// </summary>
/// <returns></returns>
public List<T> GetListPaged(int pageIndex, int pageSize, Expression<Func<T, bool>> seleWhere, out int totalcount,params OrderModelField[] orderModelFiled)
{
using (SysDb db = new SysDb(strConn))
{
totalcount = db.Set<T>().AsExpandable().Where(seleWhere).Count();//获取总数
//需要增加AsExpandable(),否则查询的是所有数据到内存，然后再排序  AsExpandable是linqkit.dll中的方法
return CommonSort(db.Set<T>().AsExpandable().Where(seleWhere), orderModelFiled).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
}
}

/// <summary>
/// 增加rownum列
/// </summary>
/// <param name="lsTemp"></param>
/// <returns></returns>
public List<T> AddRowNum(List<T> lsTemp)
{
if (typeof(T).GetProperty("RowNum") != null)
{
int i=0;
foreach (var item in lsTemp)
{
typeof(T).GetProperty("RowNum").SetValue(item, i, null);
i++;
}
}
return lsTemp;
}

}

public struct OrderModelField
{
public string PropertyName { get; set; }
public bool IsDESC { get; set; }
}