Entity Framework - Persistenz

Mit Entity Framework können Sie jetzt vom Entity Framework profitieren, ohne dass jeder Teil Ihrer Anwendung das Entity Framework kennen muss, wodurch Entitäten von der Infrastruktur getrennt werden. Sie können Klassen erstellen, die sich auf ihre Geschäftsregeln konzentrieren können, unabhängig davon, wie sie beibehalten werden (wo die Daten gespeichert werden und wie die Daten zwischen Ihren Objekten hin und her gelangen).

Persistente ignorante Entitäten erstellen

Im vorhergehenden Absatz wurde eine Methode beschrieben, die die Quelle der verbrauchten Daten nicht genau kennt. Dies unterstreicht die Essenz der Persistenz-Ignoranz, wenn es Ihren Klassen und vielen unserer Anwendungsebenen um sie herum egal ist, wie die Daten gespeichert werden.

Wenn Sie in der .NET 3.5-Version von Entity Framework bereits vorhandene Klassen verwenden möchten, müssen Sie diese ändern, indem Sie sie zwingen, von EntityObject abzuleiten.
In .NET 4 ist dies nicht mehr erforderlich. Sie müssen Ihre Entitäten nicht ändern, damit sie an Entity Framework-Vorgängen teilnehmen können.
Auf diese Weise können wir Anwendungen erstellen, die eine lose Kopplung und Trennung von Bedenken umfassen.
Mit diesen Codierungsmustern befassen sich Ihre Klassen nur mit ihren eigenen Jobs, und viele Ebenen Ihrer Anwendung, einschließlich der Benutzeroberfläche, sind nicht von externer Logik abhängig, z. B. die Entity Framework-APIs. Diese externen APIs können jedoch mit unseren interagieren Entitäten.

Es gibt zwei Möglichkeiten (verbunden und getrennt), wenn eine Entität mit dem Entity Framework beibehalten wird. Beide Wege haben ihre eigene Bedeutung. Im Fall eines verbundenen Szenarios werden die Änderungen vom Kontext verfolgt. Im Fall eines nicht verbundenen Szenarios müssen wir den Kontext über den Status der Entität informieren.

Verbundene Szenarien

Verbundenes Szenario ist, wenn eine Entität aus der Datenbank abgerufen und im selben Kontext geändert wird. Nehmen wir für ein verbundenes Szenario an, wir haben einen Windows-Dienst und führen einige Geschäftsvorgänge mit dieser Entität aus, sodass wir den Kontext öffnen, alle Entitäten durchlaufen, unsere Geschäftsvorgänge ausführen und die Änderungen dann im selben Kontext wie wir speichern am Anfang geöffnet.

Schauen wir uns das folgende Beispiel an, in dem Schüler aus der Datenbank abgerufen werden, den Vornamen der Schüler aktualisieren und dann die Änderungen in der Datenbank speichern.

class Program {

   static void Main(string[] args) {

      using (var context = new MyContext()) {

         var studentList = context.Students.ToList();

         foreach (var stdnt in studentList) {
            stdnt.FirstMidName = "Edited " + stdnt.FirstMidName;
         }

         context.SaveChanges();

         //// Display all Students from the database

         var students = (from s in context.Students
            orderby s.FirstMidName select s).ToList<Student>();

         Console.WriteLine("Retrieve all Students from the database:");

         foreach (var stdnt in students) {
            string name = stdnt.FirstMidName + " " + stdnt.LastName;
            Console.WriteLine("ID: {0}, Name: {1}", stdnt.ID, name);
         }

         Console.ReadKey();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erhalten Sie die folgende Ausgabe und sehen, dass das bearbeitete Wort vor dem Vornamen angehängt ist, wie in der folgenden Ausgabe gezeigt.

Retrieve all Students from the database: 
ID: 1, Name: Edited Edited Alain Bomer 
ID: 2, Name: Edited Edited Mark Upston

Getrennte Szenarien

Ein nicht verbundenes Szenario ist, wenn eine Entität aus der Datenbank abgerufen und in einem anderen Kontext geändert wird. Angenommen, wir möchten einige Daten in einer Präsentationsschicht anzeigen und verwenden eine n-Tier-Anwendung. Daher ist es besser, den Kontext zu öffnen, die Daten abzurufen und schließlich den Kontext zu schließen. Da wir hier die Daten abgerufen und den Kontext geschlossen haben, werden die von uns abgerufenen Entitäten nicht mehr verfolgt, und dies ist das nicht verbundene Szenario.

Schauen wir uns den folgenden Code an, in dem eine neue getrennte Student-Entität mithilfe der Add-Methode zu einem Kontext hinzugefügt wird.

class Program {

   static void Main(string[] args) {

      var student = new Student {
         ID = 1001, 
         FirstMidName = "Wasim", 
         LastName = "Akram", 
         EnrollmentDate = DateTime.Parse( DateTime.Today.ToString())
      };

      using (var context = new MyContext()) {

         context.Students.Add(student);
         context.SaveChanges();

         //// Display all Students from the database

         var students = (from s in context.Students 
            orderby s.FirstMidName select s).ToList<Student>();

         Console.WriteLine("Retrieve all Students from the database:");

         foreach (var stdnt in students) {
            string name = stdnt.FirstMidName + " " + stdnt.LastName;
            Console.WriteLine("ID: {0}, Name: {1}", stdnt.ID, name);
         }

         Console.ReadKey();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erhalten Sie die folgende Ausgabe.

Retrieve all Students from the database:
ID: 1, Name: Edited Edited Edited Alain Bomer
ID: 2, Name: Edited Edited Edited Mark Upston
ID: 3, Name: Wasim Akram