7

考虑这些人为的实体对象：

public class Consumer
{
    public int Id { get; set; }
    public string Name { get; set; }
    public bool NeedsProcessed { get; set; }
    public virtual IList<Purchase> Purchases { get; set; }  //virtual so EF can lazy-load
}

public class Purchase
{
    public int Id { get; set; }
    public decimal TotalCost { get; set; }
    public int ConsumerId { get; set; }
}

现在假设我想运行这段代码：

var consumers = Consumers.Where(consumer => consumer.NeedsProcessed);

//assume that ProcessConsumers accesses the Consumer.Purchases property
SomeExternalServiceICannotModify.ProcessConsumers(consumers);

默认情况下，这将受到 ProcessConsumers 方法中的 Select N+1 的影响。它会在枚举消费者时触发一个查询，然后它将一个一个地抓取每个购买集合。这个问题的标准解决方案是添加一个包含：

var consumers = Consumers.Include("Purchases").Where(consumer => consumer.NeedsProcessed);

//assume that ProcessConsumers accesses the Consumer.Purchases property
SomeExternalServiceICannotModify.ProcessConsumers(consumers);

这在许多情况下都可以正常工作，但在一些复杂的情况下，包含可以完全破坏性能几个数量级。是否有可能做这样的事情：

  1. 抓住我的消费者，var consumer = _entityContext.Consumers.Where(...).ToList()
  2. 抓住我的购买，var purchase = _entityContext.Purchases.Where(...).ToList()
  3. 水合消费者。从我已经加载到内存中的购买中手动购买集合。然后，当我将它传递给 ProcessConsumers 时，它不会触发更多的数据库查询。

我不确定如何做#3。如果您尝试访问任何会触发延迟加载（以及因此 Select N+1）的 consumer.Purchases 集合。也许我需要将消费者转换为正确的类型（而不是 EF 代理类型），然后加载集合？像这样的东西：

foreach (var consumer in Consumers)
{
     //since the EF proxy overrides the Purchases property, this doesn't really work, I'm trying to figure out what would
     ((Consumer)consumer).Purchases = purchases.Where(x => x.ConsumerId = consumer.ConsumerId).ToList();
}

编辑： 我已经重写了这个例子，希望能更清楚地揭示这个问题。

4

4 回答 4

1

如果我理解正确，您希望在 1 个查询中同时加载过滤后的消费者子集和过滤后的购买子集。如果这不正确，请原谅我对您的意图的理解。如果这是正确的，您可以执行以下操作：

var consumersAndPurchases = db.Consumers.Where(...)
    .Select(c => new {
        Consumer = c,
        RelevantPurchases = c.Purchases.Where(...)
    })
    .AsNoTracking()
    .ToList(); // loads in 1 query

// this should be OK because we did AsNoTracking()
consumersAndPurchases.ForEach(t => t.Consumer.Purchases = t.RelevantPurchases);

CannotModify.Process(consumersAndPurchases.Select(t => t.Consumer));

请注意，如果 Process 函数希望修改消费者对象，然后将这些更改提交回数据库，则此方法将不起作用。

于 2012-08-11T13:50:26.907 回答
0

您是否不可能通过在数据库上进行工作来解决多次往返或低效查询生成问题 - 主要是通过返回投影而不是特定实体，如下所示：

var query = from c in db.Consumers
            where c.Id > 1000
            select new { Consumer = c, Total = c.Purchases.Sum( p => p.TotalCost ) };
var total = query.Sum( cp => cp.Total );

无论如何，我都不是 EF 专家，所以如果这种技术不合适，请原谅我。

于 2012-06-09T19:00:27.020 回答
0

抓住我的消费者

var consumers = _entityContext.Consumers
                              .Where(consumer => consumer.Id > 1000)
                              .ToList();

抓住我的购买

var purchases = consumers.Select(x => new {
                                       Id = x.Id,
                                       IList<Purchases> Purchases = x.Purchases         
                                       })
                         .ToList()
                         .GroupBy(x => x.Id)
                         .Select( x => x.Aggregate((merged, next) => merged.Merge(next)))
                         .ToList();

水合消费者。从我已经加载到内存中的购买中手动购买集合。

for(int i = 0; i < costumers.Lenght; i++)
   costumers[i].Purchases = purchases[i];
于 2012-06-09T17:43:10.380 回答
0

如果您使用相同的上下文来获取两个集合， EF 将为consumer.Purchases您填充集合：

List<Consumer> consumers = null;
using ( var ctx = new XXXEntities() )
{
  consumers = ctx.Consumers.Where( ... ).ToList();

  // EF will populate consumers.Purchases when it loads these objects
  ctx.Purchases.Where( ... ).ToList();
}

// the Purchase objects are now in the consumer.Purchases collections
var sum = consumers.Sum( c => c.Purchases.Sum( p => p.TotalCost ) );

编辑 ：

这仅导致 2 次 db 调用：1 次获取集合，Consumers1次获取Purchases.

EF 将查看Purchase返回的每条记录并从中查找相应的Consumer记录Purchase.ConsumerId。然后它将为您将Purchase对象添加到Consumer.Purchases集合中。

选项 2：

如果出于某种原因您想从不同的上下文中获取两个列表然后链接它们，我会在Consumer类中添加另一个属性：

partial class Consumer
{
  public List<Purchase> UI_Purchases { get; set; }
}

然后，您可以从集合中设置此属性Purchases并在您的 UI 中使用它。

于 2012-06-09T16:42:57.357 回答