Question

nHibernate3;从EAV数据模式中检索4xxx记录。当nHibernate或.NET第一次初始化这些集合时，我们看到了严重的惩罚。后续调用看起来效率更高。在SQL Server Management Studio中运行相同的查询会导致预期的快速返回时间。

使用Fluent和运行时映射代替.hbm.xml;好奇，如果序列化的映射会有帮助吗？

nHibernate Profiler和log4net日志记录似乎没有让我继续下去。在此过程中总共有140,000个实体被水合。

附上我的dotTrace性能跟踪的屏幕截图，显示了集合初始化惩罚： dotTrace of slow nHibernate collection initialization

尝试了加入和渴望的fetchtypes，没有明显的结果，但我不是100％确定我正确地实现了这些 - 只是父母需要如此指定，还是子表也需要被标记？

var products = ((HandleSession)_handleSession).Session.CreateCriteria(typeof(Product))
                    .SetFetchMode("Product", FetchMode.Eager)
                    .List<Product>()
                    .AsEnumerable();

通过web.config启用反射优化器（我认为）： With reflection optimizer enabled

这是花费大部分时间的地方：

return new ProductList(products.Select(p => p.ToProductContract()));

这只是一种扩展方法：

public static ProductContract ToProductContract(this Product product)
        {
            return new ProductContract
                       {
                           Name = product.ProductName,
                           ProductTypeName = product.ProductType.ProductTypeName,
                           UpdateTimeStamp = product.UpdateDateTime,
                           ProductNumber = product.ProductNumber,
                           Attributes = product.ProductAttributes.ToCommonAttribute().ToList(),
                           GroupCategories = product.ProductGroups.ToGroupCategory().ToList(),
                           PublicUniqueId = product.PublicUniqueId
                       };
        }

映射：

internal class ProductMapping : ClassMap<Product>
    {
        private const string _iscurrentindicator = "IsCurrentIndicator=1";

        public ProductMapping()
        {
            Table("Product");
            Id(Reveal.Member<Product>("ProductId")).GeneratedBy.Identity().Column("ProductID");
            Map(x => x.ProductNumber).Column("ProductNumber").Not.Nullable();
            Map(x => x.ProductName).Column("ProductName").Not.Nullable();
            Map(x => x.InsertDateTime).Column("InsertedDateTime").Nullable().ReadOnly();
            Map(x => x.UpdateDateTime).Column("UpdatedDateTime").Nullable();
            Map(x => x.PublicUniqueId).Column("ProductGUID").Generated.Insert();

            References(x => x.ProductType).Column("ProductTypeId").Not.Nullable();
            HasMany(x => x.ProductAttributes)
                .KeyColumn("ProductId")
                .Inverse()
                .Fetch
                .Subselect()
                .Where(_iscurrentindicator)
                .Cascade
                .SaveUpdate();

            HasMany(x => x.ProductGroups).KeyColumn("ProductId").Fetch.Subselect().Where(_iscurrentindicator);
            DynamicUpdate();
            DynamicInsert();
            BatchSize(500);
        }
    }

internal class ProductGroupMapping : ClassMap<ProductGroup>
    {
        public ProductGroupMapping()
        {
            Table("ProductGroup");
            Id(x => x.ProductGroupId).Column("ProductGroupId").GeneratedBy.Identity();
            References(x => x.Product).Column("ProductId").Not.Nullable();
            References(x => x.Group).Column("GroupId").Not.Nullable();
            //Where("IsCurrentIndicator=1");
        }
    }

internal class ProductAttributeMapping : ClassMap<ProductAttribute>
    {
        public ProductAttributeMapping()
        {
            Table("ProductAttribute");
            LazyLoad();
            Id(x => x.ProductAttributeId).GeneratedBy.Identity().Column("ProductAttributeID");
            References(x => x.Product).Column("ProductID").Not.Nullable();
            References(x => x.Attribute).Column("AttributeID").Not.Nullable().Fetch.Join();
            Map(x => x.PositionNumber).Column("PositionNumber").Nullable();
            Map(x => x.ValueText).Column("ValueText").Nullable();
            Map(x => x.ValueBinary).Column("ValueBinary").Nullable();

            Component(x => x.OperationalAuditHistory, m =>
                        {
                            Table("ProductAttribute");
                            m.Map(x => x.ExpirationDateTime).Column("ExpirationDateTime").Nullable();
                            m.Map(x => x.IsCurrent).Column("IsCurrentIndicator").Not.Nullable();
                            m.Map(x => x.OperationCode).Column("OperationCode").Nullable();
                            m.Map(x => x.OperationDateTime).Column("OperationDateTime").Nullable();
                            m.Map(x => x.OperationSystemName).Column("OperationSystemName").Nullable();
                            m.Map(x => x.OperationUserName).Column("OperationUserName").Nullable();
                            m.Map(x => x.LastUserPriority).Column("LastUserPriority").Nullable();
                        });

            DynamicInsert();
            BatchSize(50);
        }
    }

不幸的是，尽管如此，我似乎仍然得到了类似的结果。这是一个新的痕迹;我现在已经切换到Release和x64用于关键项目，因此时间较短，但比例仍然几乎相同;以及.Eager：

var products = ((HandleSession) _handleSession).Session.CreateCriteria(typeof (Product))
                    .SetFetchMode("ProductAttribute", FetchMode.Join)
                    .SetFetchMode("ProductGroup", FetchMode.Join)
                    .SetFetchMode("ProductType", FetchMode.Join)
                    .Future<Product>()
                    .AsEnumerable();

dotTrace - Release mode, targeting x64, with .Future()

使用.Eager和.Future生成SQL：

将this_.ProductID选为   ProductID0_1_，this_.ProductNumber as   ProductN2_0_1_，this_.ProductName as   ProductN3_0_1_，this_.InsertedDateTime   如Inserted4_0_1_，   this_.UpdatedDateTime as   更新了D5_0_1_，this_.ProductGUID为   ProductG6_0_1_，this_.ProductTypeId as   ProductT7_0_1_，   producttyp2_.ProductTypeID as   ProductT1_6_0_，   producttyp2_.ProductTypeName as   ProductT2_6_0_ FROM产品this_   内部联接ProductType producttyp2_ on   this_.ProductTypeId = producttyp2_.ProductTypeID;

选择productatt0_.ProductId as   ProductId2_，   productatt0_.ProductAttributeID as   ProductA1_2_，   productatt0_.ProductAttributeID as   ProductA1_2_1_，   productatt0_.PositionNumber as   Position2_2_1_，productatt0_.ValueText   作为ValueText2_1_，   productatt0_.ValueBinary as   ValueBin4_2_1_，productatt0_.ProductID   作为ProductID2_1_，   productatt0_.AttributeID as   Attribut6_2_1_，   productatt0_.ExpirationDateTime as   Expirati7_2_1_，   productatt0_.IsCurrentIndicator as   IsCurren8_2_1_，   productatt0_.OperationCode as   Operatio9_2_1_，   productatt0_.OperationDateTime as   Operati10_2_1_，   productatt0_.OperationSystemName as   Operati11_2_1_，   productatt0_.OperationUserName as   Operati12_2_1_，   productatt0_.LastUserPriority as   LastUse13_2_1_，   attribute1_.AttributeId as   Attribut1_1_0_，   attribute1_.AttributeName as   Attribut2_1_0_，   attribute1_.DisplayName为   DisplayN3_1_0_，   attribute1_.DataTypeName为   DataType4_1_0_，   attribute1_.ConstraintText as   Constrai5_1_0_，   attribute1_.ConstraintMin as   Constrai6_1_0_，   attribute1_.ConstraintMax as   Constrai7_1_0_，attribute1_.ValuesMin   作为ValuesMin1_0_，   attribute1_.ValuesMax as   ValuesMax1_0_，attribute1_.Precision   as Precision1_0_ FROM ProductAttribute   productatt0_内连接属性   attribute1_ on   productatt0_.AttributeID = attribute1_.AttributeId   哪里   （productatt0_.IsCurrentIndicator = 1）   和productatt0_.ProductId in（选择   this_.ProductID FROM Product this_   内部联接ProductType producttyp2_ on   this_.ProductTypeId = producttyp2_.ProductTypeID）

SELECT productgro0_.ProductId as   ProductId1_，   productgro0_.ProductGroupId as   ProductG1_1_，   productgro0_.ProductGroupId as   ProductG1_3_0_，productgro0_.ProductId   如ProductId3_0_，productgro0_.GroupId   as GroupId3_0_ FROM ProductGroup   productgro0_ WHERE   （productgro0_.IsCurrentIndicator = 1）   和productgro0_.ProductId（选择   this_.ProductID FROM Product this_   内部联接ProductType producttyp2_ on   this_.ProductTypeId = producttyp2_.ProductTypeID）

Answer 1

1）序列化映射只会减少构建SessionFactory所需的时间。如果上述查询不是第一次访问数据库，那么就不会在这方面做任何事情。

2）设置FetchMode需要应用于子节点，如下所示：

var products = ((HandleSession)_handleSession).Session.CreateCriteria(typeof(Product))
                .SetFetchMode("ProductChildren", FetchMode.Eager)
                .List<Product>()
                .AsEnumerable();

3）如果我正确解释截图中的方法，这看起来像是N + 1问题。您是否将查询结果中的Products转换为ProductDTO列表？如果是这样，似乎子集合在循环中从DB中延迟加载。

修改

为了对抗N + 1 Select，我们必须事先告诉NHibernate加载所有内容，最好是使用Futures。这是一个潜在的解决方案，它基本上使用少量Select语句从数据库中提取所有数据。我没有包括任何Where-conditions。那些你必须相应添加。

// any where-condition will have to be applied here and in the subsequent queries var products = session.QueryOver<Product>() .Future(); var products2 = session.QueryOver<Product>() .Fetch(p => p.ProductType).Eager .Future(); var products3 = session.QueryOver<Product>() .Fetch(p => p.ProductAttributes).Eager .Future(); var products4 = session.QueryOver<Product>() .Fetch(p => p.ProductGroups).Eager .Future(); // Here we execute all of the above queries in one roundtrip. // Since we already have all the data we could possibly want, there is no need // for a N+1 Select. return new ProductList(products.Select(p => p.ToProductContract()));

Answer 2

一种选择是在集合上启用批量大小。我认为这些是懒惰的，并且启用批量大小后，它会尝试在单个往返中获取多个实体的集合。

如果您使用一个集合获取1个实体，则没有任何区别，但如果您选择1000个实体，这些实体都有一个集合，则会产生巨大差异。使用批量大小为1000将导致2个查询而不是1001.

试图找到一些文档，但只找到了这个例子：

nhibernate alternates batch size

在您的情况下使用连接策略会导致巨大的结果集，因此这不是一个好的选择。一个更好的选择是使用FetchMode.Select，这将明确强制您的集合在后续往返中加载。

可以改善性能的另一件事是设置：

Session.FlushMode = FlushMode.Never;

禁用自动刷新示波器。如果您实际执行的只是读取数据而不是修改数据，这将非常有用。但是，您会在callstack中看到对IsDirty的调用或对脏对象的任何其他检查。

Answer 3

如果您仅将此会话用于报告，则必须使用无状态会话： http://nhforge.org/blogs/nhibernate/archive/2008/10/30/bulk-data-operations-with-nhibernate-s-stateless-sessions.aspx

如何解决不良的nHibernate集合初始化问题

3 个答案: