一个实体的多个外键

Question

I am developing a system that volunteers can apply to be a part of ceremonies/appointments for a church.

I want to have it so multiple volunteers can be part of a ceremony, might be 1 or could be 4. I've seen various examples on SO that use just two foreign keys but I just can't wrap my head around more than two. I know I need inverse property but I'm just confused.

Here's the two entities I need. I think I need to have Appointment/Ceremony in the volunteer as an ICollection. I may be way off, I'm not too sure.

public class Volunteer
{
    [Key]
    public int VolunteerId { get; set; }

    public string Name { get; set; }

    public string Email { get; set; }

    public bool GardaVetted { get; set; }

    public string VolunteerRole { get; set; }

    public string VolunteerPhoneNumber { get; set; }

    [ForeignKey("Church")]
    public int ChurchId { get; set; }

    [ForeignKey("Appointments")]
    public int AppointmentId { get; set; }

    //Foreign Key
    public virtual Church Church { get; set; }

    public virtual ICollection<Appointments> Appointments { get; set; }

}

public class Appointments
{
    [Key]
    public int AppointmentId { get; set; }

    public string DetailsOfAppointment { get; set; }

    public int? Fee { get; set; }

    public string RoomType { get; set; }

    public string NameOfApplicant { get; set; }

    public string ApplicantPhoneNumber { get; set; }

    public string ApplicantEmail { get; set; }

    [DataType(DataType.DateTime)]
    [DisplayFormat(ApplyFormatInEditMode = true,DataFormatString = "{0:dd/MM/yyyy HH:mm}")]
    public DateTime DateOfAppointment { get; set; }

    public string ThemeColour { get; set; }

    public Boolean Confirmed { get; set; }

    [ForeignKey("Admins")]
    public int AdministrationId { get; set; }

    [ForeignKey("Church")]
    public int ChurchId { get; set; }

    //[ForeignKey("Volunteers")]
    //public int VolunteerId { get; set; }

    public virtual Church Church { get; set; }

    public virtual Administration Admins { get; set; }

    //public virtual Volunteer Volunteers { get; set; }
}

Answer 1

As far I understand from your question is that, you want a one to many relationship from Appointments to Volunteer.

Just put a ICollection navigation property of Volunteers in the Appointments model. Which will be considered as one to many relation. Like one Appointment can be eligible for multiple/many volunteers

class Volunteer
{
  //properties
}

class Appointments
{
  //other properties
  //....
  //. . .
  //Navigation property/foreign key for Volunteers(one-many)1 appointments=many volunteers
  ICollection<Volunteer> Volunteers {get;set;}
}

Answer 2

You mention a Ceremony which is later not mentioned again. I assume a Ceremony is what you call an Appointment elsewhere.

This is what I read from your classes, and what I think you have defined correctly.

You seem to have a collection of Churches. Every Church has zero or more Volunteers and every Volunteer belongs to exactly one Church. This is called a one-to-many relationship

Every Volunteer can have zero or more Appointments.

Unclear: - does an Appointment belong to only one Volunteer, or can several Volunteers attend the same Appointment? - Is the applicant a Volunteer? In that case: don't copy Volunteer properties to an Applicant - Do all Volunteers that attend a meeting belong to the same Church, or can the attendants from a meeting belong to different Churches?

It seems to me more logical that people from different Churches might attend the same meeting. That means that every Volunteer can attend zero or more meetings (Appointments), and every meeting is attended by zero or more Volunteers, possibly from different Churches: this is a true many-to-many relationship.

Apparently there is also a relation between Churches and Appointments. It is unclear whether this is the Church who hosts the appointment, or whether this is the location of the Appointment. Anyway, let's assume that every Church hosts zero or more Appointments and every Appointment is held at exactly one Church

If you'd follow the entity framework code first conventions, the following would be enough:

class Church
{
    public int Id {get; set;}

    // every Church has zero or more Volunteers:
    public virtual ICollection<Volunteer> Volunteers {get; set;}

    // every Church hosts zero or more Appointments:
    public virtual ICollection <Appointment> Appointments {get; set;}

    ... // other Church properties
}

class Volunteer
{
    public int Id {get; set;}

    // every Volunteer belongs to exactly one Church using foreign key
    public int ChurchId {get; set;}
    public virtual Church Church {get; set;}

    // every Volunteer has zero or more Appointments:
    public virtual ICollection<Appointment> Appointments {get; set;}

    ... // other Properties
}

class Appointment
{
    public int Id {get; set;}

    // every Appointment is attended by one or more Volunteers (many-to-many)
    public virtual ICollection<Volunteer> Volunteers {get; set;}

    // every Appointment is hosted by exactly one Church using foreign key
    public int ChurchId {get; set;}
    public virtual Church Church {get; set;}

    ... // other properties
}

class MyDbContext : DbContext
{
    public DbSet<Church> Churches {get; set;}
    public DbSet<Volunteer> Volunteers {get; set;}
    public DbSet<Appointment> Appointments {get; set;}
}

Because I followed the entity framework conventions, this is all entity framework needs to know to understand that I planned a one-to-many between Church and Volunteers and a many-to-many between Volunteers and Appointments. Entity Framework will recognize the primary and foreign keys, and will even create the junction table for your many-to-many relationship . There is no need for attributes nor fluent API. Only if you want different table names or column names you'll need attributes or fluent api.

Usage:

Give me all Appointments for Volunteer "John" that are held in St Bartholomew Church:

var appointmentsofJohnInStBarth = dbContext.Appointments
    .Where(appointment => Appointment.Volunteer.Name = "John"
          && appointment.Church.Name = "Saint Bartholomew")
    .Select(appointment => new
    {
        StartTime = appointment.StartTime,
        EndTime = appointment.EndTime,

        Description = appointment.Description,
        Attendants = appointment.Volunteers
            .Select(volunteer => new
            {
                Name = volunteer.Name,
                Function = volunteer.Function,
                Email = volunteer.Email,
                ...
             })
             .ToList(),
    });

Because your DbContext knows about the relations between the Volunteers / Churches / Appointments, the DbContext knows when to perform a GroupJoin for the one-to-many or a join on the JunctionTable for the many-to-many relationships, without you having to specify which joins must be performed.