NHibernate 使用 QueryOver 选择具有相关子对象的对象列表

Question

我在处理一些可能非常简单的事情时遇到了麻烦。 在我的数据库中，我有以下表格：

tblOrder
-----------------
Id
OrderStatusId
tblOrderStatus
-----------------
Id
Name

我在我的项目中进行了以下映射：

[Class(NameType = typeof(Order), Table = "tblOrder")
public class Order {
[Id(-2, Name = "Id")]
[Generator(-1, Class = "native")]
public virtual long Id { get; set; }
[ManyToOne]
public virtual OrderStatus Status { get; set; }
}
[Class(NameType = typeof(OrderStatus), Table = "tblOrderStatus")]
public class OrderStatus {
[Id(-2, Name = "Id")]
[Generator(-1, Class = "native")]
public virtual long Id { get; set; }
[Property]
public virtual string Name { get; set; }
}

查询应返回IList<OrderSummary>。我希望类OrderSummary有一个属性Status其中Status是一个具有Id和Name属性的对象。这可以是带有KeyValuePair或类型OrderStatus(以最佳和有效者为准)。获取订单不是问题，但将OrderStatus添加为具有所述属性的对象是我遇到问题的部分。 我还需要将查询结果作为 JSON 返回给客户端。

OrderSummary应如下所示：

public class OrderSummary {
public long Id { get; set; }
public OrderStatus Status { get; set; }
}

在我的第一个版本中，OrderSummary具有单独的OrderStatusId和OrderStatusName属性。这有效，但我试图避免这些单独的属性。 我也用SelectSubQuery尝试过这个，但这会返回一个错误，因为它在子查询中返回多个字段。

-----------------------------------更新-----------------------------

根据Fredy Treboux的建议，我使用Eager更改了查询，结果为以下查询：

var query = session.QueryOver<OrderStatus>
.Fetch(o => o.Status).Eager
.JoinAlias(o => o.Status, () => statusAlias, JoinType.LeftOuterJoin);

我发现，问题不在于选择数据，而是如何转换检索到的Status并将其分配给OrderSummary.Status？我尝试了以下方法：

OrderSummary orderAlias = null;
query.SelectList(list => list
.Select(o => o.Id).WithAlias(() => orderAlias.Id)
.Select(() => statusAlias).WithAlias(() => orderAlias.Status)
).TransformUsing(Transformer.AliasToBean<OrderSummary>());

--------------------------------答----------------------------------

正如我在上次编辑中所说，问题似乎不在于实际选择OrderStatus而是将其返回给客户。所以我认为这是我对NHibernate的缺乏了解，而是简单地将[JsonObject]属性添加到OrderStatus类中。我真傻。

我已将查询更改为以下内容：

Order orderAlias = null;
OrderSummary orderSummary = null;
OrderStatus statusAlias = null;
var query = session.QueryOver<Order>(() => orderAlias)
.JoinAlias(() => orderAlias.Status, () => statusAlias, JoinType.LeftOuterJoin);
query = query
.Select(
Projections.ProjectionList()
.Add(Projections.Property(() => orderAlias.Id).WithAlias(() => orderSummary.Id))
.Add(Projections.Property(() => orderAlias.Status).WithAlias(() => orderSummary.Status)
);
Result = query.TransformUsing(Tranformers.AliasToBean<OrderSummary>())
.List<OrderSummary>()
.ToList();

Answer 1

恐怕目前是不可能的。我猜Nhibernate转换器无法构造嵌套的复杂属性。 您可以返回元组列表，然后将其手动强制转换为实体：

OrderStatus statusAlias = null;        
var tuples = Session.QueryOver<Order>()
.JoinQueryOver(x => x.Status, () => statusAlias)
.SelectList(list => list
.Select(x => x.Id)
.Select(x => statusAlias.Id)
.Select(x => statusAlias.Name))
.List<object[]>();
var result = tuples.Select(Convert);
private OrderSummary Convert(object[] item) {
return new OrderSummary
{
Id = (long)item[0],
OrderStatus = new OrderStatus { Id = (long)item[1], Name = (string)item[2] }
};
}

此外，如果您不太关心性能，则可以获取订单列表并将其转换为订单摘要。您可以通过简单地定义转换运算符或使用一些工具(如AutoMapper或ExpressMapper)来做到这一点。

Answer 2

抱歉，我之前没有看到您的评论要求举例。 我将留下一些代码来解释我提到的方法，尽管它已经在另一个响应中作为替代方案给出，我相信这是最简单的方法(根本不使用转换器)：

string GetOrderSummaries()
{
// First, you just query the orders and eager fetch the status.
// The eager fetch is just to avoid a Select N+1 when traversing the returned list.
// With that, we make sure we will execute only one query (it will be a join).
var query = session.QueryOver<Order>()
.Fetch(o => o.Status).Eager;
// This executes your query and creates a list of orders.
var orders = query.List();
// We map these orders to DTOs, here I'm doing it manually.
// Ideally, have one DTO for Order (OrderSummary) and one for OrderStatus (OrderSummaryStatus).
// As mentioned by the other commenter, you can use (for example) AutoMapper to take care of this for you:
var orderSummaries = orders.Select(order => new OrderSummary
{
Id = order.Id,
Status = new OrderSummaryStatus
{
Id = order.Status.Id,
Name = order.Status.Name
}
}).ToList();
// Yes, it is true that this implied that we not only materialized the entities, but then went over the list a second time.
// In most cases I bet this performance implication is negligible (I imagine serializing to Json will possibly be slower than that).
// And code is more terse and possibly more resilient.
// We serialize the DTOs to Json with, for example, Json.NET
var orderSummariesJson = JsonConvert.SerializeObject(orderSummaries);
return orderSummariesJson;
}

有用的链接：
自动映射器： http://automapper.org/
Json.NET： http://www.newtonsoft.com/json