14

我有一个看起来像这样的对象模型（伪代码）：

class Product {
    public ISet<Product> Recommendations {get; set;}
    public ISet<Product> Recommenders {get; set;}
    public ISet<Image> Images {get; set; }
}

当我加载给定产品并想要显示其推荐的图像时，我遇到了 N+1 问题。（推荐是延迟加载的，然后循环调用每个推荐的 .Images 属性。）

Product -> Recommendations -> Images

我想做的是急切地加载图表的这个特定部分，但我不知道该怎么做。我可以急切地加载推荐，但不能加载它们的图像。这是我一直在尝试的，但它似乎不起作用：

//get the IDs of the products that will be in the recommendations collection
var recommendedIDs = QueryOver.Of<Product>()
    .Inner.JoinQueryOver<Product>(p => p.Recommenders)
    .Where(r => r.Id == ID /*product we are currently loading*/)
    .Select(p => p.Id);

//products that are in the recommendations collection should load their 
//images eagerly
CurrentSession.QueryOver<Product>()
    .Fetch(p => p.Images).Eager
    .Where(Subqueries.WhereProperty<Product>(p => p.Id).In(recommendedIDs))
    .Future<Product>();

//load the current product
return CurrentSession.QueryOver<Product>()
    .Where(p => p.Id == ID);

使用 QueryOver，最好的方法是什么？我不想一直急切地加载图像，只是在这种特殊情况下。

编辑：我改变了我的方法，虽然这并不完全是我的想法，但它确实避免了 N+1 问题。我现在使用两个查询，一个查询产品，一个查询推荐图片。产品查询很简单；这是图像查询：

//get the recommended product IDs; these will be used in
//a subquery for the images
var recommendedIDs = QueryOver.Of<Product>()
    .Inner.JoinQueryOver<Product>(p => p.Recommenders)
    .Where(r => r.Id == RecommendingProductID)
    .Select(p => p.Id);

//get the logo images for the recommended products and
//create a flattened object for the data
var recommendations = CurrentSession.QueryOver<Image>()
    .Fetch(i => i.Product).Eager
    /* filter the images down to only logos */
    .Where(i => i.Kind == ImageKind.Logo)
    .JoinQueryOver(i => i.Product)
    /* filter the products down to only recommendations */
    .Where(Subqueries.WhereProperty<Product>(p => p.Id).In(recommendedIDs))
    .List().Select(i => new ProductRecommendation {
        Description = i.Product.Description,
        ID = i.Product.Id,
        Name = i.Product.Name,
        ThumbnailPath = i.ThumbnailFile
    }).ToList();

return recommendations;
4

3 回答 3

17

JoinAlias是另一种急切地获取相关记录的方法，而且我们可以用它来更深入地挖掘另一个Recommendations层次Images。我们会使用LeftOuterJoin，因为我们想要加载产品，即使它没有推荐。

Product recommendationAlias = null;
Image imageAlias = null;

return CurrentSession.QueryOver<Product>()
    .JoinAlias(x => x.Recommendations, () => recommendationAlias, JoinType.LeftOuterJoin)
    .JoinAlias(() => recommendationAlias.Images, () => imageAlias, JoinType.LeftOuterJoin)
    .Where(x => x.Id == ID)
    .TransformUsing(Transformers.DistinctRootEntity)
    .SingleOrDefault();

在与 NHibernate 讨论对多个集合的 Eager fetching 时，您经常听到人们提到笛卡尔产品，但这不是问题。但是，如果您希望加载以下图表...

 Product -> Recommendations -> Images
         -> Images

...然后 Product.Recommendations.Images X Product.Images 将形成我们应该避免的笛卡尔积。我们可以这样做：

Product recommendationAlias = null;
Image imageAlias = null;

var productFuture = CurrentSession.QueryOver<Product>()
    .JoinAlias(x => x.Recommendations, () => recommendationAlias, JoinType.LeftOuterJoin)
    .JoinAlias(() => recommendationAlias.Images, () => imageAlias, JoinType.LeftOuterJoin)
    .Where(x => x.Id == ID)
    .TransformUsing(Transformers.DistinctRootEntity)
    .FutureValue();

var imagesFuture = CurrentSession.QueryOver<Product>()
    .Fetch(x => x.Images).Eager
    .Where(x => x.Id == ID)
    .TransformUsing(Transformers.DistinctRootEntity)
    .Future();

return productFuture.Value;
于 2011-08-12T04:40:06.540 回答
3

使用 NHibernateUtil 类对您关心的图形部分强制加载。

 NHibernateUtil.Initialize(Product.Recommendations);

有关详细信息，请参阅下面的链接。

http://nhforge.org/wikis/howtonh/lazy-loading-eager-loading.aspx

于 2011-04-11T16:17:16.060 回答
1

如果您只想避免 N+1 麻烦，请使用延迟加载的批量获取而不是急切加载。

它消除了 N+1 个问题，同时对代码的影响最小：您只需更改配置参数或调整映射。

在配置中，default_batch_fetch_size为您通常的延迟加载计数设置一些合理的值。20通常是一个很好的价值。

或者在映射中，设置类 ( ) 和集合 ( , , ...) 的batch-size属性，以逐个控制延迟加载批处理。<class><set><bag>

这会将延迟加载的实体和实体集合配置为不仅加载自身，还加载其他一些等待实体（同一类）或实体集合（同一类的其他实体的相同集合）。

我已经在这个其他答案中写了详细的解释。

于 2017-05-11T16:22:38.583 回答