Entity Framework core Model

Relationships

Nangarhar University Computer Science Faculty –(NUCSF) 1401/12/03

 oultines
1. What is relationship
2. Types of Relationship
1. One-to-one relationship
2. One-to-many relationship
3. Many-to-many relationship
3. Tow types of implementation
1. Data annotation
2. Fluent API
 Relationship
✓ Relationship in asp.net core’s model classes is an association
between them.
✓ The way that modal classes interact with each other such that :
✓An instance of one entity is associated with one or more instances of
the other entity classes.
 one-to-one relationship
• An instance of one Entity is associated with just one instance of the
another Entity.
• e.g:
• We have to model classes one is employee and another is
Department.
• In our business environment every department has just on head of
the department the HOD is among the employee.
• It means the employee could head of maximum of one department
and a department must have only one head of the department.
 one-to-one relationship
The department class with navigation property.

• public class Department

• {
• public int Id { get; set; }
• public string Name { get; set; }
• public Employee Employee { get; set; }
• }
 one-to-one relationship
The Employee class with navigation property.

• public class Employee

• {
• public int Id { get; set; }
• public string Name { get; set; }
• public string Address { get; set; }
• public Department Department { get; set; }
• }
 One-to-Many Relationship
• In one-to-many Relationship one instance of an Entity is associated
with one or more instance of the another entity.
• e.g:
• we have tow modal classes customer and country.
• A country has more than one customer and a customer is belongs to
only one country.
• We can implement the above relationship tow ways one is data
annotation and another way is fluent api.
• Let’s first implement this with the simple way this is data annotation.
 One-to-Many Relationship
with data annotation
• Tow modal classes are:
 cont…
• Note:
• If the primary key filed of a model class Id or (modelnameId) then the
migration by convention create the primary key for table otherwise it
can not map.
• E.g: there is a model class named customer if the key property a
customer class is (Id) or (CustomerId) the migration has now problem
• if we went to name primary key for customer other than (Id) or
(customerId).
• In this case [key] data annotation must be used above the property.
• [Key]
• public int customer_Id { get; set; }
 cont…
• To implement one to many relationship with data annotion Just do
the following change to customer and country classes.
 cont…
• If the primary key property dose not follow the convention then do
the following in customer class for foreign key with the name of your
choice.
 Many-to-Many Relationship
• For implementing many-to-many binary relationship we need three
model classes.
• Tow ot them are the associated classes and the third one is the joined
or intermediate classes for making many to many association.
• E.g:
• We have tow tables Course and Student.
• In this scenario a student take one or more than one courses and also
a course has one or more than one students.
 Many-to-Many Relationship

Student Class

public class Student

{
public int Id { get; set; }

public string Name { get; set; }

public string Address { get; set; }
}
 Many-to-Many Relationship

Course Class

public class Course

{
[Key]
public int Id { get; set; }
public string Name { get; set; }
public string Description { get; set; }
public string Author { get; set; }
public string Gender { get; set; }
}
 Many-to-Many Relationship
• After we implement the many to many relationship the following
changes must be made in both classes.

public class Course

{
[Key]
public int Id { get; set; }
public string Name { get; set; }
public string Description { get; set; }
public string Author { get; set; }
public string Gender { get; set; }

public ICollection<StudentCourse> StudentCourses { get; set;

}

}
 Many-to-Many Relationship
• After we implement the many to many relationship the following
changes must be made in both classes.

public class Student

{
public int Id { get; set; }

public string Name { get; set; }

public string Address { get; set; }

public ICollection<StudentCourse> StudentCourses { get; set; }

}
 Many-to-Many Relationship
• Now the time is for adding the bridge entity class.
• The intermediate class name is StudentCourse.
• With following properties.
public class StudentCourse
{
[ForeignKey("Student")]
public int StudentId { get; set; }
[ForeignKey("Course")]
public int CourseId { get; set; }
public Student Student { get; set; }
public Course Course { get; set; }
}
 Many-to-Many Relationship
• As the StudentCourse class primary key may be the combination of
the tow fileds which are studentId and CourseId.
• The data annotation dose not have any method for composite key so
for this purpose we should use the fluent api to configure composite
key for this model class.

• protected override void OnModelCreating(ModelBuilder modelBuilder)

• {
• modelBuilder.Entity<StudentCourse>()
• .HasKey(sc=> new {sc.StudentId, sc.CourseId });
• }
 Relationship Via Fluent API
➢Fluent API is an advanced way of doing model configuration.
➢Fluent API can do all things which can be done by data annotation.
➢Fluent API can do some advanced configuration which is not possible by
data annotation to be done.
➢The Fluent API Model configuration is done by overriding
OnModelCreating() method of the DbContext class.
➢Code first prefer fluent API over data annotation.
// Method in DBContext Classs.
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
// Fluent API configuration goes here.
}
 Fluent API one-to-one relationship
•
• modelBuilder.Entity<Department>()
• .HasOne(d => d.Employee)
• .WithOne(e => e.Department)
• .HasForeignKey<Department>(x =>
x.EmployeeId);
 Fluent API one-to-many relationship

•
• modelBuilder.Entity<Customer>()
• .HasOne(f => f.Country)
• .WithMany(f => f.Customers)
• .HasForeignKey(f => f.MyID);
 Fluent API many-to-many relationship
• modelBuilder.Entity<StudentCourse>()
• .HasKey(k => new { k.StudentId, k.CourseId });

• modelBuilder.Entity<StudentCourse>()
• .HasOne(s => s.Student)
• .WithMany(sc => sc.StudentCourses)
• .HasForeignKey(sf => sf.StudentId);

• modelBuilder.Entity<StudentCourse>()
• .HasOne(c => c.Course)
• .WithMany(sc => sc.StudentCourses)
• .HasForeignKey(cf => cf.CourseId);
 Fluent API Organization
• public class CustomerConfiguration : IEntityTypeConfiguration<Customer>
• {
• public void Configure(EntityTypeBuilder<Customer> builder)
• {
• builder.HasKey(c => c.Id);
• }
• }

• modelBuilder.ApplyConfiguration(new CustomerConfiguration());
Its your turn to ask about today’s lecture