不成功的MVC Repository模式，记录下来，后面看看原因在哪里(二) Repository类

public class Repository<T> : IRepository<T> where T : class
{
public WBIDbContext m_Context=WBIContextFactory.GetCurrentContext();//上下文数据库
public DbSet<T> dbSet;
public Repository(WBIDbContext dbContext)
{
this.m_Context = dbContext;
this.dbSet = dbContext.Set<T>();
}

protected IRepository<T> m_currentRepository1 { get; set; }
protected IDevTypeRepository m_currentRepository { get; set; }
public Repository(IDevTypeRepository currentRepository)
{
m_currentRepository = currentRepository;
}

public T Add(T entity)
{
//设置实体的状态 add
m_Context.Entry<T>(entity).State = System.Data.Entity.EntityState.Added;
//将上下文中所做的更改保存到数据库中
m_Context.SaveChanges();
//返回保存后的实体
return entity;
}

public bool Update(T entity)
{
m_Context.Set<T>().Attach(entity);
m_Context.Entry<T>(entity).State = System.Data.Entity.EntityState.Modified;
return m_Context.SaveChanges() > 0;
}

public bool Delete(T entity)

{
m_Context.Set<T>().Attach(entity);
m_Context.Entry<T>(entity).State = System.Data.Entity.EntityState.Deleted;
return m_Context.SaveChanges() > 0;
}

//名字是否为空
public bool CheckNameIsEmpty(Expression<Func<T, bool>> whereLambda)
{
return m_Context.Set<T>().Any(whereLambda);
}

//名字是否存在
public bool CheckNameExist(Expression<Func<T, bool>> whereLambda)
{
return m_Context.Set<T>().Any(whereLambda);
}
//检查其他项
public bool Check(Expression<Func<T, bool>> whereLambda)
{
return m_Context.Set<T>().Any(whereLambda);
}
//保存
//public void Save()
//{
//    m_Context.SaveChanges();

//}

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

public List<T> ToList()
{
return m_Context.Set<T>().ToList();
}

public T Find(Expression<Func<T, bool>> whereLambda)
{
T entity = m_Context.Set<T>().FirstOrDefault<T>(whereLambda);
return entity;
}

public IQueryable<T> FindList(Expression<Func<T, bool>> whereLamba, string orderName, bool isAsc)
{
var list = m_Context.Set<T>().Where(whereLamba);
list = OrderBy(list, orderName, isAsc);
return list;
}

public IQueryable<T> FindList<S>(Expression<Func<T, bool>> whereLambda, bool isAsc, Expression<Func<T, S>> orderLamba)
{
var list = m_Context.Set<T>().Where<T>(whereLambda);
if (isAsc)
{
list = list.OrderBy<T, S>(orderLamba);
}
else
{
list = list.OrderByDescending<T, S>(orderLamba);//降序排列
}
return list;
}

public IQueryable<T> FindPageList<S>(int pageIndex, int pageSize, out int totalRecordCnt,
Expression<Func<T, bool>> whereLamdba, bool isAsc, Expression<Func<T, S>> orderLambda)
{
var list = m_Context.Set<T>().Where<T>(whereLamdba);
totalRecordCnt = list.Count();

if (isAsc)
{
list = list.OrderBy<T, S>(orderLambda)
.Skip<T>((pageIndex - 1) * pageSize).Take<T>(pageSize);
}
else
{
list = list.OrderByDescending<T, S>(orderLambda)
.Skip<T>((pageIndex - 1) * pageSize).Take<T>(pageSize);
}

return list;
}

#region Private Methods
/// <summary>
/// 排序
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="source">原IQueryable</param>
/// <param name="propertyName">排序属性名</param>
/// <param name="isAsc">是否升序</param>
/// <returns>排序后的IQueryable</returns>
private IQueryable<T> OrderBy(IQueryable<T> source, string propertyName, bool isAsc)
{
if (source == null)
{
throw new ArgumentNullException("source", "不能为空");
}
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", "属性不存在");
}
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);
}
#endregion
}