非法尝试将集合与两个打开的会话相关联流利的休眠

Question

我有这个异常“非法尝试将一个集合与两个打开的会话相关联”，每次我保存实体包含子集合时都会引发。 我谷歌它。我发现我在调用 save 时打开了两个或多个会话，但我确定我只使用了一个会话。 我哪里做错了？我该如何解决这个问题？ 注意：我使用的是 MVC4 和流利的 NHibernate。

实体：

public class Employee : EntityBase<int>
{
    public Employee()
        : base()
    {
        Phones = new List<Phone>();
    }

    public Employee(int id) : this() { Id = id; }
    [Browsable(false)]
    public override ApprovalBase Approval
    {
        get;
        set;
    }

    public virtual string Name { get; set; }
    public virtual string Job { get; set; }

    [Browsable(false)]
    public virtual IList<Phone> Phones { get; set; }
}
public class Phone : EntityBase<int>
{
    public Phone()
        : base()
    {
    }
    public Phone(int id) : this() { Id = id; }
    public override ApprovalBase Approval
    {
        get;
        set;
    }

    public virtual string PhoneNumber { get; set; }
    public virtual string PhoneType { get; set; }
    public virtual int EmployeeId { get; set; }

    public virtual Employee Employee { get; set; }
}

映射：

public sealed class EmployeeMap : ClassMap<Employee>
{
    public EmployeeMap()
    {
        Table("dbo.Employee");

        Id(x => x.Id).Column("EmployeeId");
        Map(x => x.Name);
        Map(x => x.Job);
        HasMany(x => x.Phones).KeyColumn("EmployeeId").Table("dbo.Phone").Cascade.All().Inverse();
    }
}
public sealed class PhoneMap : ClassMap<Phone>
{
    public PhoneMap()
    {
        Table("dbo.Phone");
        Id(x => x.Id).Column("PhoneId");
        Map(x => x.PhoneNumber);
        Map(x => x.PhoneType);
        Map(x => x.EmployeeId);
        References(x => x.Employee).Column("EmployeeId")
            .Not.Update()
            .Not.Insert();
    }
}

存储库：

public abstract class RepositoryBase<TEntity, TIdentity>
    : IRepository<TEntity, TIdentity>
    where TEntity : EntityBase<TIdentity>
    where TIdentity : IComparable
{
    private readonly IPersistor<TEntity, TIdentity> persistor; //contains the session to operate with the database
    public IPersistor<TEntity, TIdentity> Persistor { get { return persistor; } }

    private readonly IFinder<TEntity, TIdentity> finder;
    public IFinder<TEntity, TIdentity> Finder { get { return finder; } }

    private RepositoryBase() { }

    public RepositoryBase(
        IPersistor<TEntity, TIdentity> persistor,
        IFinder<TEntity, TIdentity> finder)
    {
        this.persistor = persistor;
        this.finder = finder;
        this.finder.DataSource = Query();
    }

    // Get entity by ID
    public virtual TEntity Get(TIdentity id)
    {
        return persistor.Get(id);
    }

    /// <summary>
    /// Validate and Save the entity. If the validation failed, will not save the entity,
    /// but returns back list of error messages.
    /// </summary>
    public virtual IList<String> Save(TEntity entity)
    {
        if (entity == null)
            throw new ArgumentNullException("entity");

        IList<String> errors = entity.Validate();

        if (errors.Count == 0)
        {
            persistor.Save(entity);
        }

        return errors;
    }

    // Delete entity from persistance repository
    public virtual void Delete(TIdentity id)
    {
        persistor.Delete(id);
    }

    /// Gets IQueryable which we use from the concrete
    /// implementation of repository to implement our 
    /// query methods (FindBy).
    protected IQueryable<TEntity> Query()
    {
        return persistor.Query();
    }

    public IList<TEntity> GetAll()
    {
        return persistor.Query().ToList();
    }
}

public class EmployeeRepository : RepositoryBase<Employee, int>, IEmployeeRepository
{
    public EmployeeRepository(
        IPersistor<Employee, int> persistor,
        IEmployeeFinder entityFinder)
        : base(persistor, entityFinder) { }

    public IEmployeeFinder Find
    {
        get { return (IEmployeeFinder)Finder; }
    }
}
public class PhoneRepository : RepositoryBase<Phone, int>, IPhoneRepository
{
    public PhoneRepository(
        IPersistor<Phone, int> persistor,
        IPhoneFinder entityFinder)
        : base(persistor, entityFinder) { }

    public IPhoneFinder Find
    {
        get { return (IPhoneFinder)Finder; }
    }
}

填写Employee的所有信息并添加电话集合后，当我按保存时，信息尚未保存在数据库中。经过一番调试，我发现当我的程序到达“Session.SaveOrUpdate(entity);”时出现上述异常。 如何解决这个问题？

Answer 1

另外，为了完整起见，通常有两种类型的问题：

1. 通常与管理不当的 DAO 对象相关，并创建了自己的 ISession：

   如上面定义的示例，可能有两个对象可以与存储库一起使用：(a) persistor 和 (b) finder。

   他们每个人都有一个ISession 的实例。如果finder 成功并找到了某些东西（例如Phones），实体Employee 会尝试保存，但Phones 与 在不同的会话中员工。

2. 经常与 ASP.NET MVC 及其Redirect() 操作结果相关：

   很可能电话是由不同的会话加载的。不是由处理 Employee 的“当前”。

   所以最可疑的是电话Redirect()。如果是，我们会在 一个控制器的生命周期中加载一个对象 - 将其放入 Temp 字典 - 调用 Redirect 到 其他控制器 -现在有一个新会话以及一个与旧的、已关闭的会话相关联的旧对象。

解决方案：请确保所有 DAO 处理都是 ISession 范围的一部分。不要在会话之间传输任何数据（也不在控制器重定向之间）...

Answer 2

我在每个使用静态变量的方法中都使用 lock 语句解决了这个问题，因为问题的根源与同步有关。

这是一个简单的例子来说明我的解决方案：

private static int sharedVariable;
private static object _syncronizationObject = new Object();

public void MethodThatUsesStaticVariable(int newValue)
{
    // This lock prevents concurrency problems, and this is what solved the issue for me.
    lock(_syncronizationObject)
    {
        sharedVariable = newValue;
    }
}