nHibernate Future，加载顺序混乱

Question

我可能使用 Future 方法完全错误，但我在理解如何优化其使用方面遇到了很多困难。这是我的简单例子。

三个对象，Member、Player、Character

Member {
   Player Player { get; set; }

Player {
   IList<Character> Characters { get; set; }
}

所以基本上，一个成员也是一个玩家，一个玩家有多个角色。够简单的。 （这种抽象的原因是保持 Member 轻量级，以便它只能用于身份验证和角色，其中更重的数据必须附加到 Player 类。 ）

那么，我有一个方法，我想查询 Player 拥有的所有 Character 。所以我设置了以下查询...

        session.QueryOver<Player>()
            .Fetch(context => context.Characters).Eager
            .Take(1)
            .Future<Player>();

        session.QueryOver<Character>()
            .Future<Character>()
            .Take(10);

        return session.QueryOver<Member>()
            .Where(model)
            .Fetch(context => context.Player).Eager
            .List()
            .Take(1)
            .SingleOrDefault()
            .Player;

我的想法是，根据我对 Future 工作方式的理解（这可能很遥远，因为它会急切加载 Player (1:1)，它将在同一数据库行程中执行对 IList 的查询，限制为 10 个结果，每个 Player 只需要 1 个。行程，每次行程最多 10 个字符，

但是 nhProf 告诉我我正在使用无限制的请求，有人可以向我解释一下这是怎么回事吗？这些方法是如何工作的？或者有人可以提供一个更可行的示例吗？我不明白 HQL，所以我无法使用 CreateCriteria 方法。

Answer 1

您问题中的三个查询将执行以下操作：

查询 1 将获取它可以在数据库中找到的第一个玩家，没有任何 where 条件。

查询 2 将获取它可以找到的前十个字符，同样不带任何 where 条件。

查询 3 将执行这三个查询，并获取第一个与您的 where 条件匹配的成员以及关联的玩家，并返回该成员的玩家。

如果你想迭代玩家的角色，NHibernate 会再次访问数据库，因为还没有加载任何角色。

您的示例可以在没有 Futures 的情况下在单个查询中完成，如下所示：

System.Linq.Expressions.Expression<Func<Member, bool>> model = m => m.Id == 1;
Member mAlias = null;
Player pAlias = null;
Character cAlias = null;

Member member = session.QueryOver<Member>(() => mAlias)
    .JoinAlias(m => m.Player, () => pAlias)
    .Left.JoinAlias(() => pAlias.Characters, () => cAlias)
    .Where(model)
    .List().FirstOrDefault();

这是一个示例，可以更好地展示 Futures 的功能。查询的目标是获取 id = 1 的客户及其所有订单以及订单的详细信息和预订。

现在，如果我们想将订单及其详细信息和预订一起加载，生成的查询将为我们提供笛卡尔积： count(Details) * count(Bookings)

int id = 1;
// define Aliases to use in query and be able to reference joined entities
Customer cAlias = null;
Order oAlias = null;
OrderDetails odAlias = null;
Booking bAlias = null;

// get the Customer and his Orders
var customers = session.QueryOver<Customer>(() => cAlias)
    .Left.JoinAlias(o => o.Orders, () => oAlias)
    .Where(c => c.Id == id)
    .Future<Customer>();

// get the Orders and their Details
var orders = session.QueryOver<Order>(() => oAlias)
    .JoinAlias(o => o.Customer, () => cAlias)
    .Left.JoinAlias(() => oAlias.Details, () => odAlias)
    .Where(() => cAlias.Id == id)
    .Future<Order>();

// get the Orders and their Bookings
var orders2 = session.QueryOver<Order>(() => oAlias)
    .JoinAlias(o => o.Customer, () => cAlias)
    .Left.JoinAlias(() => oAlias.Bookings, () => bAlias)
    .Where(() => cAlias.Id == id)
    .Future<Order>();

var list = customers.ToList();
Customer customer = list.FirstOrDefault();

Order o1 = customer.Orders.FirstOrDefault();
// iterate through the Details 
// normally this would cause N+1 selects, here it doesn't, because we already loaded
foreach (OrderDetails od1 in o1.Details)
{
    decimal d = od1.Quantity;
}

我的所有映射都使用延迟加载，并且我没有在这些查询中指定急切加载。尽管如此，当我运行代码时，我在一次往返中得到了三个 SQL 查询，而没有笛卡尔积。这就是期货的美妙之处。