Question

使用EF Core 2.2.2，我的数据库中有一个表，用于存储许多其他表的注释。换句话说，它有点像主从关系中的明细表，但是有多个主表。考虑以下简化的EF模型：

public class Person
{
  public Guid PersonID { get; set; }
  public string Name { set; set; }
}

public class InvoiceItem
{
  public Guid InvoiceItemID { get; set; }
  public Guid InvoiceID { get; set; }
  public string Description { get; set; }
}

public class Invoice
{
  public Guid InvoiceID { get; set; }
  public int InvoiceNumber { get; set; }

  public List<Item> Items { get; set; }
}

public class Notes
{
  public Guid NoteID { get; set; }
  public Guid NoteParentID { get; set; }
  public DateTime NoteDate { get; set; }
  public string Note { get; set; }
}

在这种情况下，Notes可以存储Person注释或Invoice注释（或InvoiceItem注释，尽管我们只说UI不支持该注释）。

我有这样设置的查询方法：

public IQueryable<PersonDTO> GetPersonQuery()
{
  return from p in Context.People
             select new PersonDTO
             {
               PersonID = p.PersonID,
               Name = p.Name
             };
}

public List<PersonDTO> GetPeople()
{
  return (from p in GetPersonQuery()
              return p).ToList();
}

public IQueryable<InvoiceDTO> GetInvoiceQuery()
{
  return from p in Context.Invoices
             select new InvoiceDTO
             {
               InvoiceID = p.InvoiceID,
               InvoiceNumber = p.InvoiceNumber
             };
}

public List<InvoiceDTO> GetInvoices()
{
  return (from i in GetInvoiceQuery()
              return i).ToList();
}

所有这些均按预期工作。现在，假设我将InvoiceItems添加到Invoice查询中，如下所示：

public IQueryable<InvoiceDTO> GetInvoiceQuery()
{
  return from p in Context.Invoices
             select new InvoiceDTO
             {
               InvoiceID = p.InvoiceID,
               InvoiceNumber = p.InvoiceNumber,
               Items = (from ii in p.Items
                             select new ItemDTO
                             {
                               ItemID = ii.ItemID,
                               Description = ii.Description
                             }).ToList()
             };
}

这也很好用，只需发出几个查询即可。但是，以下内容：

public IQueryable<InvoiceDTO> GetInvoiceQuery()
{
  return from p in Context.Invoices
             select new InvoiceDTO
             {
               InvoiceID = p.InvoiceID,
               InvoiceNumber = p.InvoiceNumber,
               Items = (from ii in p.Items
                             select new ItemDTO
                             {
                               ItemID = ii.ItemID,
                               Description = ii.Description
                             }).ToList(),
              Notes = (from n in Context.Notes
                             where i.InvoiceID = n.NoteParentID
                             select new NoteDTO
                             {
                               NoteID = n.NoteID,
                               Note = n.Note
                             }).ToList(),
             };
}

针对“发票”表中的每个“发票”行向“注释”表发送单独的查询。因此，如果“发票”表中有1,000张发票，这将向数据库发送类似1,001个查询的信息。

“项目”子查询似乎没有相同的问题，因为“发票”和“项目”之间存在明确的关系，而“发票”和“便笺”之间没有特定的关系（因为并非所有便笺都与发票相关）。 / p>

有没有一种方法可以重写该最终查询，以便它不会为表中的每个发票发送单独的便笺查询？

Answer 1

问题确实是相关子查询与集合导航属性之间的关系。 EF Core查询翻译器在处理此类子查询时仍然存在问题，这些子查询实际上是逻辑集合导航属性，应该以类似的方式进行处理。

有趣的是，使用中间投影（LINQ查询语法中的git branch运算符）模拟集合导航属性似乎可以解决此问题：

let

EF Core-许多查询发送到数据库以进行子查询

1 个答案: