Entity Framework - Persistenza

Entity Framework ora ti consente di trarre vantaggio da Entity Framework senza costringere ogni parte della tua applicazione a essere a conoscenza di Entity Framework, separando le entità dall'infrastruttura. È possibile creare classi che possono concentrarsi sulle proprie regole di business indipendentemente dal modo in cui vengono mantenute (dove vengono archiviati i dati e come i dati passano avanti e indietro tra gli oggetti).

Creazione di entità ignoranti persistenti

Il paragrafo precedente ha descritto un metodo che non ha una conoscenza approfondita della fonte dei dati che consuma. Ciò evidenzia l'essenza dell'ignoranza della persistenza, ovvero quando le tue classi e molti dei nostri livelli applicativi attorno a loro non si preoccupano di come vengono archiviati i dati.

• Nella versione .NET 3.5 di Entity Framework, se si desiderava utilizzare classi preesistenti, era necessario modificarle costringendole a derivare da EntityObject.

• In .NET 4 questo non è più necessario. Non è necessario modificare le entità per consentire loro di partecipare alle operazioni di Entity Framework.

• Questo ci consente di creare applicazioni che abbracciano l'accoppiamento libero e la separazione delle preoccupazioni.

• Con questi modelli di codifica, le tue classi si occupano solo dei propri lavori e, molti livelli della tua applicazione, inclusa l'interfaccia utente, non hanno dipendenze dalla logica esterna, come le API di Entity Framework, ma quelle API esterne sono in grado di interagire con il nostro entità.

Esistono 2 modi (connesso e disconnesso) quando si mantiene un'entità con Entity Framework. Entrambi i modi hanno la loro importanza. Nel caso di uno scenario connesso le modifiche vengono tracciate dal contesto, ma nel caso di uno scenario disconnesso è necessario informare il contesto sullo stato dell'entità.

Scenari connessi

Lo scenario connesso è quando un'entità viene recuperata dal database e modificata nello stesso contesto. Per uno scenario connesso, supponiamo di avere un servizio Windows e di eseguire alcune operazioni aziendali con quell'entità, quindi apriremo il contesto, eseguiremo il ciclo di tutte le entità, eseguiremo le nostre operazioni aziendali e quindi salveremo le modifiche con lo stesso contesto aperto all'inizio.

Diamo un'occhiata al seguente esempio in cui gli studenti vengono recuperati dal database e aggiornano il nome degli studenti, quindi salvano le modifiche nel database.

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();
      }
   }
}

Quando il codice sopra è stato compilato ed eseguito, riceverai il seguente output e vedrai che la parola modificata è allegata prima del nome come mostrato nell'output seguente.

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

Scenari disconnessi

Lo scenario disconnesso è quando un'entità viene recuperata dal database e modificata in un contesto diverso. Supponiamo di voler visualizzare alcuni dati in un livello di presentazione e di utilizzare un'applicazione a più livelli, quindi sarebbe meglio aprire il contesto, recuperare i dati e infine chiudere il contesto. Poiché qui abbiamo recuperato i dati e chiuso il contesto, le entità che abbiamo recuperato non vengono più tracciate e questo è lo scenario disconnesso.

Diamo un'occhiata al codice seguente in cui la nuova entità Student disconnessa viene aggiunta a un contesto usando il metodo Add.

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();
      }
   }
}

Quando il codice precedente viene compilato ed eseguito, riceverai il seguente output.

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