使用Fluent API的Entity Framework 6代码优先关系

Question

I have 3 related tables in an existing database. Many-to-Many (Many Person Many Group) and a table between - Event, witch ralate these two tables.

public class Person
    {
        public int PersonID { get; set; }
        public string No { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public virtual ICollection<Event> Events { get; set; }
    }
   public class Event
    {
        public int EventID { get; set; }
        public string EventData { get; set; }
        public int PersonID { get; set; }
        public int GroupID { get; set; }
        public virtual Person Person { get; set; }
        public virtual Group Group { get; set; }
   }

   public class Group
    {
        public int GroupID { get; set; }
        public string GroupName { get; set; }
        public virtual ICollection<Event> PersonGroup { get; set; }
    }

I ddescribed relations using Fluent API. First I declared PK's

modelBuilder.Entity<Person>()
.HasKey(k => k.PersonID });

modelBuilder.Entity<Event>()
.HasKey(k => k.EventID);

modelBuilder.Entity<Group>()
.HasKey(k => k.GroupID });

Now foreign keys: Person has many Events

modelBuilder.Entity<Person>()
.HasKey(k => k.PersonID })
.HasMany(k => k.Events)
.WithRequired()
.HasForeignKey(f => f.PersonID);

In Event class I have Person (and all its parameters)

modelBuilder.Entity<Event>()
.HasRequired(s => s.Person)
.WithMany()
.HasForeignKey(fk => fk.PersonID);

Also I need a Group with all data:

modelBuilder.Entity<Event>()
.HasOptional(s => s.Group)
.WithMany()
.HasForeignKey(fk => fk.GroupID });

At least I need a Person group participating in an Event

modelBuilder.Entity<Group>()
.HasKey(k =>k.GroupID })
.HasMany(k => k.PersonGroup)
.WithOptional()
.HasForeignKey(fk => fk.GroupID);

It seems I have everything I need, but I need one mo collection (Group of persons with their names)

What I get through PersonGroup relation I have all events but also need to get Persons. Could You help?

Answer 1

Edit

I just realize it's not a typical many-to-many, since your Event-Group relation is optional. Is this intended?

Maybe your model should be changed to reflect a more natural event structure:

Group-Person: many-to-many

Event-Group: many-to-many

Event-Person: no direct relation, only via groups; alternative many-to-many

The way your model is currently designed, a single event entry can't be related to more than one group and one person and a person can't be part of a group unless they are associated in the context of an event entry.

---

Basically, the thing you ask for is not directly available, because you decided to explicitely create the many-to-many table with additional properties.

However, in queries you can always write a select to get the persons collection

db.Groups.Select(g => new {Group = g, PeopleInGroup = g.PersonGroup.Select(ev => ev.Person)})

Few side-notes regarding your model:

• Consider removing EventID and instead use modelBuilder.Entity<Event>().HasKey(k => new { k.PersonID, k.GroupID }) , like a typical many-to-many table would be designed.
• Mention reverse properties in fluent api:

.

modelBuilder.Entity<Person>()
.HasKey(k => k.PersonID })
.HasMany(k => k.Events)
.WithRequired(e => e.Person)
.HasForeignKey(f => f.PersonID);

// redundant with the previous configuration
modelBuilder.Entity<Event>()
.HasRequired(s => s.Person)
.WithMany(p => p.Events)
.HasForeignKey(fk => fk.PersonID);

// same to be done for groups

In order to have a convenient access to the associated people of a group, you could create a not-mapped property getter which wraps the necessary query:

public class Group
{
    public int GroupID { get; set; }
    public string GroupName { get; set; }
    public virtual ICollection<Event> PersonGroup { get; set; }

    [NotMapped]
    public IEnumerable<Person> PersonsInGroupEvents
    {
        return PersonGroup.Select(ev => ev.Person);
    }
}

// or fluent api way of NotMapped:
modelBuilder.Entity<Group>()
    .Ignore(x => x.PersonsInGroupEvents);