NHibernate 真的提供透明持久性吗

Question

开始使用 Nhibernate 来实现持久性，受到它尊重域模型的承诺的诱惑，我尝试为我的域对象实现一个关系管理器。基本上，为了干燥管理双向一对多和多对多关系的代码，我决定让这些关系由单独的类管理。当设置一对多或多对一属性时，会在字典中创建两个对象的条目，键可以是具有集合值的一侧以保存多侧，也可以是具有值的多侧一边。

特定类型组合的一对多关系如下所示：

public class OneToManyRelation<TOnePart, TManyPart> : IRelation<IRelationPart, IRelationPart>
    where TOnePart : class, IRelationPart
    where TManyPart : class, IRelationPart
{
    private readonly IDictionary<TOnePart, Iesi.Collections.Generic.ISet<TManyPart>> _oneToMany;
    private readonly IDictionary<TManyPart, TOnePart> _manyToOne;

    public OneToManyRelation()
    {
        _manyToOne = new ConcurrentDictionary<TManyPart, TOnePart>();
        _oneToMany = new ConcurrentDictionary<TOnePart, Iesi.Collections.Generic.ISet<TManyPart>>();
    }

    public void Set(TOnePart onePart, TManyPart manyPart)
    {
        if (onePart == null || manyPart == null) return;
        if (!_manyToOne.ContainsKey(manyPart)) _manyToOne.Add(manyPart, onePart);
        else _manyToOne[manyPart] = onePart;
    }

    public void Add(TOnePart onePart, TManyPart manyPart)
    {
        if (onePart == null || manyPart == null) return;

        if (!_manyToOne.ContainsKey(manyPart)) _manyToOne.Add(manyPart, onePart);
        else _manyToOne[manyPart] = onePart;
        if (!_oneToMany.ContainsKey(onePart)) _oneToMany.Add(onePart, new HashedSet<TManyPart>());
        _oneToMany[onePart].Add(manyPart);
    }

    public Iesi.Collections.Generic.ISet<TManyPart> GetManyPart(TOnePart onePart)
    {
        if (!_oneToMany.ContainsKey(onePart)) _oneToMany[onePart] = new HashedSet<TManyPart>();
        return _oneToMany[onePart];
    }

    public TOnePart GetOnePart(TManyPart manyPart)
    {
        if(!_manyToOne.ContainsKey(manyPart)) _manyToOne[manyPart] = default(TOnePart);
        return _manyToOne[manyPart];
    }

    public void Remove(TOnePart onePart, TManyPart manyPart)
    {
        _manyToOne.Remove(manyPart);
        _oneToMany[onePart].Remove(manyPart);
    }

    public void Set(TOnePart onePart, Iesi.Collections.Generic.ISet<TManyPart> manyPart)
    {
        if (onePart == null) return;
        if (!_oneToMany.ContainsKey(onePart)) _oneToMany.Add(onePart, manyPart);
        else _oneToMany[onePart] = manyPart;
    }

    public void Clear(TOnePart onePart)
    {
        var list = new HashedSet<TManyPart>(_oneToMany[onePart]);
        foreach (var manyPart in list)
        {
            _manyToOne.Remove(manyPart);
        }
        _oneToMany.Remove(onePart);
    }

    public void Clear(TManyPart manyPart)
    {
        if (!_manyToOne.ContainsKey(manyPart)) return;
        if (_manyToOne[manyPart] == null) return;

        _oneToMany[_manyToOne[manyPart]].Remove(manyPart);
        _manyToOne.Remove(manyPart);
    }
}

在多方面，代码片段如下所示：

    public virtual SubstanceGroup SubstanceGroup
    {
        get { return RelationProvider.SubstanceGroupSubstance.GetOnePart(this); } 
        protected set { RelationProvider.SubstanceGroupSubstance.Set(value, this); }
    }

在一方面，因此，在本例中为 SubstanceGroup，代码片段如下所示：

    public virtual ISet<Substance> Substances
    {
        get { return RelationProvider.SubstanceGroupSubstance.GetManyPart(this); }
        protected set { RelationProvider.SubstanceGroupSubstance.Set(this, value); }
    }

仅使用我的域对象，这效果很好。在域对象中，我只需引用一个抽象工厂来检索适当的关系，并且我可以从一侧设置关系，从而自动变为双向关系。

然而，当 NH 出现时，问题是我的字典中出现了重复的键。 NH 以某种方式使用域对象的新副本（？）设置具有空值（！）的关系属性。因此，当保存域对象时，我有该域对象的两个条目，例如关系的多方，即 _manyToOne 字典。

这个问题让我掉头发，我不明白发生了什么？

Answer 1

为了回答你的第一个非常普遍的问题：“NHibernate 真的提供透明的持久性吗”，我只能说：没有什么是完美的。 NH 尽力保持尽可能透明，同时也努力保持尽可能低的复杂性。

有一些假设，特别是关于集合的假设：集合及其实现不被视为域模型的一部分。 NH 提供了自己的集合实现。您不仅需要使用 ISet 和 IList 等接口。当从数据库读取对象时，您还应该采用 NH 给出的实例，并且切勿用您自己的实例替换它。 （我不知道您的关系类实际用于什么，所以我不知道这是否是这里的问题。）

域对象在会话的同一实例中是唯一的。如果每次都获得域对象的新实例，则您可能实现了“每次调用会话”反模式，该模式为每个数据库交互创建一个新会话。

我不知道你到底在做什么。这个 OneToManyRelation 实际上是如何使用的？当 NH 表现不符合预期时，您在做什么？对于您的具体实施来说，这是一个非常具体的问题。

Answer 2

除了“复杂的代码”和“你到底在做什么”的评论之外。问题是我正在替换 NH 的持久性集合，如下面的代码片段所示：

public void Add(TOnePart onePart, TManyPart manyPart)
{
    if (onePart == null || manyPart == null) return;

    if (!_manyToOne.ContainsKey(manyPart)) _manyToOne.Add(manyPart, onePart);
    else _manyToOne[manyPart] = onePart;
    if (!_oneToMany.ContainsKey(onePart)) _oneToMany.Add(onePart, new HashedSet<TManyPart>());
    _oneToMany[onePart].Add(manyPart);
}

我为许多部分创建了一个新的哈希集。这就是问题所在。如果只是设置了传入集合的许多部分（在 NH 的持久性集合实现的情况下），那么它就会起作用。

作为 NH 新手，用 NH 的特殊实现替换集合一直是错误的重要来源。作为对其他 NH 新手的警告。