我现在使用实体框架代码优先方法开发了许多应用程序。在所有我使用数据存储库模式。此数据存储库模式一次查询单个实体。例如，
我有 2 个模型 Employee 和 Department
因此，要获取所有员工和部门，我将创建 2 个数据存储库实例。例如
var empRepository = new DataRepository<Employee>();
var allEmployees = empRepository.GetAll();
var depRepository = new DataRepository<Department>();
var alldepartment = depRepository.GetAll();
现在，这种模式在大多数情况下都很好用。现在，当我想执行加入时，我不能在这种模式下这样做。只有在获取了两个实体的所有记录之后，我才能执行连接，然后我可以在内存数据上使用连接。这在我的逻辑中产生了 2 个查询的额外开销。有没有人有可以与 DataRepository 模式一起使用的好的模式或解决方案。请建议此模式的任何替代方案。
实际上，我昨天刚刚在我的通用存储库中实现了一个 Join 函数。这比每个人都想的要容易得多，而且您可以在这样做的同时使用 Entity Framework 的一些很酷的功能。
首先，我使用的存储库类似于我在这篇博文中所写的内容。您会注意到许多方法正在返回IQueryable。这绝非偶然。IQueryable将允许仍然使用延迟执行，这意味着查询不会在数据库上运行，直到某些东西强制它（即循环或.ToList()调用）。您会看到，通过Join将IQueryable.
话虽如此，这就是我如何在我的存储库中获得 Join ，基于Join方法的 Queryable 版本：
public IQueryable<TResult> Join<TInner, TKey, TResult>(IRepository<TInner> innerRepository, Expression<Func<T, TKey>> outerSelector, Expression<Func<TInner, TKey>> innerSelector, Expression<Func<T, TInner, TResult>> resultSelector) where TInner : class
{
return DbSet.Join(innerRepository.All(), outerSelector, innerSelector, resultSelector);
}
然后，这只对数据库进行一次查询以获取您请求的所有信息（同样，因为它只IQueryable在All()方法中传递一个）。
使用Repository模式，您可以像在正常情况下一样加入两个表。假设您已经像这样定义了您的存储库：
public interface IRepository<T>
{
T GetById(object id);
void Insert(T entity);
void Update(T entity);
void Delete(T entity);
IQueryable<T> Table { get; }
}
然后你可以加入两个表如下：
from p in _someRepository.Table
join p2 in _someOtherRepository.Table on p.FOO equals p2.BAR
使用这种方法，无需将所有表条目加载到内存中。
这是存储库成为负担的原因之一，尤其是通用存储库（每个实体类型一个）。如果你试图保持对模式的忠诚，你总是会遇到一些重大问题。
为什么不直接使用上下文？看到这篇文章（似乎我一直在引用它）。上下文是包含存储库（DbSets 或ObjectSets）并跟踪更改和事务 (UoW) 的类。为什么将这个存储库单元和 UoW 包装在另一层存储库和 UoW 中？那是两层。然后，您不会将存储库公开给客户端代码，因为您不想公开IQueryables。因此，您将在创建、编排和处置它们的服务层中包装存储库。那是三层。
（并且存储库应该公开，IQueryable否则它们是不可组合的）。
但它是不可测试的，人们说，我们想模拟存储库，因此我们可以将这些模拟存储库注入到我们的服务中进行单元测试。那是一种错觉。模拟实体框架行为具有欺骗性，实际上是不可能的。我并不是说单元测试没有用。我为一旦对象存在就应该工作的各种业务逻辑编写单元测试。我只是不编写单元测试来测试数据访问代码。
请查看以下链接，以防您还没有...
@Link.fr 的回答如下：-
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;
namespace Repository
{
class Program
{
static void Main(string[] args)
{
// get all the informations about orders
CustomersRepository oCustomersRepository = new CustomersRepository();
ProductsRepository oProductsRepository = new ProductsRepository();
OrdersRepository oOrdersRepository = new OrdersRepository();
var query1 = oOrdersRepository.SelectAll().
Join(oCustomersRepository.SelectAll(),
order => order.CustomerId,
customer => customer.Id,
(order, customer) => new
{
MyOrder = order,
MyCustomer = customer
}).
Join(oProductsRepository.SelectAll(),
item => item.MyOrder.ProductId,
product => product.Id,
(item, product) => new
{
MyOrder = item.MyOrder,
MyCustomer = item.MyCustomer,
MyProduct = product }).
ToList();
foreach (var row in query1)
{
Console.WriteLine("query1 : {0} - {1}", row.MyCustomer.Name, row.MyProduct.Name);
}
Console.WriteLine("--");
或者
var query2 = (from order in oOrdersRepository.SelectAll()
join customer in oCustomersRepository.SelectAll() on order.CustomerId equals customer.Id
join product in oProductsRepository.SelectAll() on order.ProductId equals product.Id
select
new
{
CustomerName = customer.Name,
ProductName = product.Name
}).ToList();
foreach (var row in query2)
{
Console.WriteLine("query2 : {0} - {1}", row.CustomerName, row.ProductName);
}
Console.ReadKey();
}
}
类是这样的： -
public class Customer
{
public int Id { get; set; }
public string Name { get; set; }
}
public class Product
{
public int Id { get; set; }
public string Name { get; set; }
}
public class Order
{
public int CustomerId { get; set; }
public int ProductId { get; set; }
}
public interface IRepository<T>
{
IList<T> SelectAll();
IList<T> SelectAll(Func<T, bool> expression);
}
public class CustomersRepository : IRepository<Customer>
{
public IList<Customer> SelectAll()
{
return new List<Customer>
{
new Customer{ Id = 1, Name = "Customer1"},
new Customer{ Id = 2, Name = "Customer2"},
new Customer{ Id = 3, Name = "Customer3"},
new Customer{ Id = 4, Name = "Customer4"}
};
}
public IList<Customer> SelectAll(Func<Customer, bool> expression)
{
return new List<Customer>
{
new Customer{ Id = 1, Name = "Customer1"},
new Customer{ Id = 2, Name = "Customer2"},
new Customer{ Id = 3, Name = "Customer3"},
new Customer{ Id = 4, Name = "Customer4"}
}.Where(expression).ToList();
}
}
public class ProductsRepository : IRepository<Product>
{
public IList<Product> SelectAll()
{
return new List<Product>
{
new Product{ Id = 1, Name = "Product1"},
new Product{ Id = 2, Name = "Product2"},
new Product{ Id = 3, Name = "Product3"},
new Product{ Id = 4, Name = "Product4"}
};
}
public IList<Product> SelectAll(Func<Product, bool> expression)
{
return new List<Product>
{
new Product{ Id = 1, Name = "Product1"},
new Product{ Id = 2, Name = "Product2"},
new Product{ Id = 3, Name = "Product3"},
new Product{ Id = 4, Name = "Product4"}
}.Where(expression).ToList();
}
}
public class OrdersRepository : IRepository<Order>
{
public IList<Order> SelectAll()
{
return new List<Order>
{
new Order{ CustomerId = 1, ProductId = 1},
new Order{ CustomerId = 1, ProductId = 2},
new Order{ CustomerId = 2, ProductId = 3},
new Order{ CustomerId = 3, ProductId = 4},
};
}
public IList<Order> SelectAll(Func<Order, bool> expression)
{
return new List<Order>
{
new Order{ CustomerId = 1, ProductId = 1},
new Order{ CustomerId = 1, ProductId = 2},
new Order{ CustomerId = 2, ProductId = 3},
new Order{ CustomerId = 3, ProductId = 4},
}.Where(expression).ToList();
}
}
}
可能会有所帮助。