Viele zu Viele Beziehung mit Fluent NHibernate

Könnten Sie code, der bewirkt, dass Ihr Fehler? Ich habe nur versucht, Ihre mappings und Sie scheinen gut zu funktionieren (auf fließend 1.0 RTM und NH 2.1.1 GA mit einer SQLite-Datenbank), mit einer geringfügigen änderung an Ihrem EmployeeMap (ich angenommen haben, dass die Mitarbeiter-team-Beziehung ist bidirektional, und als pro Dokumentation müssen Sie markieren einer Seite als inverse).

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

Natürlich, wenn die Mitarbeiter-team-Beziehung ist nicht bidirektional, ich hätte gedacht, Sie sollten in der Lage sein, zu geben eine andere .Tabelle(name) für jeden - aber ich habe nicht getestet, und Sie scheinen immer unterschiedliche Ergebnisse sowieso (daher, warum die Bereitstellung von Beispiel-code wäre am besten)

Ich würde auch hinzufügen, dass ich vermute, Satz-Semantik (anstelle Tasche) wäre besser geeignet für die Mitarbeiter.Team und das Team.Mitarbeiter-Eigenschaften. (Unabhängig davon, tun Sie nichts, meint Ordnung ist erhalten, es gibt keine Garantie, dass es sein wird)

Vorgeschlagen mapping und Beispiel:

 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()));
  }
 }