Entitäten: Team <-> TeamEmployee <-> Employee

Bedarf:

Ein Team und ein Mitarbeiter können ohne ihr Gegenstück existieren.In der Team-TeamEmployee-Beziehung ist das Team verantwortlich (Eltern) [mit einem späteren TeamRepository].In der Mitarbeiter-Team-Mitarbeiter-Beziehung ist der Mitarbeiter verantwortlich (übergeordnet) [mit einem späteren EmployeeRepository].Duplikate sind nicht erlaubt.Durch das Löschen eines Teams werden alle Mitarbeiter im Team gelöscht, wenn der Mitarbeiter keinem anderen Team angehört.Durch das Löschen eines Mitarbeiters wird nur ein Team gelöscht, wenn das Team keine weiteren Mitarbeiter enthält.

Kartierung:

public class TeamMap : ClassMap<Team>
{
    public TeamMap()
    {
        // identity mapping
        Id(p => p.Id)
            .Column("TeamID")
            .GeneratedBy.Identity();

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

        // associations
        HasMany(p => p.TeamEmployees)
            .KeyColumn("TeamID")
            .Inverse()
            .Cascade.SaveUpdate()
            .AsSet()
            .LazyLoad();
    }
}

public class EmployeeMap : ClassMap<Employee>
{
    public EmployeeMap()
    {
        // identifier mapping
        Id(p => p.Id)
            .Column("EmployeeID")
            .GeneratedBy.Identity();

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

        // associations
        HasMany(p => p.TeamEmployees)
            .Inverse()
            .Cascade.SaveUpdate()
            .KeyColumn("EmployeeID")
            .AsSet()
            .LazyLoad();

        HasMany(p => p.LoanedItems)
            .Cascade.SaveUpdate()
            .LazyLoad()
            .KeyColumn("EmployeeID");
    }
}

public class TeamEmployeeMap : ClassMap<TeamEmployee>
{
    public TeamEmployeeMap()
    {
        Id(p => p.Id);

        References(p => p.Employee)
            .Column("EmployeeID")
            .LazyLoad();

        References(p => p.Team)
            .Column("TeamID")
            .LazyLoad();
    }
}

Mitarbeiter und Teams erstellen:

    var employee1 = new Employee { EMail = "Mail", FirstName = "Firstname", LastName = "Lastname" };
    var team1 = new Team { Name = "Team1" };
    var team2 = new Team { Name = "Team2" };

    employee1.AddTeam(team1);
    employee1.AddTeam(team2);


    var employee2 = new Employee { EMail = "Mail2", FirstName = "Firstname2", LastName = "Lastname2" };
    var team3 = new Team { Name = "Team3" };

    employee2.AddTeam(team3);
    employee2.AddTeam(team1);

    team1.AddEmployee(employee1);
    team1.AddEmployee(employee2);
    team2.AddEmployee(employee1);
    team3.AddEmployee(employee2);

    session.SaveOrUpdate(team1);
    session.SaveOrUpdate(team2);
    session.SaveOrUpdate(team3);

    session.SaveOrUpdate(employee1);
    session.SaveOrUpdate(employee2);

Danach übergebe ich die Änderungen mit transaction.Commit (). Das erste seltsame ist, dass ich Teams und Mitarbeiter retten muss, stattdessen nur einen von ihnen (warum ?!). Wenn ich nur alle Teams oder (Xoder) alle Mitarbeiter speichere, bekomme ich eineTransientObjectException:

"Objekt verweist auf eine nicht gespeicherte transiente Instanz - speichern Sie die transiente Instanz vor dem Leeren. Geben Sie Folgendes ein: Core.Domain.Model.Employee, Entity: Core.Domain.Model.Employee"

Wenn ich alle erstellten Teams und Mitarbeiter speichere, ist alles in Ordnung, ABER die Beziehungstabelle TeamEmployeedoppelte Assoziationen.

ID EID TID
1  1   1
2  2   1
3  1   2
4  2   3
5  1   1
6  1   2
7  2   3
8  2   1

Anstelle von 4 Relationen gibt es also 8 Relationen. 4 Relationen für die linke Seite und 4 Relationen für die rechte Seite. : [

Was mache ich falsch?

Weitere Fragen: Muss ich beim Löschen eines Teams oder eines Mitarbeiters das Team oder den Mitarbeiter aus der TeamEmployee-Liste im Objektmodell entfernen oder erledigt NHibernate den Job für mich (mit session.delete (..))?