3

我现在使用实体框架代码优先方法开发了许多应用程序。在所有我使用数据存储库模式。此数据存储库模式一次查询单个实体。例如，

我有 2 个模型 Employee 和 Department

因此，要获取所有员工和部门，我将创建 2 个数据存储库实例。例如

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

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

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

4

4 回答 4

3

实际上，我昨天刚刚在我的通用存储库中实现了一个 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()方法中传递一个）。

于 2013-03-20T20:05:56.777 回答
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

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

于 2013-03-20T19:37:32.893 回答
1

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

  • 你一直在写这些笨拙的连接查询（linq）。您不能真正利用导航属性的强大功能。当查询变得非常简单时，这是一个主要的痛苦。
  • 因此，无论如何您都可能会使用导航属性。现在的问题是：哪个存储库负责哪个实体？查询的目标是获取孩子，但一个舒适的入口点是父母。
  • 您还必须有一些工作单元 (UoW) 来收集和“处理”不同存储库的 CUD 操作。

为什么不直接使用上下文？看到这篇文章（似乎我一直在引用它）。上下文是包含存储库（DbSets 或ObjectSets）并跟踪更改和事务 (UoW) 的类。为什么将这个存储库单元和 UoW 包装在另一层存储库和 UoW 中？那是两层。然后，您不会将存储库公开给客户端代码，因为您不想公开IQueryables。因此，您将在创建、编排和处置它们的服务层中包装存储库。那是三层。

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

但它是不可测试的，人们说，我们想模拟存储库，因此我们可以将这些模拟存储库注入到我们的服务中进行单元测试。那是一种错觉。模拟实体框架行为具有欺骗性，实际上是不可能的。我并不是说单元测试没有用。我为一旦对象存在就应该工作的各种业务逻辑编写单元测试。我只是不编写单元测试来测试数据访问代码。

于 2013-03-20T21:48:13.330 回答
1

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

社交 MSDN和

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

类是这样的： -

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

可能会有所帮助。

于 2013-03-20T19:30:30.797 回答