Aktualisieren der Datenbank mit Entity Framework, Vergleichen von Methoden

Question

Ich denke, das sind im Wesentlichen die gleiche Methode, aber die erste fragt die db zuerst ab, so hat weniger Leistung aufgrund der zweimal die db treffen. Ich werde höchstens 40 Benutzer haben, so dass die Leistung nicht zu groß ist. Gibt es noch einen anderen Grund, einen über den anderen zu benutzen?

greifen die Einheit aus der db zuerst, ändern sie dann speichern:

public void UpdateStudent(StudentModel model) 
    { 
     using (var _db = new AppEntities()) 
     { 
      Student student = new Student(); 

      student = _db.Student.Find(model.studentId); 

      student.FirstName = model.FirstName; 
      student.LastName = model.LastName; 
      student.DOB = model.DOB; 
      student.GradeId = model.GradeId; 

      _db.Entry(student).State = System.Data.Entity.EntityState.Modified; 
      _db.SaveChanges(); 
     } 
    } 

Ändern Sie die Einheit und lassen EF es in der DB und Update finden:

public void UpdateStudent(StudentModel model) 
    { 
     using (var _db = new AppEntities()) 
     { 
      Student student = new Student() 
      { 
       student.StudentId = model.StudentId, 
       student.FirstName = model.FirstName, 
       student.LastName = model.LastName, 
       student.DOB = model.DOB, 
       student.GradeId = model.GradeId 
      }; 

      _db.Entry(student).State = System.Data.Entity.EntityState.Modified; 
      _db.SaveChanges(); 
     } 
    } 

Answer 1

Im ersten Code-Schnipsel Sie nehmen eine Version der Entitätsform db. Wenn ein anderer Thread oder Prozess dieselbe Entität ändert, glaube ich nicht, dass EF eine Aktualisierung zulassen würde, da sich Ihre Basisversion der Entität von der in DB vor einer Aktualisierungsabfrage unterscheidet.

Im zweiten Fall, wenn ein Thread oder Prozess diese Entität ändert, während Sie diese Anfrage bearbeiten, könnten Sie diese Änderung wahrscheinlich verlieren.

EDIT: Ich habe das nie müde. Ich erhalte immer die Entität und ändere und speichere sie, aber du könntest einen Test schreiben, um zu überprüfen, was passiert.

Answer 2

In Ihrem ersten Snippet müssen Sie die Entität nicht als Modified markieren, da der Change Tracker dafür sorgt. Dies ist wichtig zu beachten, da es auch den Unterschied zwischen den beiden Methoden definiert. Ich erkläre es.

Nehmen wir an, dass von allen Zuweisungen (student.FirstName = model.FirstName; etc.) nur die erste eine echte Änderung ist. Wenn ja -

• Das erste Code-Fragment (aber ohne Kennzeichnung die Einheit als Modified) löst eine Update-Anweisung, dass nur Updates FirstName.
• Das zweite Codefragment aktualisiert immer alle Felder in Student. Diese

bedeutet, dass das erste Fragment ist weniger wahrscheinlich, dass Gleichzeitigkeit Konflikte verursachen (jemand anderes kann LastName in der Zwischenzeit ändern und Sie nicht überschreiben diese Änderung durch veraltete Daten, wie in dem zweiten Szenario passiert).

es ist also über feinkörnige Änderungen im Vergleich zu einem umfassenden Update, Rundreisen vs. Redundanz:

• das erste Szenario nimmt aber mehr Rundreisen Concurrency-sicher ist.
• Das zweite Szenario nimmt keine Roundtrips, ist aber weniger nebenläufigkeitssicher.

Es liegt an Ihnen, die Kompromisse auszugleichen.

diese Wahl schwieriger etwas zu machen, gibt es eine dritte Option:

public void UpdateStudent(StudentModel model) 
{ 
    using (var _db = new AppEntities()) 
    { 
     Student student = new Student() 
     { 
      student.StudentId = model.StudentId, 
      student.FirstName = model.FirstName, 
      student.LastName = model.LastName, 
      student.DOB = model.DOB, 
      student.GradeId = model.GradeId 
     }; 
     _db.Students.Attach(student); 

     _db.Entry(student).Property(s => s.FirstName).IsModified = true; 
     _db.Entry(student).Property(s => s.LastName).IsModified = true; 
     _db.Entry(student).Property(s => s.DOB).IsModified = true; 
     _db.Entry(student).Property(s => s.GradeId).IsModified = true; 
     _db.SaveChanges(); 
    } 
} 

Keine Folgendes zu bieten und jetzt markieren Sie nur 4 Eigenschaften modifiziert. Sie aktualisieren also immer noch zu viele Eigenschaften, wenn nur eine tatsächlich geändert wurde, aber vier sind besser als alle.

Und es gibt mehr zu dieser Frage "Rondtrips vs Redundanz", aber ich erklärte, dass elswhere.