Nhibernate 防止内部联接后出现多个实例

在连接到另一个表之后，同一对象的多个实例有一个小问题。为了进行测试，我创建了一个

存储

，其中包含两个

产品

（多个关系）。下面的代码片段有希望描述我的问题

var preResult = _session.QueryOver<Store>().List(); // One store

Product productAlias = null;
var result = _session.QueryOver<Store>()
    .JoinAlias(s => s.Products, () => productAlias)
    .List();                                        // Two instances of the same store

var preResult=\u session.QueryOver（）.List（）；//一家店
productAlias=null；
var result=\u session.QueryOver（）
.JoinAlias（s=>s.Products，（）=>productAlias）
.List（）；//同一商店的两个实例

我甚至认为这种行为是正确的，但我如何防止多个实例？在查询中是否可能

---

仅供参考，为什么我需要进行这种不必要的连接：我想根据不同的临界点扩展查询，类似于：

Product productAlias = null;
var query = _session.QueryOver<Store>().JoinAlias(s => s.Products, () => productAlias);
if (!string.IsNullOrWhiteSpace(criteria.ProductName))
{
    query.Where(Restrictions.On(() => productAlias.Name).IsInsensitiveLike(criteria.ProductName));
}

if (criteria.ProductType != null)
{
    query.Where(s => productAlias.Type == criteria.ProductType);
}

var result = query.List();

产品productAlias=null；
var query=\u session.QueryOver（）.JoinAlias（s=>s.Products，（）=>productAlias）；
如果（！string.IsNullOrWhiteSpace（criteria.ProductName））
{
query.Where（Restrictions.On（（）=>productAlias.Name）.IsInsensitiveLike（criteria.ProductName））；
}
if（criteria.ProductType！=null）
{
其中（s=>productAlias.Type==criteria.ProductType）；
}
var result=query.List（）；

---

在这里，我遇到了不同的问题，这取决于标准。

尝试在您的场景中使用

Transformers.DistincTrotenty

来消除笛卡尔积

Product productAlias = null;
var query = _session.QueryOver<Store>()
                    .JoinAlias(s => s.Products, () => productAlias)

query = query.TransformUsing(Transformers.DistinctRootEntity);

var result = query.List();

产品productAlias=null；
var query=\u session.QueryOver（）
.JoinAlias（s=>s.Products，（）=>productAlias）
query=query.TransformUsing（Transformers.distinctroventy）；
var result=query.List（）；

让我们将解决方案分为两个查询

顶部的

QueryOver（）

将正确返回一个不同的列表。而且，通过设计，它将支持分页（

Take（）

，

Skip（）

）

内部的一个将只返回一个存储ID列表，它完全满足任何条件 结果SQL将如下所示

SELECT ... // top one 
FROM Store
WHERE StoreID IN ( SELECT StoreID ...) // inner one

内部的 让我们从内部选择开始，NHibernate已分离

QueryOver

：

Store storeAlias = null;
Product productAlias = null;

// detached query, resulting in a set of searched StoreID 
var subQuery = QueryOver.Of<Store>(() => storeAlias)
    .JoinAlias((s) => s.Products, () => productAlias)
    .Select((s) => s.ID); // ID projection

if (!string.IsNullOrWhiteSpace(criteria.ProductName))
{
    subQuery.Where(Restrictions.On(() => productAlias.Code)
        .IsInsensitiveLike(criteria.ProductName));
}

storestorealias=null；
productAlias=null；
//分离查询，生成一组搜索的StoreID
var subQuery=QueryOver.Of（（）=>storeAlias）
.JoinAlias（（s）=>s.Products，（）=>productAlias）
.选择（（s）=>s.ID）；//ID投影
如果（！string.IsNullOrWhiteSpace（criteria.ProductName））
{
子查询.Where（限制（（）=>productAlias.Code）
.IsInsensitiveLike（criteria.ProductName））；
}

顶部 筛选完存储后，我们可以在top-one中使用此子查询

var query = session.QueryOver<Store>()
   // IN clause
   .Where(Subqueries.PropertyIn("ID", subQuery.DetachedCriteria))
   .Skip(100) 
   .Take(50) // paging over already distinct resultset
   ;

var result = query.List<Store>();

var query=session.QueryOver（）
//在条款中
.Where（subquerys.PropertyIn（“ID”，subQuery.DetachedCriteria））
.Skip（100）
.Take（50）//对已经不同的结果集进行分页
;
var result=query.List（）；

现在我们可以对内部查询应用任何过滤器，并获得满足过滤器条件的存储ID列表。。。在处理顶级查询时，这是不同的