我可以在 EntityFramework 中的 ObjectSet 上使用多少个 Include 以保持性能？

Question

我正在为我的个人资料页面使用以下 LINQ 查询：

var userData = from u in db.Users
                        .Include("UserSkills.Skill")
                        .Include("UserIdeas.IdeaThings")
                        .Include("UserInterests.Interest")
                        .Include("UserMessengers.Messenger")
                        .Include("UserFriends.User.UserSkills.Skill")
                        .Include("UserFriends1.User1.UserSkills.Skill")
                        .Include("UserFriends.User.UserIdeas")
                        .Include("UserFriends1.User1.UserIdeas")
                               where u.UserId == userId
                               select u;

它有一个很长的对象图并使用许多 Include。目前运行完美，但是当网站用户较多时，性能会不会受到很大影响？

我应该用其他方式来做吗？

Answer 1

包含包含的查询返回单个结果集，包含的数量会影响大数据集从数据库服务器传输到 Web 服务器的方式。示例：

假设我们有一个实体 Customer (Id, Name, Address) 和一个实体 Order (Id, CustomerId, Date)。现在我们要查询客户的订单：

var customer = context.Customers
                      .Include("Orders")
                      .SingleOrDefault(c => c.Id == 1);

生成的数据集将具有以下结构：

 Id | Name | Address | OrderId | CustomerId | Date 
---------------------------------------------------
  1 |  A   |   XYZ   |    1    |     1      | 1.1.
  1 |  A   |   XYZ   |    2    |     1      | 2.1.

这意味着每个 Order 都会重复 Cutomers 数据。现在让我们使用另一个实体扩展该示例 -“OrderLine (Id, OrderId, ProductId, Quantity)andProduct (Id, Name)”。现在我们要查询客户的订单、订单行和产品：

var customer = context.Customers
                      .Include("Orders.OrderLines.Product")
                      .SingleOrDefault(c => c.Id == 1);

生成的数据集将具有以下结构：

 Id | Name | Address | OrderId | CustomerId | Date | OrderLineId | LOrderId | LProductId | Quantity | ProductId | ProductName
------------------------------------------------------------------------------------------------------------------------------
  1 |  A   |   XYZ   |    1    |     1      | 1.1. |     1       |    1     |     1      |    5     |    1      |     AA
  1 |  A   |   XYZ   |    1    |     1      | 1.1. |     2       |    1     |     2      |    2     |    2      |     BB
  1 |  A   |   XYZ   |    2    |     1      | 2.1. |     3       |    2     |     1      |    4     |    1      |     AA
  1 |  A   |   XYZ   |    2    |     1      | 2.1. |     4       |    2     |     3      |    6     |    3      |     CC

如您所见，数据变得相当多重复。通常，每个引用导航属性（示例中的 Product）的包含都会添加新列，并且每个包含到集合导航属性（Orders 和 OrderLines > 在示例中）将为所包含集合中的每一行添加新列并复制已创建的行。

这意味着您的示例可以轻松拥有数百列和数千行，这是需要传输的大量数据。正确的方法是创建性能测试，如果结果不能满足您的期望，您可以通过自己的查询或通过 LoadProperty 方法单独修改查询和加载导航属性。

单独查询的示例：

var customer = context.Customers
                      .Include("Orders")
                      .SingleOrDefault(c => c.Id == 1);
var orderLines = context.OrderLines
                        .Include("Product")
                        .Where(l => l.Order.Customer.Id == 1)
                        .ToList();

LoadProperty 示例：

var customer = context.Customers
                      .SingleOrDefault(c => c.Id == 1);
context.LoadProperty(customer, c => c.Orders);

此外，您应该始终仅加载真正需要的数据。

编辑：我刚刚创建了关于 Data UserVoice 的提案，支持额外的急切加载策略，其中急切加载的数据将在附加结果集中传递（由同一数据库往返中的单独查询创建）。如果您发现此改进很有趣，请不要忘记投票支持该提案。

Answer 2

（您可以通过从数据库创建 2 个或更多小数据请求来提高许多包含的性能，如下所示。

根据我的经验，只能为每个查询提供最多 2 个包含，例如超过这个数量将会带来非常糟糕的性能。

var userData = from u in db.Users
                        .Include("UserSkills.Skill")
                        .Include("UserIdeas.IdeaThings")
                        .FirstOrDefault();

 userData = from u in db.Users
                    .Include("UserFriends.User.UserSkills.Skill")
                    .Include("UserFriends1.User1.UserSkills.Skill")
                    .FirstOrDefault();

上面将通过使用更多的数据库访问来从数据库中带来小数据集。

Answer 3

是的，会的。如果使用 Include 扩展主表行上的多个详细信息行，请避免使用 Include。

我相信 EF 会将查询转换为一个大型联接而不是多个查询。因此，您最终将在详细信息表的每一行上复制主表数据。

例如：大师->细节。假设 master 有 100 行，Details 有 5000 行（每个 master 50 行）。

如果延迟加载详细信息，则会返回 100 行（大小：master）+ 5000 行（大小：详细信息）。

如果您使用 .Include("Details")，您将返回 5000 行（大小：主数据 + 详细信息）。本质上，主部分被复制了 50 多次。

如果包含多个表，它会向上增加。

检查EF生成的SQL。

Answer 4

我建议您执行负载测试并测量网站在压力下的性能。如果您对每个请求执行复杂的查询，您可以考虑缓存一些结果。

Answer 5

include 的结果可能会改变：它取决于调用 include 方法的实体。

就像 Ladislav Mrnka 提出的示例一样，假设我们有一个

实体Customer（Id、Name、Address）

映射到的 此表：

Id  |  Name   | Address
-----------------------
C1  |  Paul   |   XYZ   

实体订单（Id、CustomerId、Total）

以及映射到此表的

Id |  CustomerId  | Total
-----------------------
O1 |      C1      |  10.00
O2 |      C1      |  13.00

：关系是一个客户与许多订单

---

示例 1：Customer = >订单

var customer = context.Customers
                      .Include("Orders")
                      .SingleOrDefault(c => c.Id == "C1");

Linq 将转换为非常复杂的 SQL 查询。

在这种情况下，查询将生成两条记录，并且将复制有关客户的信息。

 Customer.Id   |   Customer.Name |    Order.Id |  Order.Total
-----------------------------------------------------------
     C1        |       Paul      |       O1    |    10.00     
     C1        |       Paul      |       O2    |    13.00   

---

示例 2：订单 => Customer

var order = context.Orders
                      .Include("Customers")
                      .SingleOrDefault(c => c.Id == "O1");

Linq 将被转换为简单的 sql Join。

在这种情况下，查询将仅生成一条记录，没有重复的信息：

 Order.Id |  Order.Total |  Customer.Id   |   Customer.Name
-----------------------------------------------------------
     O1   |    10.00     |      C1        |       Paul