Fluent nhibernate 与Fluent NHibernate的多对多关系_Fluent Nhibernate_Many To Many

Fluent nhibernate 与Fluent NHibernate的多对多关系

fluent-nhibernate

Fluent nhibernate 与Fluent NHibernate的多对多关系,fluent-nhibernate,many-to-many,Fluent Nhibernate,Many To Many,我得到了以下错误：“无法理解多对多的另一面应该是什么。” 团队实体： public class Team : IEntity { public int Id { get; set; } public string Name { get; set; } public IList<Employee> Employee { get; set; } public Team() { Employee = new List<Em

我得到了以下错误：“无法理解多对多的另一面应该是什么。” 团队实体：

public class Team : IEntity
{
    public int Id { get; set; }

    public string Name { get; set; }

    public IList<Employee> Employee { get; set; }

    public Team()
    {
        Employee = new List<Employee>();
    }
}

公共类团队：IEntity
{
公共int Id{get；set；}
公共字符串名称{get；set；}
公共IList雇员{get；set；}
公共团队（）
{
Employee=新列表（）；
}
}

员工实体：

public class Employee : IEntity
{
    public int Id { get; set; }

    public String LastName { get; set; }

    public string FirstName { get; set; }

    public IList<Team> Team { get; set; }

    public string EMail { get; set; }

    public Employee()
    {
        Team = new List<Team>();
    }
}

公共类员工：IEntity
{
公共int Id{get；set；}
公共字符串LastName{get；set；}
公共字符串名{get；set；}
公共IList团队{get；set；}
公共字符串电子邮件{get；set；}
公职人员（）
{
团队=新列表（）；
}
}

团队映射：

public class TeamMap : ClassMap<Team>
{
    public TeamMap()
    {
        // identity mapping
        Id(p => p.Id);

        // column mapping
        Map(p => p.Name);

        // relationship mapping
        HasManyToMany<Employee>(m => m.Employee);
    }
}

公共类团队地图：类地图
{
公共团队地图（）
{
//身份映射
Id（p=>p.Id）；
//列映射
Map（p=>p.Name）；
//关系映射
HasManyToMany（m=>m.Employee）；
}
}

员工映射：

public class EmployeeMap : ClassMap<Employee>
{
    public EmployeeMap()
    {
        // identifier mapping
        Id(p => p.Id);

        // column mapping
        Map(p => p.EMail);
        Map(p => p.LastName);
        Map(p => p.FirstName);

        // relationship mapping
        HasManyToMany<Team>(m => m.Team);
    }
}

公共类EmployeeMap:ClassMap
{
公共雇员地图（）
{
//标识符映射
Id（p=>p.Id）；
//列映射
地图（p=>p.EMail）；
Map（p=>p.LastName）；
Map（p=>p.FirstName）；
//关系映射
HasManyToMany（m=>m.Team）；
}
}

没有人有答案

编辑：以下代码出现错误：

public static ISessionFactory CreateSessionFactory()
{
    return Fluently.Configure()
        .Database(MsSqlConfiguration.MsSql2008
        .ConnectionString(c=>
            c.Database("Ariha")
            .TrustedConnection()
            .Server("localhost")
            ).ShowSql())
        .Mappings(m => m.FluentMappings
            .AddFromAssemblyOf<BookMap>()
            .AddFromAssemblyOf<MagazineMap>()
            .AddFromAssemblyOf<EmployeeMap>()
            .AddFromAssemblyOf<TeamMap>())
        .ExposeConfiguration(BuildSchema)
        .BuildSessionFactory();
}

公共静态ISessionFactory CreateSessionFactory（）
{
流畅地返回。Configure（）
.数据库（MsSqlConfiguration.MsSql2008
.ConnectionString（c=>
c、 数据库（“Ariha”）
.TrustedConnection（）
.Server（“本地主机”）
).ShowSql（））
.Mappings（m=>m.FluentMappings
.AddFromAssemblyOf（）的
.AddFromAssemblyOf（）的
.AddFromAssemblyOf（）的
.AddFromAssemblyOf（））
.ExposeConfiguration（构建架构）
.BuildSessionFactory（）；
}

编辑：这里是整个解决方案：

Fluent NHibernate试图通过查看实体名称和集合属性来确定多对多关系的另一面是什么。我相信它在你的情况下不起作用，因为你的收藏属性不是复数；尝试分别重命名您的收藏

员工

和

团队

另一种方法是在两侧手动设置多对多表名称，因为这将禁用预测。

Fluent NHibernate通过查看实体名称和集合属性来确定多对多关系的另一侧是什么。我相信它在你的情况下不起作用，因为你的收藏属性不是复数；尝试分别重命名您的收藏

员工

和

团队

另一种方法是在两侧手动设置多对多表名，因为这将禁用预测。

您能提供导致错误的代码吗？我刚刚尝试了您的映射，它们似乎工作得很好（在fluent 1.0 RTM和NH 2.1.1 GA上，使用SQLite数据库），只需对EmployeeMap稍作修改（我假设员工-团队关系是双向的，并且根据需要将一侧标记为反向）

//关系映射
HasManyToMany（m=>m.Team）.Inverse（）；

当然，如果员工与团队之间的关系不是双向的，我会认为您应该能够为每个关系指定不同的.Table（名称）——但我没有测试过，您似乎得到了不同的结果（因此，为什么提供示例代码最好）

我还想补充一点，我怀疑Set语义（而不是Bag）更适合Employee.Team和Team.Employee属性。（不管怎样，不要做任何假定秩序得到维护的事情，也不能保证秩序会得到维护）

建议的映射和示例：

 public class Team
 {
  public int Id { get; set; }
  public string Name { get; set; }
  public ICollection<Employee> Employee { get; set; }
  public Team() { Employee = new List<Employee>(); }
 }

 public class Employee
 {
  public int Id { get; set; }
  public String LastName { get; set; }
  public string FirstName { get; set; }
  public ICollection<Team> Team { get; set; }
  public string EMail { get; set; }
  public Employee() { Team = new List<Team>(); }
 }

 public class TeamMap : ClassMap<Team>
 {
  public TeamMap()
  {
   Not.LazyLoad();
   // identity mapping
   Id(p => p.Id);
   // column mapping
   Map(p => p.Name);
   // relationship mapping
   HasManyToMany<Employee>(m => m.Employee).AsSet();
  }
 }

 public class EmployeeMap : ClassMap<Employee>
 {
  public EmployeeMap()
  {
   Not.LazyLoad();
   // identifier mapping
   Id(p => p.Id);
   // column mapping
   Map(p => p.EMail);
   Map(p => p.LastName);
   Map(p => p.FirstName);
   // relationship mapping
   HasManyToMany<Team>(m => m.Team).Inverse().AsSet();
  }
 }

 [TestFixture]
 public class Mapping
 {
  [Test]
  public void PersistDepersist()
  {
   var fcfg = Fluently.Configure()
    .Database(SQLiteConfiguration.Standard.UsingFile("testdb.sqldb"))
    .Mappings(mc =>
    {
     mc.FluentMappings.Add(typeof (TeamMap));
     mc.FluentMappings.Add(typeof (EmployeeMap));
    })
    .ExposeConfiguration(cfg => new SchemaExport(cfg).Execute(false, true, false));

   var sess = fcfg.BuildSessionFactory().OpenSession();


   var teams = Enumerable.Range(0, 4).Select(i => new Team() {Name = "Team " + i}).ToArray();
   var employees = Enumerable.Range(0, 10).Select(i => new Employee() {FirstName = "Employee " + i}).ToArray();

   teams[0].Employee = new List<Employee>() {employees[0], employees[3], employees[5]};
   teams[1].Employee = new List<Employee>() {employees[7], employees[2], employees[5]};
   teams[3].Employee = new List<Employee>() {employees[0], employees[8], employees[9]};

   foreach (var team in teams)
    foreach (var employee in team.Employee)
     employee.Team.Add(team);

   Console.WriteLine("Dumping Generated Team/Employees:");
   Dump(teams);
   Dump(employees);

   using (var t = sess.BeginTransaction())
   {
    foreach (var team in teams)
     sess.Save(team);
    foreach (var employee in employees)
     sess.Save(employee);
    t.Commit();
   }

   sess.Flush();
   sess.Clear();

   var teamsPersisted = sess.CreateCriteria(typeof (Team)).List<Team>();
   var employeesPersisted = sess.CreateCriteria(typeof (Employee)).List<Employee>();

   Assert.AreNotSame(teams, teamsPersisted);
   Assert.AreNotSame(employees, employeesPersisted);

   Console.WriteLine();
   Console.WriteLine();
   Console.WriteLine("Dumping Depersisted Team/Employees:");
   Dump(teamsPersisted);
   Dump(employeesPersisted);
  }

  private static void Dump(IEnumerable<Team> teams)
  {
   foreach (var team in teams)
    Console.WriteLine("Team: " + team.Name + " has members: " + string.Join(", ", team.Employee.Select(e => e.FirstName).ToArray()));
  }

  private static void Dump(IEnumerable<Employee> employees)
  {
   foreach (var employee in employees)
    Console.WriteLine("Employee: " + employee.FirstName + " in teams: " + string.Join(", ", employee.Team.Select(e => e.Name).ToArray()));
  }
 }

公共类团队
{
公共int Id{get；set；}
公共字符串名称{get；set；}
公共ICollection雇员{get；set；}
公共团队（）{Employee=new List（）；}
}
公营雇员
{
公共int Id{get；set；}
公共字符串LastName{get；set；}
公共字符串名{get；set；}
公共ICollection团队{get；set；}
公共字符串电子邮件{get；set；}
公共雇员（）{Team=newlist（）；}
}
公共类TeamMap:ClassMap
{
公共团队地图（）
{
不是。懒汉（）；
//身份映射
Id（p=>p.Id）；
//列映射
Map（p=>p.Name）；
//关系映射
HasManyToMany（m=>m.Employee）.AsSet（）；
}
}
公共类EmployeeMap:ClassMap
{
公共雇员地图（）
{
不是。懒汉（）；
//标识符映射
Id（p=>p.Id）；
//列映射
地图（p=>p.EMail）；
Map（p=>p.LastName）；
Map（p=>p.FirstName）；
//关系映射
HasManyToMany（m=>m.Team）.Inverse（）.AsSet（）；
}
}
[测试夹具]
公共类映射
{
[测试]
public void persistedepersist（）
{
var fcfg=fluntly.Configure（）
.Database（SQLiteConfiguration.Standard.UsingFile（“testdb.sqldb”））
.Mappings（mc=>
{
mc.FluentMappings.Add（typeof（TeamMap））；
添加（typeof（EmployeeMap））；
})
.ExposeConfiguration（cfg=>newschemaexport（cfg）.Execute（false，true，false））；
var sess=fcfg.BuildSessionFactory（）.OpenSession（）；
var teams=Enumerable.Range（0，4）.Select（i=>newteam（）{Name=“Team”+i}）.ToArray（）；
var employees=Enumerable.Range（0，10）.Select（i=>newemployees（）{FirstName=“employees”+i}）.ToArray（）；
团队[0]。Employee=new List（）{employees[0]，employees[3]，employees[5]}；
团队[1]。Employee=new List（）{employees[7]，employees[2]，employees[5]}；
团队[3]。Employee=new List（）{employees[0]，employees[8]，employees[9]}；
foreach（团队中的var团队）
foreach（团队中的var员工。员工）
employee.Team.Add（团队）；
Console.WriteLine（“转储生成的团队/员工：”）；
垃圾场（团队）；
倾销（雇员）；
 public class Team
 {
  public int Id { get; set; }
  public string Name { get; set; }
  public ICollection<Employee> Employee { get; set; }
  public Team() { Employee = new List<Employee>(); }
 }

 public class Employee
 {
  public int Id { get; set; }
  public String LastName { get; set; }
  public string FirstName { get; set; }
  public ICollection<Team> Team { get; set; }
  public string EMail { get; set; }
  public Employee() { Team = new List<Team>(); }
 }

 public class TeamMap : ClassMap<Team>
 {
  public TeamMap()
  {
   Not.LazyLoad();
   // identity mapping
   Id(p => p.Id);
   // column mapping
   Map(p => p.Name);
   // relationship mapping
   HasManyToMany<Employee>(m => m.Employee).AsSet();
  }
 }

 public class EmployeeMap : ClassMap<Employee>
 {
  public EmployeeMap()
  {
   Not.LazyLoad();
   // identifier mapping
   Id(p => p.Id);
   // column mapping
   Map(p => p.EMail);
   Map(p => p.LastName);
   Map(p => p.FirstName);
   // relationship mapping
   HasManyToMany<Team>(m => m.Team).Inverse().AsSet();
  }
 }

 [TestFixture]
 public class Mapping
 {
  [Test]
  public void PersistDepersist()
  {
   var fcfg = Fluently.Configure()
    .Database(SQLiteConfiguration.Standard.UsingFile("testdb.sqldb"))
    .Mappings(mc =>
    {
     mc.FluentMappings.Add(typeof (TeamMap));
     mc.FluentMappings.Add(typeof (EmployeeMap));
    })
    .ExposeConfiguration(cfg => new SchemaExport(cfg).Execute(false, true, false));

   var sess = fcfg.BuildSessionFactory().OpenSession();


   var teams = Enumerable.Range(0, 4).Select(i => new Team() {Name = "Team " + i}).ToArray();
   var employees = Enumerable.Range(0, 10).Select(i => new Employee() {FirstName = "Employee " + i}).ToArray();

   teams[0].Employee = new List<Employee>() {employees[0], employees[3], employees[5]};
   teams[1].Employee = new List<Employee>() {employees[7], employees[2], employees[5]};
   teams[3].Employee = new List<Employee>() {employees[0], employees[8], employees[9]};

   foreach (var team in teams)
    foreach (var employee in team.Employee)
     employee.Team.Add(team);

   Console.WriteLine("Dumping Generated Team/Employees:");
   Dump(teams);
   Dump(employees);

   using (var t = sess.BeginTransaction())
   {
    foreach (var team in teams)
     sess.Save(team);
    foreach (var employee in employees)
     sess.Save(employee);
    t.Commit();
   }

   sess.Flush();
   sess.Clear();

   var teamsPersisted = sess.CreateCriteria(typeof (Team)).List<Team>();
   var employeesPersisted = sess.CreateCriteria(typeof (Employee)).List<Employee>();

   Assert.AreNotSame(teams, teamsPersisted);
   Assert.AreNotSame(employees, employeesPersisted);

   Console.WriteLine();
   Console.WriteLine();
   Console.WriteLine("Dumping Depersisted Team/Employees:");
   Dump(teamsPersisted);
   Dump(employeesPersisted);
  }

  private static void Dump(IEnumerable<Team> teams)
  {
   foreach (var team in teams)
    Console.WriteLine("Team: " + team.Name + " has members: " + string.Join(", ", team.Employee.Select(e => e.FirstName).ToArray()));
  }

  private static void Dump(IEnumerable<Employee> employees)
  {
   foreach (var employee in employees)
    Console.WriteLine("Employee: " + employee.FirstName + " in teams: " + string.Join(", ", employee.Team.Select(e => e.Name).ToArray()));
  }
 }