Question

我现在已经使用Entity Framework Code First方法开发了许多应用程序。在所有我使用Data Repository模式。此Data Repository模式一次查询单个实体。例如，

我有2个型号员工和部门

因此，为了获取所有员工和部门，我将创建2个数据存储库实例。 e.g

var empRepository = new DataRepository<Employee>();
var allEmployees = empRepository.GetAll();

var depRepository = new DataRepository<Department>();
var alldepartment = depRepository.GetAll();

现在，这种模式在大多数情况下都很有效。现在，当我想要执行连接时，我无法在此模式中执行此操作。我只有在获取了两个实体的所有记录之后才能执行连接，然后我可以在内存数据上使用连接。这会在我的逻辑中产生2个查询的额外开销。是否有任何人具有可与DataRepository模式一起使用的良好模式或解决方案。请建议任何替代此模式。

Answer 1

我实际上昨天刚刚在我的通用存储库中实现了一个Join函数。这比每个人的实现方式要容易得多，并且在这样做时你可以使用Entity Framework的一些很酷的功能。

首先，我使用的存储库类似于我在this blog post中编写的存储库。您会注意到许多方法正在返回IQueryable。这不是偶然的。 IQueryable将允许仍然使用延迟执行，这意味着查询将不会在数据库上运行，直到某些东西强制执行（即循环或.ToList()调用）。你会看到，将Join放在这种类型的存储库上，你最终不需要将所有实体加载到内存中来进行连接，因为你所暴露的只是一个IQueryable。

话虽如此，基于Join方法的可查询版本，以下是我在我的存储库中加入的方法：

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()。

Answer 2

使用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

使用这种方法，不需要将所有表条目加载到内存中。

Answer 3

请查看以下链接，以防您没有...

Social MSDN和

Forums.Asp.Net

@ 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();
    }
  }

CLASS如下： -

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();
    }
  }
}

可能有帮助。

Answer 4

这是存储库成为负担的原因之一，尤其是通用存储库（每个实体类型一个）。如果你尝试坚持这种模式，你总会遇到一些重大问题。

你一直在写这些笨拙的连接查询（linq）。你无法真正利用导航属性的力量。当查询超出简单时，这是一个很大的痛苦。
所以你可能会使用导航属性。现在问题是：哪个存储库负责哪个实体？查询的目标是获取子项，但父项是一个舒适的入口点。
您还必须有一些工作单元（UoW）来收集和“交易”单独存储库的CUD操作。

为什么不直接使用上下文？请参阅this post（我似乎一直在引用它）。上下文是一个包含存储库（DbSet或ObjectSet s）的类，并跟踪更改和事务（UoW）。为什么将这个存储库和UoW单元包装在另一层存储库和UoW中？这是两层。然后，您不会将您的存储库暴露给客户端代码，因为您不希望公开IQueryable。因此，您将把存储库包装在一个创建，编排和处理它们的服务层中。那是三层。

（并且存储库应该公开IQueryable，否则它们是不可组合的。）

但人们说，它不可测试，我们想要模拟存储库，以便我们可以将这些模拟存储库注入我们的单元测试服务中。这是一种幻觉。 Mocking entity framework behaviour is deceptive and practically impossible。我不是说单元测试没用。我为各种业务逻辑编写单元测试，一旦对象存在就应该工作。我只是不编写单元测试来测试数据访问代码。

我们应该使用Entity Framework Code First方法在MVC应用程序中使用Data Repository模式吗？

4 个答案: