We Keep Coding

How to define common property for two different entities in EF core?

I have two entities Student and course as below
public class Student
{
public int Id { get; set; }
public string Name { get; set; }
[System.Text.Json.Serialization.JsonIgnore]
public virtual IList<Course> Courses { get; set; }
}
public class Course
{
public int Id { get; set; }
public string Name { get; set; }
public virtual IList<Student> Students { get; set; }
[ForeignKey(nameof(TeacherId))]
public int TeacherId {get;set;}
public Teacher Teacher { get; set; }
}
Now I want to add list of grades to two entities containing grade and id of the course or Student depending on the situation. Do I have to define a entity grade with studentId and CourseId or is there any other way to do it without creating entity

What you describe is a m:n-relationship between Course and Student with the extra information of the grade that was awarded for the participation. By creating the two navigation properties Student.Courses and Course.Students you have already created an implicit crosstab between the entities. In order to add the grade, I'd propose to create a dedicated entity, e.g. CourseParticipation that defines the relationship between Course and Student and also carries the extra information (up to now, the grade, later maybe more):
public class CourseParticipation
{
public int Id { get; set; }
public int CourseId { get; set; }
public Course Course { get; set; }
public int StudentId { get; set; }
public Student Student { get; set; }
public int Grade { get; set; }
}
public class Student
{
public int Id { get; set; }
public string Name { get; set; }
[System.Text.Json.Serialization.JsonIgnore]
public virtual IList<CourseParticipation> Courses { get; set; }
}
public class Course
{
public int Id { get; set; }
public string Name { get; set; }
public virtual IList<CourseParticipation> Participants { get; set; }
[ForeignKey(nameof(TeacherId))]
public int TeacherId {get;set;}
public Teacher Teacher { get; set; }
}
This way, you make the relationship explicit and are prepared for later additions to the relationship.

Remove() with many-to-many relationship doesn't work

Let's say I have two tables with a many-to-many relationship that generated with database first in edmx type:
public class Teacher
{
public int TeacherId { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public virtual ICollection<Cours> Courses { get; set; }
}
public class Course
{
public int CourseId { get; set; }
public string CourseName { get; set; }
public byte QtySession { get; set; }
public virtual ICollection<Teacher> Teachers { get; set; }
}
TeacherCourse
{
[key]
public int CourseId { get; set; }
[key]
public int TeacherId { get; set; }
}
//this is many to many relationship table But not generated with edmx
In following code I am trying to remove the one of row in TeacherCourse table. But the result is not correct(not any actions).
SabaEntities sabaEntities = new SabaEntities();
var teacher = sabaEntities.Teachers.FirstOrDefault(x => x.TeacherId == teacherId);
sabaEntities.Courses.FirstOrDefault(x => x.CourseId == courseId).Teachers.Remove(teacher);
sabaEntities.SaveChanges()
This code running without any error, but the result not corrected, because not remove row mentioned in TeacherCourse.
How can I solve it?

what's the best solution for Many to Many Relation in .Net Core(EF Core)? [duplicate]

This question already has an answer here:
Entity Framework Core many-to-many navigation issues
(1 answer)
Closed 2 years ago.
as you know we don't have automatic Many to Many Relations between Entities in EF Core. whats the best solution to achieve that?
here what I create for do that:
class Student
{
public int StudentId { get; set; }
public string Name { get; set; }
public string Family { get; set; }
public List<StudentCourse> Courses { get; set; }
}
class Course
{
public int CourseId { get; set; }
public string Name { get; set; }
public List<Student> Students { get; set; }
}
class StudentCourse
{
public int StudentCourseId { get; set; }
public Student Student { get; set; }
public Course Course { get; set; }
}

In your example you're doing it correctly, but I would say that Course entity should also have a List<StudentCourse> rather than List<Student to keep it consistent. Also add flat CourseId to the StudentCourse entity to control the foreign key in mapping configuration.
Using a join table is a common practice, and lack of the "automatic" many-to-many relations in EF Core forces you to define those mappings manually.
Personally I like that there is no automatic way in EF Core, because it gives more control and tidiness of table structure (like naming of the join table, forcing composite primary key etc.)
public void Configure(EntityTypeBuilder<StudentCourse> builder)
{
builder.ToTable("StudentCourses");
builder.HasKey(sc => new { sc.StudentId, sc.CourseId });
builder.HasOne(sc => sc.Student)
.WithMany(s => s.StudentCourses)
.HasForeignKey(sc => sc.StudentId);
builder.HasOne(sc => sc.Course)
.WithMany(c => c.StudentCourses)
.HasForeignKey(sc => sc.CourseId);
}
public class Student
{
public int StudentId { get; set; }
public List<StudentCourse> StudentCourses { get; set; }
}
public class Course
{
public int CourseId { get; set; }
public List<StudentCourse> StudentCourses { get; set; }
}
public class StudentCourse
{
public int StudentId { get; set; }
public Student Student { get; set; }
public int CourseId { get; set; }
public Course Course { get; set; }
}

Entity Framework Code First navigation property through relational table

I'm trying to setup some navigation properties with some Entity Framework Code First models. I'd like them to look like this example:
public class Course
{
[Key]
public int CourseId { get; set; }
public string CourseName { get; set; }
public virtual ICollection<Student> Students { get; set; }
}
public class Student
{
[Key]
public int StudentId { get; set; }
public string StudentName { get; set; }
public virtual ICollection<Course> Courses { get; set; }
}
public class StudentCourses
{
[Key, Column(Order = 0)]
public int StudentId { get; set; }
public virtual Student Student { get; set; }
[Key, Column(Order = 1)]
public int CourseId { get; set; }
public virtual Course Course { get; set; }
}
So Student and Course relationships would be established in the StudentCourses table. An instance of the student class would automatically reference all of that students courses, and vice versa an instance of the Course class would automatically reference all of its Students. And an instance of the StudentCourses class would automatically reference its Student and Course. But when I try to Update-Database, the relationships don't seem to get properly interpreted. Is there anything I'm missing here? Perhaps some configuring needs to be done in the context class? Most of the examples of navigation properties just show one-to-many relationship navigation properties.

You need to construct your models as shown below when you have a M : M relationship. You don't need to construct junction table. EF will create one for you when you do the data migration.
Model configuration using Conventions.
public class Student
{
public Student()
{
this.Courses = new HashSet<Course>();
}
public int StudentId { get; set; }
public string StudentName { get; set; }
public virtual ICollection<Course> Courses { get; set; }
}
public class Course
{
public Course()
{
this.Students = new HashSet<Student>();
}
public int CourseId { get; set; }
public string CourseName { get; set; }
public virtual ICollection<Student> Students { get; set; }
}
Your context class should be like this.
public class YourDBContext : DBContext
{
public YourDBContext () : base("Default")
{
}
public DbSet<Student> Students { get; set; }
public DbSet<Course> Courses { get; set; }
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
}
}

After following Sampath's advice, I actually decided I wanted to attach some other properties to the relationship. So I ended up defining the StudentCourses class afterall like this:
public class StudentCourses
{
[Key, Column(Order = 0)]
public int StudentId { get; set; }
public virtual Student Student { get; set; }
[Key, Column(Order = 1)]
public int CourseId { get; set; }
public virtual Course Course { get; set; }
public int Grade { get; set; }
}
So I changed Student and Course like this:
public class Course
{
[Key]
public int CourseId { get; set; }
public string CourseName { get; set; }
public virtual ICollection<StudentCourses> Students { get; set; }
}
public class Student
{
[Key]
public int StudentId { get; set; }
public string StudentName { get; set; }
public virtual ICollection<StudentCourses> Courses { get; set; }
}
And most importantly, I did not add StudentCourses to the DbContext. So after Update-Database was performed, EF automatically created the table for StudentCourses, and the navigation properties all work.

Most efficient way for LINQ query on InverseProperty in AutoMapper

Assuming I've the following Entity Framework Code-First models:
public class Employee {
[Key]
public int Id { get; set; }
public int DepartmentId { get; set; }
[ForeignKey(nameof(DepartmentId ))]
public Department Department { get; set; }
public DateTime EntryDate { get; set; }
}
public class Manager {
[Key]
public int Id { get; set; }
public int DepartmentId { get; set; }
[ForeignKey(nameof(DepartmentId ))]
public Department Department { get; set; }
}
public class Department {
[Key]
public int Id { get; set; }
[InverseProperty(nameof(Employee.Department))]
public virtual ICollection<Employee> Employees { get; set; }
[InverseProperty(nameof(Manager.Department))]
public virtual ICollection<Manager> Managers { get; set; }
}
And the following DTO object:
public class MyDto {
public int ManagerId { get; set; }
public Employee NewestEmployee { get; set; }
}
I want to use AutoMapper to convert a list of managers to a list of DTO objects. AutoMapper configuration is like this:
CreateMap<Manager, MyDto>()
.ForMember(
m => m.NewestEmployee,
opt => opt.MapFrom(
manager =>
manager.Department.Employees.OrderBy(employee => employee.EntryDate).FirstOrDefault()))
And called like this:
IEnumerable<Manager> managers = GetAllManagers();
var data = Mapper.Map<IEnumerable<MyDto>>(managers);
While this works it makes individual SQL statement requests for each manager to the employee table. Is there a way to improve performance by having only one SQL query executed (either by changing something in the Entity Framework models or AutoMapper configuration)?