Entity framework 带有连接的通用存储库模式 我已经开始阅读实体框架（6。x）的知识库模式，通过阅读我认为本文中最基本的处理方法：

不幸的是，它没有处理连接。使用通用存储库，如何连接到任意数量的其他实体/存储库

到目前为止，我在通用接口中有以下内容：

    interface IGenericRepository<T> where T: class
{
    IEnumerable<T> SelectAll();
    T SelectByID(object id);
    void Insert(T obj);
    void Update(T obj);
    void Delete(object id);
    void Save();

}

    public class GenericRepository<T> : IGenericRepository<T> where T : class
{
    private SocialMediaEntities db = null;
    private DbSet<T> table = null;

    public GenericRepository()
    {
        this.db = new SocialMediaEntities();
        table = db.Set<T>();
    }

    public GenericRepository(SocialMediaEntities db)
    {
        this.db = db;
        table = db.Set<T>();
    }

    public IEnumerable<T> SelectAll()
    {
        return table.ToList();
    }

    public T SelectByID(object id)
    {
        return table.Find(id);
    }

    public void Insert(T obj)
    {
        table.Add(obj);
    }

    public void Update(T obj)
    {
        table.Attach(obj);
        db.Entry(obj).State = EntityState.Modified;
    }

    public void Delete(object id)
    {
        T existing = table.Find(id);
        table.Remove(existing);
    }

    public void Save()
    {
        db.SaveChanges();
    }

}

---

在研究了给出的第一个答案之后，它似乎更符合通用存储库模式的精神。

您可以为GetAll方法创建几个重载。像这样：

//get all, including orderby clause, and includes
//usage: var s = repository.GetAll(i => i.Name, false, i => i.NavigationProperty);
public IEnumerable<T> GetAll<TOrderKey>(Expression<Func<T, TOrderKey>> orderbyExp, 
                                        Boolean descending, 
                                        params Expression<Func<T, Object>>[] includeExps)
{
    var query = table.AsQueryable();
    query = !descending ? query.OrderBy(orderByExp) : query.OrderByDescending(orderByExp);
    if (includeExps != null)
       query = includeExps.Aggregate(query, (current, exp) => current.Include(exp));        

   return query.ToList();
}


//get all, including select clause, orderby clause, and includes
//usage: var s = repository.GetAll(i => new { Name = i.Name }, i => i.Name, false, i => i.NavigationProperty
public IEnumerable<TReturn> GetAll<TReturn, TOrderKey>(Expression<Func<T, TReturn>> selectExp,
                                                       Expression<Func<T, TOrderKey>> orderExp, 
                                                       Boolean descending, 
                                                       params Expression<Func<T, Object>>[] includeExps)
{
     var query = table.AsQueryable();
     query = !descending ? query.OrderBy(orderByExp) : query.OrderByDescending(orderByExp);
     if (includeExps != null)
       query = includeExps.Aggregate(query, (current, exp) => current.Include(exp));  

      return query.Select(selectExp).ToList();
}


//get all, including select clause, where clause, order by clause, and includes
//usage: var s = repository.GetAll(i => new { i.Name }, i => i.Name.Contains('John'), i => i.Name, false, i => i.NavigationProperty
public IEnumerable<TReturn> GetAll<TReturn, TOrderKey>(Expression<Func<T, TReturn>> selectExp,
                                                       Expression<Func<T, Boolean>> whereExp, 
                                                       Expression<Func<T, TOrderKey>> orderbyExp,
                                                       Boolean descending,
                                                       params Expression<Func<T, object>>[] includeExps)
{
    var query = table.Where(whereExp);
    query = !descending ? query.OrderBy(orderbyExp) : query.OrderByDescending(orderbyExp);
    if (includeExps != null)
      query = includeExps.Aggregate(query, (current, exp) => current.Include(exp));

    return query.Select(selectExp).ToList();
}

//获取全部，包括orderby子句和includes
//用法：var s=repository.GetAll（i=>i.Name，false，i=>i.NavigationProperty）；
公共IEnumerable GetAll（表达式orderbyExp，
布尔递减，
参数表达式[]includeExps）
{
var query=table.AsQueryable（）；
query=！descending？query.OrderBy（orderByExp）：query.OrderByDescending（orderByExp）；
如果（includeExps！=null）
query=includeExps.Aggregate（query，（current，exp）=>current.Include（exp））；
返回query.ToList（）；
}
//获取全部，包括select子句、orderby子句和includes
//用法：var s=repository.GetAll（i=>new{Name=i.Name}，i=>i.Name，false，i=>i.NavigationProperty
公共IEnumerable GetAll（表达式selectExp，
表达式orderExp，
布尔递减，
参数表达式[]includeExps）
{
var query=table.AsQueryable（）；
query=！descending？query.OrderBy（orderByExp）：query.OrderByDescending（orderByExp）；
如果（includeExps！=null）
query=includeExps.Aggregate（query，（current，exp）=>current.Include（exp））；
返回query.Select（selectExp.ToList（）；
}
//获取全部，包括select子句、where子句、order by子句和INCLUDE
//用法：var s=repository.GetAll（i=>new{i.Name}，i=>i.Name.Contains（'John'），i=>i.Name，false，i=>i.NavigationProperty
公共IEnumerable GetAll（表达式selectExp，
表达方式如下：，
表达式orderbyExp，
布尔递减，
参数表达式[]includeExps）
{
var查询=表。其中（whereExp）；
query=！descending？query.OrderBy（orderbyExp）：query.OrderByDescending（orderbyExp）；
如果（includeExps！=null）
query=includeExps.Aggregate（query，（current，exp）=>current.Include（exp））；
返回query.Select（selectExp.ToList（）；
}

---

上述方法只是一个示例。您应该根据需要重新创建它们。

您可以为GetAll方法创建多个重载。如下所示：

//get all, including orderby clause, and includes
//usage: var s = repository.GetAll(i => i.Name, false, i => i.NavigationProperty);
public IEnumerable<T> GetAll<TOrderKey>(Expression<Func<T, TOrderKey>> orderbyExp, 
                                        Boolean descending, 
                                        params Expression<Func<T, Object>>[] includeExps)
{
    var query = table.AsQueryable();
    query = !descending ? query.OrderBy(orderByExp) : query.OrderByDescending(orderByExp);
    if (includeExps != null)
       query = includeExps.Aggregate(query, (current, exp) => current.Include(exp));        

   return query.ToList();
}


//get all, including select clause, orderby clause, and includes
//usage: var s = repository.GetAll(i => new { Name = i.Name }, i => i.Name, false, i => i.NavigationProperty
public IEnumerable<TReturn> GetAll<TReturn, TOrderKey>(Expression<Func<T, TReturn>> selectExp,
                                                       Expression<Func<T, TOrderKey>> orderExp, 
                                                       Boolean descending, 
                                                       params Expression<Func<T, Object>>[] includeExps)
{
     var query = table.AsQueryable();
     query = !descending ? query.OrderBy(orderByExp) : query.OrderByDescending(orderByExp);
     if (includeExps != null)
       query = includeExps.Aggregate(query, (current, exp) => current.Include(exp));  

      return query.Select(selectExp).ToList();
}


//get all, including select clause, where clause, order by clause, and includes
//usage: var s = repository.GetAll(i => new { i.Name }, i => i.Name.Contains('John'), i => i.Name, false, i => i.NavigationProperty
public IEnumerable<TReturn> GetAll<TReturn, TOrderKey>(Expression<Func<T, TReturn>> selectExp,
                                                       Expression<Func<T, Boolean>> whereExp, 
                                                       Expression<Func<T, TOrderKey>> orderbyExp,
                                                       Boolean descending,
                                                       params Expression<Func<T, object>>[] includeExps)
{
    var query = table.Where(whereExp);
    query = !descending ? query.OrderBy(orderbyExp) : query.OrderByDescending(orderbyExp);
    if (includeExps != null)
      query = includeExps.Aggregate(query, (current, exp) => current.Include(exp));

    return query.Select(selectExp).ToList();
}

//获取全部，包括orderby子句和includes
//用法：var s=repository.GetAll（i=>i.Name，false，i=>i.NavigationProperty）；
公共IEnumerable GetAll（表达式orderbyExp，
布尔递减，
参数表达式[]includeExps）
{
var query=table.AsQueryable（）；
query=！descending？query.OrderBy（orderByExp）：query.OrderByDescending（orderByExp）；
如果（includeExps！=null）
query=includeExps.Aggregate（query，（current，exp）=>current.Include（exp））；
返回query.ToList（）；
}
//获取全部，包括select子句、orderby子句和includes
//用法：var s=repository.GetAll（i=>new{Name=i.Name}，i=>i.Name，false，i=>i.NavigationProperty
公共IEnumerable GetAll（表达式selectExp，
表达式orderExp，
布尔递减，
参数表达式[]includeExps）
{
var query=table.AsQueryable（）；
query=！descending？query.OrderBy（orderByExp）：query.OrderByDescending（orderByExp）；
如果（includeExps！=null）
query=includeExps.Aggregate（query，（current，exp）=>current.Include（exp））；
返回query.Select（selectExp.ToList（）；
}
//获取全部，包括select子句、where子句、order by子句和INCLUDE
//用法：var s=repository.GetAll（i=>new{i.Name}，i=>i.Name.Contains（'John'），i=>i.Name，false，i=>i.NavigationProperty
公共IEnumerable GetAll（表达式selectExp，
表达方式如下：，
表达式orderbyExp，
布尔递减，
参数表达式[]includeExps）
{
var查询=表。其中（whereExp）；
query=！descending？query.OrderBy（orderbyExp）：query.OrderByDescending（orderbyExp）；
如果（includeExps！=null）
query=includeExps.Aggregate（query，（current，exp）=>current.Include（exp））；
返回query.Select（selectExp.ToList（）；
}

以上方法只是一个例子，您应该根据需要重新创建它们