Question

我知道这已经讨论了无数次，但我还没有理解这一点。问题是：何时使用Inverse以及何时在多对多上使用Cascade。

这是我的情景：

我有两个实体：

 public class Contact
    {
        public virtual int Id { get; set; }
        public virtual string Name { get; set; }
        public virtual ICollection<Employee> Employees { get; set; }
    }

 public class Employee
 {
    public virtual int Id { get; set; }
    public virtual string Name { get; set; }
    public virtual ICollection<Contact> Contacts { get; set; }
 }

这是他们的地图：

 public class ContactMap : ClassMap<Contact>
    {
        public ContactMap()
        {
            Table("Contact");
            Id(x => x.Id);
            Map(x => x.Name);

            HasManyToMany(x => x.Employees)
               .Table("Contact_Employee_Link")
               .ParentKeyColumn("Contact_Id ")
               .ChildKeyColumn("Employee_Id")
               .AsSet();
        }
    }

    public class EmployeeMap : ClassMap<Employee>
    {
        public EmployeeMap()
        {
            Id(x => x.Id).GeneratedBy.Identity();
            Map(x => x.Name);

            HasManyToMany(x => x.Contacts)
                .Table("Contact_Employee_Link")
                .ParentKeyColumn("Employee_Id")
                .ChildKeyColumn("Contact_Id")
                .AsSet();
        }
    }

Contact_Employee_Link表只有两列：Contact_Id和Employee_Id ..both 是各个主键表的外键。

我写了一个（荒谬的）单元测试来测试工作：

       [Test]
    public void ShouldSaveEmployeeLinksWhileSavingContact()
    {
        Employee employeeAlias = null;
        using (var session = NHibernateHelper.SessionFactory.OpenSession())
        {
            var contact = session.QueryOver<Contact>()
                 .JoinAlias(x => x.Employees, () => employeeAlias, JoinType.LeftOuterJoin)
                .Where(x => x.Id == 9)
                 .TransformUsing(Transformers.DistinctRootEntity)
                .SingleOrDefault();

            var employee = session.QueryOver<Employee>()
                .Where(x => x.Id == 1)
                .SingleOrDefault();

            contact.Name = "BNM";
            contact.Employees.Add(employee);
            session.SaveOrUpdate(contact);
            session.Flush();
        }

        using (var session = NHibernateHelper.SessionFactory.OpenSession())
        {

            var contact = session.QueryOver<Contact>()
                .JoinAlias(x => x.Employees , () => employeeAlias , JoinType.LeftOuterJoin)
                .Where(x => x.Id == 9)
                .TransformUsing(Transformers.DistinctRootEntity)
                .SingleOrDefault();

            Assert.That(contact.Employees.Count == 1);
        }
    }

它的效果非常好。没有额外的更新，没有错。像魅力一样。我既没有使用Cascade.SaveUpdate（）也没有使用Inverse ..它仍然可以正常工作。

我还有另一个类似的测试，它将联系人添加到员工对象中，并且完全正常。

即使我在多对多mappins上设置Cascade.SaveUpdate（），它仍然有效完全没问题。

然后我尝试将映射的一端设置为Inverse（同时设置为Cascade.SaveUpdate（））并且它仍然可以正常工作。

我的目标是了解什么是建立双向多对多关系的最佳方式。它似乎与我所拥有的东西一起工作......但我无法理解它为什么会起作用。

我确实理解“反向”表示关系的哪一端拥有这种关系。

这如何适用于多对多？

如果我需要能够从两端添加，那该怎么办？我应该使用Cascade.SaveUpdate然后..或者不使用我现在所做的任何事情？

任何想法......？有人可以解释为什么我的单元测试有效吗？

由于

流畅的NHibernate Cascade与反向混乱

0 个答案: