Repository封装方法

1.创建依赖的实体类

/// <summary>

/// 泛型实体基类
/// </summary>
/// <typeparam name="TPrimaryKey">主键类型</typeparam>
public abstract class Entity<TPrimaryKey>
{
/// <summary>
/// 主键
/// </summary>
public virtual TPrimaryKey Id { get; set; }
}

/// <summary>
/// 定义默认主键类型为int的实体基类
/// </summary>
public abstract class Entitys : Entity<int>
{

}

2.定义封装的接口

public interface IRepository<T> where T : Entitys
{

//异步保存保存信息
Task<int> SaveChangesAsync();
void SaveChanges();

//添加实体类
T Add(T data);

//批量添加实体类
IEnumerable<T> AddRange(IEnumerable<T> entitys);

//异步批量添加实体类
Task<IEnumerable<T>> AddRangeAsync(IEnumerable<T> entitys);

bool Remove(T data);

bool RemoveRange(IEnumerable<T> entitys);

bool Update(T data);

int Max(Expression<Func<T, int>> whereLamdba);

/// <summary>
/// 查询记录数
/// </summary>
/// <param name="whereLambda">查询表达式</param>
/// <returns></returns>
int Count(Expression<Func<T, bool>> whereLambda);

/// <summary>
/// 是否存在
/// </summary>
/// <param name="anyLambda">查询表达式</param>
/// <returns></returns>
bool Exist(Expression<Func<T, bool>> anyLambda);

/// <summary>
/// 得到数据集
/// </summary>
/// <returns></returns>
DbSet<T> Set();

T Find(Expression<Func<T, bool>> whereLambda);

/// <summary>
/// 查找数据列表
/// </summary>
/// <param name="whereLamdba">查询表达式</param>
/// <param name="orderName">排序名称</param>
/// <param name="isAsc">isAsc</param>
/// <returns></returns>
IQueryable<T> FindList(Expression<Func<T, bool>> whereLamdba, string orderName, bool isAsc);
/// <summary>
/// sql查找数据列表
/// </summary>
/// <param name="sql"></param>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <param name="totalRecord"></param>
/// <param name="whereLamdba"></param>
/// <param name="orderName"></param>
/// <param name="isAsc"></param>
/// <returns></returns>
IQueryable<T> FindPageListFromsql(int pageIndex, int pageSize, out int totalRecord, string sql, string orderName, bool isAsc);
/// <summary>
/// 查找分页数据列表
/// </summary>
/// <param name="pageIndex">当前页</param>
/// <param name="pageSize">每页记录数</param>
/// <param name="totalRecord">总记录数</param>
/// <param name="whereLamdba">查询表达式</param>
/// <param name="orderName">排序名称</param>
/// <param name="isAsc">是否升序</param>
/// <returns></returns>
IQueryable<T> FindPageList(int pageIndex, int pageSize, out int totalRecord, Expression<Func<T, bool>> whereLamdba, string orderName, bool isAsc);

IQueryable<T> FromSql(string sql);

/// <summary>
/// 操作数据库
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
int ExecuteSqlCommand(string sql);
}

3 .实现接口方法

public class Repository<T> : IRepository<T> where T : Entitys
{
protected virtual StudyDbContext nWriteContext { get; set; }
protected virtual StudyDbContext nReadContext { get; set; }

public Repository(IServiceProvider serviceProvider, StudyDbContext studyDbContext)
{
this.nWriteContext = studyDbContext;
this.nReadContext = this.nWriteContext;
}

public void SaveChanges()
{
nWriteContext.SaveChanges();
}
public async Task<int> SaveChangesAsync()
{
return await nWriteContext.SaveChangesAsync();
}

public T Add(T entity)
{
nWriteContext.Entry<T>(entity).State = EntityState.Added;
nWriteContext.SaveChanges();
return entity;
}

public IEnumerable<T> AddRange(IEnumerable<T> entitys)
{
foreach (var entity in entitys)
{
nWriteContext.Entry<T>(entity).State = EntityState.Added;
}
nWriteContext.SaveChanges();
return entitys;
}
public async Task<IEnumerable<T>> AddRangeAsync(IEnumerable<T> entitys)
{
foreach (var entity in entitys)
{
nWriteContext.Entry<T>(entity).State = EntityState.Added;
}
await nWriteContext.SaveChangesAsync();
return entitys;
}

public int Count(Expression<Func<T, bool>> predicate)
{
//return nReadContext.Set<T>().Count(predicate);
return nReadContext.Set<T>().Count(predicate);
}

public bool Update(T entity)
{
nWriteContext.Set<T>().Attach(entity);
nWriteContext.Entry<T>(entity).State = EntityState.Modified;
return nWriteContext.SaveChanges() > ;
}

public bool Remove(T entity)
{
nWriteContext.Set<T>().Attach(entity);
nWriteContext.Entry<T>(entity).State = EntityState.Deleted;
return nWriteContext.SaveChanges() > ;
}

public bool RemoveRange(IEnumerable<T> entitys)
{
foreach (var entity in entitys)
{
nWriteContext.Set<T>().Attach(entity);
nWriteContext.Entry<T>(entity).State = EntityState.Deleted;
}
return nWriteContext.SaveChanges() > ;
}

public bool Exist(Expression<Func<T, bool>> anyLambda)
{
return nReadContext.Set<T>().Any(anyLambda); //Read
}

public T Find(Expression<Func<T, bool>> whereLambda)
{
T _entity = nReadContext.Set<T>().FirstOrDefault<T>(whereLambda);//Read
return _entity;
}

public DbSet<T> Set()
{
//var type = DbSlaveType.master;
//if (type == DbSlaveType.master)
//{
return nWriteContext.Set<T>();
//}
//else
//{
// return nReadContext.Set<T>();//read
//}
}

public IQueryable<T> FindList(Expression<Func<T, bool>> whereLamdba, string orderName, bool isAsc)
{
var _list = nReadContext.Set<T>().Where<T>(whereLamdba); //read
_list = OrderBy(_list, orderName, isAsc);
return _list;
}

public IQueryable<T> FindPageList(int pageIndex, int pageSize, out int totalRecord, Expression<Func<T, bool>> whereLamdba, string orderName, bool isAsc)
{
var _list = nReadContext.Set<T>().Where<T>(whereLamdba); //read
totalRecord = _list.Count();
_list = OrderBy(_list, orderName, isAsc).Skip<T>((pageIndex - ) * pageSize).Take<T>(pageSize);
return _list;
}

public IQueryable<T> FindPageListFromsql(int pageIndex, int pageSize, out int totalRecord, string sql, string orderName, bool isAsc)
{
var _list = nWriteContext.Set<T>().FromSql(sql); //read
totalRecord = _list.Count();
_list = OrderBy(_list, orderName, isAsc).Skip<T>((pageIndex - ) * pageSize).Take<T>(pageSize);
return _list;
}
/// <summary>
/// 排序
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="source">原IQueryable</param>
/// <param name="propertyName">排序属性名</param>
/// <param name="isAsc">是否正序</param>
/// <returns>排序后的IQueryable<T></returns>
private IQueryable<T> OrderBy(IQueryable<T> source, string propertyName, bool isAsc)
{
if (source == null)
{
//throw new ArgumentNullException("source", "不能为空");
return null;
}
if (string.IsNullOrEmpty(propertyName)) return source;
var _parameter = Expression.Parameter(source.ElementType);
var _property = Expression.Property(_parameter, propertyName);
if (_property == null)
{
// throw new ArgumentNullException("propertyName", "属性不存在");
return null;
}
var _lambda = Expression.Lambda(_property, _parameter);
var _methodName = isAsc ? "OrderBy" : "OrderByDescending";
var _resultExpression = Expression.Call(typeof(Queryable), _methodName, new Type[] { source.ElementType, _property.Type }, source.Expression, Expression.Quote(_lambda));
return source.Provider.CreateQuery<T>(_resultExpression);
}

public int Max(Expression<Func<T, int>> whereLamdba)
{
return nWriteContext.Set<T>().Select(whereLamdba).Max(); //read
}

public IQueryable<T> FromSql(string sql)
{
return nWriteContext.Set<T>().FromSql(sql); //read
}

public int ExecuteSqlCommand(string sql)
{
return nWriteContext.Database.ExecuteSqlCommand(sql);
}

}