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);
    }
}

在许多方面，代码 sn-p 看起来像：

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

一方面，在这种情况下，SubstanceGroup，sn-p 看起来像：

    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 给出的实例，并且永远不要用您自己的实例替换它。 （我不知道你的关系类实际上是用来做什么的，所以我不知道这是否是这里的问题。）

域对象在同一会话实例中是唯一的。如果您每次都获得域对象的新实例，那么您可能实现了“session-per-call”反模式，它为每次数据库交互创建一个新会话。

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

Answer 2

除了关于“复杂代码”和“你到底在做什么”的 cmets。问题是我正在替换 NH 的持久性集合，如下面的代码 sn-p：

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 新手的警告一样。