Eliminar/actualizar muchos a muchos Entity Framework. No puedo hacer que funcione

Question

Estoy usando EF4 y tengo problemas con muchas actualizaciones y eliminaciones de elementos. Estoy contento con la inserción pero la actualización y la eliminación no pueden resolverlo.

Supongamos que tengo 3 mesas y 3 clases dto que coincide

1. salón de clase Tabla

   ClassID-ClassName 
   

2. Tabla Estudiante

   StudentID-StudentName 
   

3. Tabla StudentClass

   StudentID-ClassID 
   
   
   ///Happy all works I am using existing students to populate the class. Fine. 
   private void InsertClassRoom(ClassRoomDto classRoomDto) 
   { 
       using (var ctx = new TrainingContext()) 
       { 
        //Convert dto to Entity 
        var classRoomEntity = new ClassRoom { ClassID = classRoomDto.ClassId, ClassName = classRoomDto.ClassName }; 
        foreach (var studentInClass in classRoomDto.Students) 
        { 
         Student student = ctx.Students.Where(x => x.StudentID == studentInClass.StudentId).SingleOrDefault(); 
         classRoomEntity.Students.Add(student); 
        } 
        ctx.AddToClassRooms(classRoomEntity); 
        ctx.SaveChanges(); 
       } 
   } 
   

Pero tengo 2 escenarios que no pueden imaginar qué hacer.

1. actualizar el nombre de clase
2. Añadir 1 estudiante
3. actualizar el nombre de 1 estudiante

Eliminar un estudiante de la clase.
¿Cómo lo hago?

Este es mi intento en la actualización:

private void UpdateClassRoom(ClassRoomDto classRoomDto) 
{ 
    using (var ctx = new TrainingContext()) 
    { 
     var classRoomEntity = new ClassRoom { ClassID = classRoomDto.ClassId, ClassName = classRoomDto.ClassName }; 
     foreach (var studentDto in classRoomDto.Students) 
     { 
      if (studentDto.StudentId == 0) 
      { 
       //it's a new student add it to the classroom 
       Student student = new Student { StudentID = studentDto.StudentId, StudentName = studentDto.StudentName }; 
       classRoomEntity.Students.Add(student); 
      } 
      else 
      { 
       //Alter name of the student 
       Student student = ctx.Students.Where(x => x.StudentID == studentDto.StudentId).SingleOrDefault(); 
       //update name 
       student.StudentName = studentDto.StudentName; 
       //? what do I do finish this attach or ??? 
      } 
     } 
     ctx.AddToClassRooms(classRoomEntity); 
     ctx.SaveChanges(); 
    } 
} 

public void DeleteStudent(ClassRoomDto classRoomDto) 
{ 
    using (var ctx = new TrainingContext()) 
    { 
     //lost on how to delete a student in many to many 
    } 
} 

Answer 1

En primer lugar, supongo que usted sabe que el aula ya existe en la base de datos. El enfoque más simple es consultar primero. La razón por la que realmente recibe una nueva entrada ClassRoom insertada es que usa ctx.AddToClassRooms(classRoomEntry). Esto asocia la entidad al contexto y establece EntityState en Added.

private void UpdateClassRoom(ClassRoomDto classRoomDto) 
{ 
    using (var ctx = new TrainingContext()) 
    { 
     ClassRoom classRoomEntity = ctx. 
            ClassRooms. 
            Include("Students"). 
            Single(c => c.ClassID == classRoomDto.ClassId); 
     classRoomEntity.ClassName = classRoomDto.ClassName; 

     foreach (var studentDto in classRoomDto.Students) 
     { 
      if (studentDto.StudentId == 0) 
      { 
       // it's a new student add it to the classroom 
       Student student = new Student 
             { 
              StudentID = studentDto.StudentId, 
              StudentName = studentDto.StudentName 
             }; 
       classRoomEntity.Students.Add(student); 
      } 
      else 
      { 
       // Student exists in the DB, but you don't know whether it's 
       // already part of the student collection for the classroom 
       Student student = classRoomEntity. 
            Students. 
            FirstOrDefault(s => s.StudentID == studentDto.StudentId); 

       if (student == null) 
       { 
        // this student is not in the class, fetch it from the DB 
        // and add to the classroom 
        student = ctx. 
           Students. 
           SingleOrDefault(s => s.StudentID == studentDto.StudentId) 

        classRoomEntity.Students.Add(student); 
       } 

       // Update name 
       student.StudentName = studentDto.StudentName; 
       // Since student is now part of the classroom student collection 
       // and classroom IS attached => student is also attached 
      } 
     } 

     ctx.SaveChanges(); 
    } 
} 

Con el fin de eliminar a un estudiante de clase thr, es necesario simplemente removerla de la colección (pero no lo hacen llamada ctx.DeleteObject(), ya que eliminará el estudiante de la BD. En su caso, El código anterior no se ocupará de esto, ya que solo agrega nuevos estudiantes. En lugar de hacer coincidir a todos los estudiantes que están en la base de datos, pero no en su DTO, podría tomar un enfoque más simple. Primero borre la lista y luego agregue el estudiantes:

private void UpdateClassRoom(ClassRoomDto classRoomDto) 
{ 
    using (var ctx = new TrainingContext()) 
    { 
     ClassRoom classRoomEntity = ctx. 
            ClassRooms. 
            Include("Students"). 
            Single(c => c.ClassID == classRoomDto.ClassId); 
     classRoomEntity.ClassName = classRoomDto.ClassName; 
     classRoomEntity.Students.Clear(); 

     foreach (var studentDto in classRoomDto.Students) 
     { 
      Student student; 
      if (studentDto.StudentId == 0) 
      { 
       // it's a new student add it to the classroom 
       student = new Student 
           { 
            StudentID = studentDto.StudentId, 
            StudentName = studentDto.StudentName 
           }; 
      } 
      else 
      { 
       student = ctx. 
          Students. 
          SingleOrDefault(s => s.StudentID == studentDto.StudentId) 

       // Update name 
       student.StudentName = studentDto.StudentName; 
      } 

      classRoomEntity.Students.Add(student); 
     } 

     ctx.SaveChanges(); 
    } 
} 

Este es probablemente el enfoque que estás buscando. escribió de manera ecológica el primer fragmento de código para mostrarle los diferentes casos de cómo tratar entidades nuevas y existentes, pero es el segundo enfoque (más simple) que es más correcto. Espero que esto ayude.