WCF Wire 上的 NHibernate Lazy 初始化集合

Question

我的对象看起来像这样：

class
{
    int a;
    object b;
    IList<string> c;
}

所有字段都从数据库中填充，并且集合正在进行延迟初始化，这是理想的。 现在，我的问题是我想将此对象发送到 Web 服务。但由于集合是延迟加载的，我无法做到这一点。有人可以给我一个想法或方向或一些示例代码，我可以研究我的问题吗？

我想要一种通用方法来强制初始化该列表，然后再通过网络发送该列表。另外，我有多个这样的对象，所以用通用的方法来实现它会很棒。现在，要执行此操作，我正在使用此方法：

public static T Unlazy<T>(this T persistentCollection)
{

    if (persistentCollection is IPersistentCollection) 
    { 
        IPersistentCollection collection = (IPersistentCollection)persistentCollection;             
        collection.SetCurrentSession(session.GetSessionImplementation()); 
        collection.ForceInitialization(); 
    } 
}  

但这会因某种原因引发对象引用设置为 null 异常

Answer 1

没有什么灵丹妙药可以让收藏变得“放松”。您很可能会触发 SELECT+1 问题。您确实需要对对象图执行急切加载。

您可以在映射中执行此操作，但我建议您将映射中的所有内容保留为惰性。最好的策略是在从数据库获取数据时覆盖此行为。如果使用 HQL，查询类似于“

"from class 
left join **fetch** class.b b
left join **fetch** class.c c"

如果您使用 ICriteria，请使用 SetFetchMode()”。

当您执行 List() 时，您会注意到重复的根实体对象。这是预期的行为。如果这不是您想要的，最简单的解决方案是将所有内容加载到 HashedSet 中并枚举结果。

注意：每个实体只能急切加载一个集合。这是 SQL 的限制。

Answer 2

http: //trentaulous.com/2009/08/how-to-use-nhibernate-lazy-initializing-proxies-with-web-services-or-wcf/

顺便说一句，如果您可能想设置代理集合= null，请遵循：

    public static T UnproxyObjectTreeWithNulls<T>(this T persistentObject, ISessionFactory sessionFactory)  //  Force Null Initialization
    {
        //  Получаем настоящий (не proxy) тип элемента
        var persistentType = persistentObject.GetUnproxiedType();

        if (persistentType == null)     //  persistentObject is IPersistentCollection
            //return persistentObject.UnproxyCollectionObjectTreeWithNulls(sessionFactory);
            return persistentObject;

        //  Получаем NHibernate-метаданные класса
        var classMetadata = sessionFactory.GetClassMetadata(persistentType);

        // Iterate through each property and unproxy entity types
        for (int i = 0; i < classMetadata.PropertyTypes.Length; i++)
        {
            var nhType = classMetadata.PropertyTypes[i];
            var propertyName = classMetadata.PropertyNames[i];
            var propertyInfo = persistentType.GetProperty(propertyName);

            if (nhType.IsCollectionType)
            {
                var propertyValue = propertyInfo.GetValue(persistentObject, null);
                if (propertyValue == null) continue;    //  пропускаем пустые свойства

                if (propertyValue is IPersistentCollection)
                {
                    propertyInfo.SetValue(persistentObject, null, null);
                }
                else
                    propertyValue.UnproxyCollectionObjectTreeWithNulls(sessionFactory);
            }
            else if (nhType.IsEntityType)
            {
                var propertyValue = propertyInfo.GetValue(persistentObject, null);
                if (propertyValue == null) continue;    //  пропускаем пустые свойства
                if (propertyValue is INHibernateProxy)
                    //  Если это прокси объект, то мы зануляем его (и отменяем lazy-загрузку)
                    propertyInfo.SetValue(persistentObject, null, null);
                else
                    //  Иначе идем дальше по графу и зануляем поля внутри него
                    propertyInfo.SetValue(persistentObject, propertyValue.UnproxyObjectTreeWithNulls(sessionFactory), null);
            }   
        }

        return persistentObject;
    }

    /// <summary>
    /// Инициализируем ненужные proxy-коллекции null'ами
    /// </summary>
    public static T UnproxyCollectionObjectTreeWithNulls<T>(this T persistentCollection, ISessionFactory sessionFactory) 
    {
        if (!(persistentCollection is IPersistentCollection))      //  если это IPersistentCollection, то мы должны занулить её
        {
            var c = persistentCollection as System.Collections.ICollection;
            if (c == null) return persistentCollection;

            foreach (var item in c)
                item.UnproxyObjectTreeWithNulls(sessionFactory);    //  проделываем все тоже самое внутри элементов коллекции (а кто сказал что будет легко?)
        }

        return persistentCollection;
    }

    /// <summary>
    /// Gets the underlying class type of a persistent object that may be proxied
    /// </summary>
    public static Type GetUnproxiedType<T>(this T persistentObject)
    {
        var proxy = persistentObject as INHibernateProxy;

        if (proxy != null)
            return proxy.HibernateLazyInitializer.PersistentClass;

        var proxyCollection = persistentObject as IPersistentCollection;
        if (proxyCollection != null)
            return null;

        return persistentObject.GetType();
    }

祝你好运 =)

Answer 3

我不确定我是否正确理解了这个问题。您在服务器端有一个数据库 - 您可以将 NHibernate 与该数据库一起使用 - 使用延迟加载。当您的对象传输到客户端时遇到问题吗？

如果是这种情况，您需要做的是停止延迟加载。由于客户端无权访问数据库，因此您将无法从客户端加载延迟加载的数据。在将数据传输到客户端之前，您需要确保数据已加载到服务器端。解决此问题的最简单方法是停止延迟加载。如果没有，您需要确保在将持有对象返回给客户端之前加载惰性数据。如果您有一个从数据库获取数据、执行某些操作并返回该数据的服务，那么您也可以立即从数据库加载数据。

希望这有帮助。

Answer 4

简短的回答：虽然你可能会因为必须比你想要的更多地握住 NHibernate 的手而感到痛苦（就像它对我一样），但我同意 James L 的观点，即急切的获取似乎是最好的方法。

根据 Mauricio 的链接，我们发现直接跨 WCF 传递 NHibernate 实体并不能很好地工作，因为您并不是真正传递 WCF 喜欢的 POCO 对象，而是使用 NHibernate 特定集合来代理对象。

因此，我们成功地使用 Automapper 将实体转换为相应的 DTO，以便在与 WCF 连线。这样做的一个副作用是，它基本上不会延迟所有事情，因为它将遍历对象图以便将其放入另一个对象中。

虽然这可行，但我必须强烈同意 James 关于选择 N+1 问题的警告；我们在网络应用程序中发现，单个页面加载可能会导致数百个单独的数据库调用。首先通过 HQL 或 Criteria 进行急切获取，确实可以减少大量数据。

每个实体只能急切加载一个集合。这是 SQL 的限制。

我不确定这是真的，但我当然建议您在单独的查询中加载集合；我认为您可以将它们全部加载到一个查询中，但在底层 SQL 中，它们将保留为外连接，这将导致笛卡尔积很容易失控。

像往常一样，Ayende Rahien 有 已经很好地描述了所有这些，以及如何使用 Futures 至少在一次往返中相对轻松地完成所有这些单独的集合查询的描述。