基于Repository模式设计项目架构—你可以参考的项目架构设计

public interface IRepository<TEntity> where TEntity : class 
 { 
    ///获取当前实体的查询数据集 
    IQueryable<TEntity> Entities{get;} 
 
    ///获取当前实体的数据集 
    DbSet<TEntity> DbEntities{get;} 
 
 /// <summary> 
 /// Gets all objects from database 
 /// </summary> 
 /// <returns></returns> 
 IQueryable<TEntity> All(); 
 
 /// <summary> 
 /// Gets objects from database by filter. 
 /// </summary> 
 /// <param name="predicate">Specified a filter</param> 
 /// <returns></returns> 
 IQueryable<TEntity> Filter(Expression<Func<TEntity, bool>> predicate); 
 
 /// <summary> 
 /// Gets objects from database with filting and paging. 
 /// </summary> 
 /// <param name="filter">Specified a filter</param> 
 /// <param name="total">Returns the total records count of the filter.</param> 
 /// <param name="index">Specified the page index.</param> 
 /// <param name="size">Specified the page size</param> 
 /// <returns></returns> 
 IQueryable<TEntity> Filter(Expression<Func<TEntity, bool>> filter, out int total, int index = 0, int size = 50); 
 
 /// <summary> 
 /// Gets the object(s) is exists in database by specified filter. 
 /// </summary> 
 /// <param name="predicate">Specified the filter expression</param> 
 /// <returns></returns> 
 bool Contains(Expression<Func<TEntity, bool>> predicate); 
 
 /// <summary> 
 /// Find object by keys. 
 /// </summary> 
 /// <param name="keys">Specified the search keys.</param> 
 /// <returns></returns> 
 TEntity Find(params object[] keys); 
 
 /// <summary> 
 /// Find object by specified expression. 
 /// </summary> 
 /// <param name="predicate"></param> 
 /// <returns></returns> 
 TEntity Find(Expression<Func<TEntity, bool>> predicate); 
 
 /// <summary> 
 /// Create a new object to database. 
 /// </summary> 
 /// <param name="t">Specified a new object to create.</param> 
 /// <returns></returns> 
 int Create(TEntity t); 
 
 /// <summary> 
 /// Delete the object from database. 
 /// </summary> 
 /// <param name="t">Specified a existing object to delete.</param> 
 void Delete(TEntity t); 
 
 /// <summary> 
 /// Delete objects from database by specified filter expression. 
 /// </summary> 
 /// <param name="predicate"></param> 
 /// <returns></returns> 
 int Delete(Expression<Func<TEntity, bool>> predicate); 
 
 /// <summary> 
 /// Update object changes and save to database. 
 /// </summary> 
 /// <param name="t">Specified the object to save.</param> 
 /// <returns></returns> 
 int Update(TEntity t); 
 
 /// <summary> 
 /// Select Single Item by specified expression. 
 /// </summary> 
 /// <typeparam name="T"></typeparam> 
 /// <param name="expression"></param> 
 /// <returns></returns> 
 TEntity FirstOrDefault(Expression<Func<TEntity, bool>> expression); 
 }

public class BaseRepository<TEntity> : IRepository<TEntity> where TEntity : class 
 { 
 protected readonly DbContext Context; 
 
 public BaseRepository(DbContext context) 
 { 
 Context = context; 
 } 
 
/// 获取当前实体的查询数据集 
public IQueryable<TEntity> Entities 
{ 
get { return Context.Set<TEntity>().AsQueryable(); } 
} 
 
/// 获取当前实体 
public IQueryable<TEntity> Entities 
{ 
get { return Context.Set<TEntity>(); } 
} 
 
 public TEntity FirstOrDefault(Expression<Func<TEntity, bool>> expression) 
 { 
 return All().FirstOrDefault(expression); 
 } 
 
 public IQueryable<TEntity> All() 
 { 
 return Context.Set<TEntity>().AsQueryable(); 
 } 
 
 public virtual IQueryable<TEntity> Filter(Expression<Func<TEntity, bool>> predicate) 
 { 
 return Context.Set<TEntity>().Where<TEntity>(predicate).AsQueryable<TEntity>(); 
 } 
 
 public virtual IQueryable<TEntity> Filter(Expression<Func<TEntity, bool>> filter, out int total, int index = 0, 
 int size = 50) 
 { 
 var skipCount = index * size; 
 var resetSet = filter != null 
 ? Context.Set<TEntity>().Where<TEntity>(filter).AsQueryable() 
 : Context.Set<TEntity>().AsQueryable(); 
 resetSet = skipCount == 0 ? resetSet.Take(size) : resetSet.Skip(skipCount).Take(size); 
 total = resetSet.Count(); 
 return resetSet.AsQueryable(); 
 } 
 
 public virtual int Create(TEntity TObject) 
 { 
 Entities.Add(TObject); 
 Context.SaveChanges(); 
 } 
 
 public virtual int Delete(TEntity TObject) 
 { 
 Entities.Remove(TObject);. 
 Context.SaveChanges(); 
 } 
 
 public virtual void Update(TEntity TObject) 
 { 
 try 
 { 
 var entry = Context.Entry(TObject); 
 Context.Set<TEntity>().Attach(TObject); 
 entry.State = EntityState.Modified; 
 } 
 catch (OptimisticConcurrencyException ex) 
 { 
 throw ex; 
 } 
 } 
 
 public virtual int Delete(Expression<Func<TEntity, bool>> predicate) 
 { 
 var objects = Filter(predicate); 
 foreach (var obj in objects) 
 Context.Set<TEntity>().Remove(obj); 
 return Context.SaveChanges(); 
 } 
 
 public bool Contains(Expression<Func<TEntity, bool>> predicate) 
 { 
 return Context.Set<TEntity>().Any(predicate); 
 } 
 
 public virtual TEntity Find(params object[] keys) 
 { 
 return Context.Set<TEntity>().Find(keys); 
 } 
 
 public virtual TEntity Find(Expression<Func<TEntity, bool>> predicate) 
 { 
 return Context.Set<TEntity>().FirstOrDefault<TEntity>(predicate); 
 } 
 }

public interface IStudentRepository : IRepository<Student> 
 { 
 int AddStudent(Student student); 
 }

public class StudentRepository : BaseRepository<Student>, IStudentRepository 
 { 
 private readonly SchoolContext _context; 
 
 public StudentRepository(SchoolContext context) 
 : base(context) 
 { 
 _context = context; 
 } 
 
int AddStudent(Student student) 
{ 
_context.Create(student); 
} 
 }