-1

开始使用 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 字典。

这个问题让我脱发，我不明白这是怎么回事？？

4

2 回答 2

3

要回答您的第一个非常笼统的问题：“NHibernate 是否真的提供透明的持久性”，我只能说：没有什么是完美的。NH 尽最大努力尽可能透明，同时尽可能降低其复杂性。

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

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

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

于 2011-08-24T12:18:15.253 回答
0

除了关于“复杂代码”和“你到底在做什么”的评论。问题是我正在替换 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 新手的警告一样。

于 2011-08-26T09:30:49.830 回答