为什么要添加新项目？

Question

One teacher can have many subjects and vice versa, one subject can have many teachers. That is, here is mtm((ef > 5.0). That's exactly what I did. But when a new teacher is added, new subjects are created. How to fix this?

Before adding a teacher

• Chemistry
• PE
• Biology

Then I'm adding a new teacher

    // for example subjects = ["Biology", "Chemistry"] 

    await _db.Teachers.AddAsync(new Teacher
    {
          ...
          Subjects = subjects,
    });

After adding a teacher

• Chemistry
• PE
• Biology
• Chemistry
• Biology

Teacher model

public class Teacher : User
{
    public string Name { get; set; }
    public string Surname { get; set; }
    public IList<Subject> Subjects { get; set; }
}

User model

public class User
{
    public int Id { get; set; }
    public string Login { get; set; }
}

Subject model

public class Subject
{
    public int Id { get; set; }
    public string Name { get; set; }
    public IEnumerable<Teacher> Teachers { get; set; }
}

Answer 1

This is a common pitfall with web applications and EF when you pass entities around, or cases where you create new references to related entities and assume that EF will relate them.

If you have a collection of Subjects passed into your method something like:

public void CreateTeacher(string name, IEnumerable<Subject> subjects)
{
    var teacher = new Teacher
    {
        Name = name,
        Subjects = subjects
    };
    context.Teachers.Add(teacher);
    context.SaveChanges();
}

where the subjects list had Chemistry and Biology. It looks innocent enough, but between web request calls those Subjects coming in are just deserialized objects. They are not known to the DbContext, so when they are associated with the new Teacher they are treated as new subjects. Be default EF conventions will treat a column named Id as an Identity so this will result in two new subjects added to the Subject table with names Chemistry & Biology.

To avoid this behaviour we need to do one of two things: Associate the subjects to the DbContext (after checking to ensure they aren't already associated) or ensure we use only subjects that have been fetched by the DbContext.

Example: Fetching subjects from DbContext

public void CreateTeacher(string name, IEnumerable<Subject> subjects)
{
    var subjectIds = subjects.Select(x => x.Id).ToList();
    var dbSubjects = context.Subjects.Where(x => subjectIds.Contains(x.Id)).ToList();
    var teacher = new Teacher
    {
        Name = name,
        Subjects = dbSubjects
    };
    context.Teachers.Add(teacher);
    context.SaveChanges();
}

Typically we would re-factor the method to just pass in Subject Ids and use the DbContext to load them. No need to send all subject fields over the wire.

Example: Associating with the DbContext

public void CreateTeacher(string name, IEnumerable<Subject> subjects)
{
    var subjectIds = subjects.Select(x => x.Id).ToList();
    foreach(var subject in subjects)
    {
        if(!context.Subjects.Local.Any(x => x.Id == subject.Id)
            context.Subjects.Attach(subject);
    }
    var dbSubjects = context.Subjects.Local
        .Where(x => subjectIds.Contains(x => x.Id))
        .ToList();

    var teacher = new Teacher
    {
        Name = name,
        Subjects = dbSubjects
    };
    context.Teachers.Add(teacher);
    context.SaveChanges();
}

This assumes that all Subjects coming in are valid and reference an existing row in the database. If you can mix in new subjects then this gets a fair bit more complex. (checking subject IDs for 0 etc.) By going to context.Subjects.Local we don't hit the DB, we just check the DbContext cache for any loaded subjects before attaching the subject. Once attached it will be part of the .Local set so we can find our subjects without touching the DB.

Generally fetching the data from the DB is safer and simpler. Fetching entities by ID is quite fast and helps ensure that the data state supports the passed in references.

Answer 2

I think what Sergey is proposing is close to what is required in that I think you need to move your adding of the relationship outside of the adding of the teacher record. Just the second from last line changed from his proposal.

var teacher=new Teacher
    {
          ...
                   // don' t use this Subjects = subjects,
    });

 _db.Teachers.Add(teacher);
 teacher.Subjects = tvm.Subjects;
 await _db.Teacher.SaveChangesAsync();