这能解决Nhibernate的身份问题和GetHashCode问题吗?

Question

我建议的解决方案涉及相当多的代码，但你可以只是复制它，并通过它在VS测试解决方案假设你已经安装了SqLite，你应该能够自己运行测试。

由于我一直在使用Nhibernate与对象身份、对象平等和数据库身份问题作斗争，我阅读了各种帖子。但是，我无法清楚地了解如何正确地设置对象标识与集合。基本上，最大的问题是，一旦对象被添加到集合中，它的标识(由GetHashCode派生)方法就不能更改。实现GetHasHCode的首选方法是使用业务键。但是，如果业务钥匙不是正确的呢?我希望用它的新业务密钥更新该实体。但是我的集合就不同步了，因为我违反了对象标识的不变性。

下面的代码是解决这个问题的建议。然而，我当然不是NHibernate专家，也不是一个非常有经验的开发人员，我很乐意收到来自更资深开发人员的评论，看看这是否是一个可行的方法。

using System;
using System.Collections.Generic;
using FluentNHibernate.Cfg;
using FluentNHibernate.Cfg.Db;
using FluentNHibernate.Mapping;
using Iesi.Collections.Generic;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using NHibernate;
using NHibernate.Cfg;
using NHibernate.Tool.hbm2ddl;
using NHibernate.Util;
namespace NHibernateTests
{
    public class InMemoryDatabase : IDisposable
    {
        private static Configuration _configuration;
        private static ISessionFactory _sessionFactory;
        private ISession _session;
        public ISession Session { get { return _session ?? (_session = _sessionFactory.OpenSession()); } }
        public InMemoryDatabase()
        {
// Uncomment this line if you do not use NHProfiler
            HibernatingRhinos.Profiler.Appender.NHibernate.NHibernateProfiler.Initialize();
            _sessionFactory = CreateSessionFactory();
            BuildSchema(Session);
        }
        private static ISessionFactory CreateSessionFactory()
        {
            return Fluently.Configure()
              .Database(SQLiteConfiguration.Standard.InMemory().Raw("hbm2ddl.keywords", "none").ShowSql())
              .Mappings(m => m.FluentMappings.AddFromAssemblyOf<Brand>())
              .ExposeConfiguration(cfg => _configuration = cfg)
              .BuildSessionFactory();
        }
        private static void BuildSchema(ISession Session)
        {
            SchemaExport export = new SchemaExport(_configuration);
            export.Execute(true, true, false, Session.Connection, null);
        }
        public void Dispose()
        {
            Session.Dispose();
        }
    }

    public abstract class Entity<T>
        where T: Entity<T>
    {
        private readonly IEqualityComparer<T> _comparer;
        protected Entity(IEqualityComparer<T> comparer)
        {
            _comparer = comparer;
        } 
        public virtual Guid Id { get; protected set; }
        public virtual bool IsTransient()
        {
            return Id == Guid.Empty;
        }
        public override bool Equals(object obj)
        {
            if (obj == null) return false;
            return _comparer.Equals((T)this, (T)obj);
        }
        public override int GetHashCode()
        {
            return  _comparer.GetHashCode((T)this);
        }
    }
    public class Brand: Entity<Brand>
    {
        protected Brand() : base(new BrandComparer()) {}
        public Brand(String name) : base (new BrandComparer())
        {
            SetName(name);
        }
        private void SetName(string name)
        {
            Name = name;
        }
        public virtual String Name { get; protected set; }
        public virtual Manufactor Manufactor { get; set; }
        public virtual void ChangeName(string name)
        {
            Name = name;
        }
    }
    public class BrandComparer : IEqualityComparer<Brand>
    {
        public bool Equals(Brand x, Brand y)
        {
            return x.Name == y.Name;
        }
        public int GetHashCode(Brand obj)
        {
            return obj.Name.GetHashCode();
        }
    }
    public class BrandMap : ClassMap<Brand>
    {
        public BrandMap()
        {
            Id(x => x.Id).GeneratedBy.GuidComb();
            Map(x => x.Name).Not.Nullable().Unique();
            References(x => x.Manufactor)
                .Cascade.SaveUpdate();
        }
    }
    public class Manufactor : Entity<Manufactor>
    {
        private Iesi.Collections.Generic.ISet<Brand> _brands = new HashedSet<Brand>();
        protected Manufactor() : base(new ManufactorComparer()) {}
        public Manufactor(String name) : base(new ManufactorComparer())
        {
            SetName(name);
        }
        private void SetName(string name)
        {
            Name = name;
        }
        public virtual String Name { get; protected set; }
        public virtual Iesi.Collections.Generic.ISet<Brand> Brands
        {
            get { return _brands; }
            protected set { _brands = value; }
        }
        public virtual void AddBrand(Brand brand)
        {
            if (_brands.Contains(brand)) return;
            _brands.Add(brand);
            brand.Manufactor = this;
        }
    }
    public class ManufactorMap : ClassMap<Manufactor>
    {
        public ManufactorMap()
        {
            Id(x => x.Id);
            Map(x => x.Name);
            HasMany(x => x.Brands)
                .AsSet()
                .Cascade.AllDeleteOrphan().Inverse();
        }
    }
    public class ManufactorComparer : IEqualityComparer<Manufactor>
    {
        public bool Equals(Manufactor x, Manufactor y)
        {
            return x.Name == y.Name;
        }
        public int GetHashCode(Manufactor obj)
        {
            return obj.Name.GetHashCode();
        }
    }
    public static class IdentityChanger
    {
        public static void ChangeIdentity<T>(Action<T> changeIdentity, T newIdentity, ISession session)
        {
            changeIdentity.Invoke(newIdentity);
            session.Flush();
            session.Clear();
        }
    }
    [TestClass]
    public class BusinessIdentityTest
    {
        private InMemoryDatabase _db;
        [TestInitialize]
        public void SetUpInMemoryDb()
        {
            _db = new InMemoryDatabase();
        }
        [TestCleanup]
        public void DisposeInMemoryDb()
        {
            _db.Dispose();
        }
        [TestMethod]
        public void ThatBrandIsIdentifiedByBrandComparer()
        {
            var brand = new Brand("Dynatra");
            Assert.AreEqual("Dynatra".GetHashCode(), new BrandComparer().GetHashCode(brand));
        }
        [TestMethod]
        public void ThatSetOfBrandIsHashedByBrandComparer()
        {
            var brand = new Brand("Dynatra");
            var manufactor = new Manufactor("Lily");
            manufactor.AddBrand(brand);
            Assert.IsTrue(manufactor.Brands.Contains(brand));
        }
        [TestMethod]
        public void ThatHashOfBrandInSetIsThatOfComparer()
        {
            var brand = new Brand("Dynatra");
            var manufactor = new Manufactor("Lily");
            manufactor.AddBrand(brand);
            Assert.AreEqual(manufactor.Brands.First().GetHashCode(), "Dynatra".GetHashCode());
        }
        [TestMethod]
        public void ThatSameBrandCannotBeAddedTwice()
        {
            var brand = new Brand("Dynatra");
            var duplicate = new Brand("Dynatra");
            var manufactor = new Manufactor("Lily");
            manufactor.AddBrand(brand);
            manufactor.AddBrand(duplicate);
            Assert.AreEqual(1, manufactor.Brands.Count);
        }
        [TestMethod]
        public void ThatPersistedBrandIsSameAsLoadedBrandWithSameId()
        {
            var brand = new Brand("Dynatra");
            var manufactor = new Manufactor("Lily");
            manufactor.AddBrand(brand);
            _db.Session.Transaction.Begin();
            _db.Session.Save(brand);
            var copy = _db.Session.Load<Brand>(brand.Id);
            _db.Session.Transaction.Commit();
            Assert.AreSame(brand, copy);
        }
        [TestMethod]
        public void ThatLoadedBrandIsContainedByManufactor()
        {
            var brand = new Brand("Dynatra");
            var manufactor = new Manufactor("Lily");
            manufactor.AddBrand(brand);
            _db.Session.Transaction.Begin();
            _db.Session.Save(brand);
            var copy = _db.Session.Load<Brand>(brand.Id);
            _db.Session.Transaction.Commit();
            Assert.IsTrue(brand.Manufactor.Brands.Contains(copy));
        }
        [TestMethod]
        public void ThatAbrandThatIsLoadedUsesTheSameHash()
        {
            var brand = new Brand("Dynatra");
            var manufactor = new Manufactor("Lily");
            manufactor.AddBrand(brand);
            _db.Session.Transaction.Begin();
            _db.Session.Save(brand);
            var id = brand.Id;
            brand = _db.Session.Load<Brand>(brand.Id);
            Assert.IsTrue(brand.Manufactor.Brands.Contains(new Brand("Dynatra")));
        }
        [TestMethod]
        public void ThatBrandCannotBeFoundIfIdentityChanges()
        {
            var brand = new Brand("Dynatra");
            var manufactor = new Manufactor("Lily");
            manufactor.AddBrand(brand);
            _db.Session.Transaction.Begin();
            _db.Session.Save(brand);
            Assert.IsTrue(brand.Manufactor.Brands.Contains(new Brand("Dynatra")));
            brand.ChangeName("Dynatra_");
            Assert.AreEqual("Dynatra_", brand.Name);
            Assert.AreEqual("Dynatra_".GetHashCode(), brand.Manufactor.Brands.First().GetHashCode());
            Assert.IsFalse(brand.Manufactor.Brands.Contains(brand));
            // ToDo: I don't understand why this test fails
            Assert.IsTrue(brand.Manufactor.Brands.Contains(new Brand("Dynatra")));
        }
        [TestMethod]
        public void ThatSessionNeedsToBeClearedAfterIdentityChange()
        {
            var brand = new Brand("Dynatra");
            var manufactor = new Manufactor("Lily");
            manufactor.AddBrand(brand);
            _db.Session.Transaction.Begin();
            _db.Session.Save(brand);
            var id = brand.Id;
            brand = _db.Session.Load<Brand>(brand.Id);
            // This makes the test pass
            IdentityChanger.ChangeIdentity(brand.ChangeName, "Dynatra_", _db.Session);
            brand = _db.Session.Load<Brand>(id);
            Assert.IsFalse(brand.Manufactor.Brands.Contains(new Brand("Dynatra")));
            Assert.IsTrue(brand.Manufactor.Brands.Contains(new Brand("Dynatra_")));
        }
    }
}

重要的编辑!我现在认为我所建议的方法，正如已经指出的那样，不是正确的方法。对于我所面临的困境，我提供了一个不同的答案。

Answer 1

这是一个有趣的方法，但与其花时间去理解和批评，我只想提供我对这个问题的解决方案。

我不喜欢通用实体基类的想法，所以我的解决方案只支持int, Guid和string身份。下面的一些代码，例如使用Func<int>来获取哈希码，只是为了支持不区分大小写的字符串比较而存在。如果我忽略字符串标识符(我希望我可以)，代码将更紧凑。

这段代码通过了我对它的单元测试，并没有让我在我们的应用程序中失望，但我确信有边缘情况。我唯一想到的是:如果我新建并保存一个实体，它将保留其原始哈希码，但如果保存后我在另一个会话中从数据库检索同一实体的实例，它将具有不同的哈希码。

欢迎反馈。

基类:

[Serializable]
public abstract class Entity
{
    protected int? _cachedHashCode;
    public abstract bool IsTransient { get; }
    // Check equality by comparing transient state or id.
    protected bool EntityEquals(Entity other, Func<bool> idEquals)
    {
        if (other == null)
        {
            return false;
        }
        if (IsTransient ^ other.IsTransient)
        {
            return false;
        }
        if (IsTransient && other.IsTransient)
        {
            return ReferenceEquals(this, other);
        }
        return idEquals.Invoke();
    }
    // Use cached hash code to ensure that hash code does not change when id is assigned.
    protected int GetHashCode(Func<int> idHashCode)
    {
        if (!_cachedHashCode.HasValue)
        {
            _cachedHashCode = IsTransient ? base.GetHashCode() : idHashCode.Invoke();
        }
        return _cachedHashCode.Value;
    }
}

int标识:

[Serializable]
public abstract class EntityIdentifiedByInt : Entity
{
    public abstract int Id { get; }
    public override bool IsTransient
    {
        get { return Id == 0; }
    }
    public override bool Equals(object obj)
    {
        if (obj == null || obj.GetType() != GetType())
        {
            return false;
        }
        var other = (EntityIdentifiedByInt)obj;
        return Equals(other);
    }
    public virtual bool Equals(EntityIdentifiedByInt other)
    {
        return EntityEquals(other, () => Id == other.Id);
    }
    public override int GetHashCode()
    {
        return GetHashCode(() => Id);
    }
}

Guid标识:

[Serializable]
public abstract class EntityIdentifiedByGuid : Entity
{
    public abstract Guid Id { get; }
    public override bool IsTransient
    {
        get { return Id == Guid.Empty; }
    }
    public override bool Equals(object obj)
    {
        if (obj == null || obj.GetType() != GetType())
        {
            return false;
        }
        var other = (EntityIdentifiedByGuid)obj;
        return Equals(other);
    }
    public virtual bool Equals(EntityIdentifiedByGuid other)
    {
        return EntityEquals(other, () => Id == other.Id);
    }
    public override int GetHashCode()
    {
        return GetHashCode(() => Id.GetHashCode());
    }
}

字符串标识:

[Serializable]
public abstract class EntityIdentifiedByString : Entity
{
    public abstract string Id { get; }
    public override bool IsTransient
    {
        get { return Id == null; }
    }
    public override bool Equals(object obj)
    {
        if (obj == null || obj.GetType() != GetType())
        {
            return false;
        }
        var other = (EntityIdentifiedByString)obj;
        return Equals(other);
    }
    public virtual bool Equals(EntityIdentifiedByString other)
    {
        Func<bool> idEquals = () => string.Equals(Id, other.Id, StringComparison.OrdinalIgnoreCase);
        return EntityEquals(other, idEquals);
    }
    public override int GetHashCode()
    {
        return GetHashCode(() => Id.ToUpperInvariant().GetHashCode());
    }
}

Answer 2

我认为这里的基本误解是您基于业务数据实现Equals和GetHashCode。我不知道你为什么喜欢那样，我看不出有什么好处。当然，在处理没有Id的值对象时除外。

在nhforge.org上有一篇关于身份域、等式和哈希码的好文章

编辑:这部分代码会导致问题:

    public static class IdentityChanger
    {
        public static void ChangeIdentity<T>(Action<T> changeIdentity, T newIdentity, ISession session)
        {
            changeIdentity.Invoke(newIdentity);
            session.Flush();
            session.Clear();
        }
    }

1. 冲洗成本高
2. 清除会话使NH再次加载相同的实体。
   1. 它可能会产生太多的db查询，因为实体在会话中找不到了。
   2. 当从数据库中读取的实体链接到另一个实体时，NH会抱怨它是短暂的
   3. 它可能产生内存泄漏，例如，当它发生在循环

您应该基于不可变数据实现Equals和GetHashCode。

Answer 3

我花了很长时间才明白，但我认为我的问题的答案实际上很简单。正如Hibernate团队长期提倡的那样，最好的方法就是不重写equals和gethashcode。我不明白的是，当我在一组业务对象上调用Contains时，显然我想知道该集合是否包含具有特定业务值的对象。但这是我没有从Nhibernate持久化集得到的东西。但是Stefan Steinegger在一个关于这个主题的不同问题的评论中说对了:"持久性集合不是业务集合"!我第一次完全没有理解他的话。

关键问题是我不应该尝试将持久性设置为作为业务集合。相反，我应该使用封装在业务集合中的持久性集。然后事情就容易多了。因此，在我的代码中，我创建了一个包装器:

internal abstract class EntityCollection<TEnt, TParent> : IEnumerable<TEnt>
{
    private readonly Iesi.Collections.Generic.ISet<TEnt> _set;
    private readonly TParent _parent;
    private readonly IEqualityComparer<TEnt> _comparer;
    protected EntityCollection(Iesi.Collections.Generic.ISet<TEnt> set, TParent parent, IEqualityComparer<TEnt> comparer)
    {
        _set = set;
        _parent = parent;
        _comparer = comparer;
    } 
    public IEnumerator<TEnt> GetEnumerator()
    {
        return _set.GetEnumerator();
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
    public bool Contains(TEnt entity)
    {
        return _set.Any(x => _comparer.Equals(x, entity));
    }
    internal Iesi.Collections.Generic.ISet<TEnt> GetEntitySet()
    {
        return _set;
    }
    internal protected virtual void Add(TEnt entity, Action<TParent> addParent)
    {
        if (_set.Contains(entity)) return;
        if (Contains(entity)) throw new CannotAddItemException<TEnt>(entity);
        _set.Add(entity);
        addParent.Invoke(_parent);
    }
    internal protected virtual void Remove(TEnt entity, Action<TParent> removeParent)
    {
        if (_set.Contains(entity)) return;
        _set.Remove(entity);
        removeParent.Invoke(_parent);
    }
}

这是实现集合的业务含义的通用包装器。它通过一个IEqualityComparer知道什么时候两个业务对象的值相等，它将自己呈现为一个真正的业务集合，将实体公开为实体接口的可枚举对象(比公开持久化集干净得多)，它甚至知道如何处理与父对象的双向关系。

拥有此业务集合的父实体具有以下代码:

    public virtual IEnumerable<IProduct> Products
    {
        get { return _products; }
    }
    public virtual Iesi.Collections.Generic.ISet<Product> ProductSet
    {
        get { return _products.GetEntitySet(); }
        protected set { _products = new ProductCollection<Brand>(value, this); }
    }
    public virtual void AddProduct(IProduct product)
    {
        _products.Add((Product)product, ((Product)product).SetBrand);
    }
    public virtual void RemoveProduct(IProduct product)
    {
        _products.Remove((Product)product, ((Product)product).RemoveFromBrand);
    }

因此，实体实际上有两个接口，一个是公开业务集合的业务接口，另一个是公开给Nhibernate处理集合持久性的实体接口。请注意，返回给Nhibernate的持久性集与使用ProductSet属性传入的相同。

基本上都归结为关注点分离:

• 持久化集不是我关心的，而是由nhibernate处理来持久化我的集合
• 按值相等的业务含义由相等比较器处理
• 集合的业务含义，即当集合已经包含具有相同业务值的实体时，我不应该能够传入具有相同业务值的第二个不同对象，由业务集合对象处理。

只是，当我想在会话之间混合实体时，我必须采用上述其他解决方案。但我认为如果你能避免这种情况，你应该。