Entity Framework: persistencia

Entity Framework ahora le permite beneficiarse de Entity Framework sin obligar a cada parte de su aplicación a conocer Entity Framework, separando las entidades de la infraestructura. Puede crear clases que puedan centrarse en sus reglas de negocio sin importar cómo se conservan (dónde se almacenan los datos y cómo los datos van y vienen entre sus objetos).

Creación de entidades ignorantes persistentes

El párrafo anterior describe un método que no tiene un conocimiento profundo de la fuente de los datos que consume. Esto resalta la esencia de la ignorancia persistente, que es cuando a sus clases y a muchas de nuestras capas de aplicación a su alrededor no les importa cómo se almacenan los datos.

En la versión .NET 3.5 de Entity Framework, si deseaba usar clases preexistentes, debía modificarlas forzándolas a derivar de EntityObject.
En .NET 4 esto ya no es necesario. No tiene que modificar sus entidades para que puedan participar en las operaciones de Entity Framework.
Esto nos permite crear aplicaciones que abarcan un acoplamiento flexible y una separación de preocupaciones.
Con estos patrones de codificación, sus clases solo se preocupan por sus propios trabajos y, muchas capas de su aplicación, incluida la interfaz de usuario, no tienen dependencias de la lógica externa, como las API de Entity Framework, pero esas API externas pueden interactuar con nuestra entidades.

Hay 2 formas (conectadas y desconectadas) cuando persiste una entidad con Entity Framework. Ambas formas tienen su propia importancia. En el caso de un escenario conectado, los cambios son rastreados por el contexto, pero en el caso de un escenario desconectado, necesitamos informar al contexto sobre el estado de la entidad.

Escenarios conectados

El escenario conectado es cuando una entidad se recupera de la base de datos y se modifica en el mismo contexto. Para un escenario conectado, supongamos que tenemos un servicio de Windows y estamos haciendo algunas operaciones comerciales con esa entidad, así que abriremos el contexto, recorreremos todas las entidades, realizaremos nuestras operaciones comerciales y luego guardaremos los cambios con el mismo contexto que abierto al principio.

Echemos un vistazo al siguiente ejemplo en el que los estudiantes se recuperan de la base de datos y actualizan el nombre de los estudiantes y luego guardan los cambios en la base de datos.

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

Cuando se compile y ejecute el código anterior, recibirá el siguiente resultado y verá que la palabra editada se adjunta antes del nombre, como se muestra en el siguiente resultado.

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

Escenarios desconectados

El escenario desconectado es cuando una entidad se recupera de la base de datos y se modifica en un contexto diferente. Supongamos que queremos mostrar algunos datos en una capa de presentación y estamos usando una aplicación de n niveles, por lo que sería mejor abrir el contexto, obtener los datos y finalmente cerrar el contexto. Dado que aquí hemos obtenido los datos y cerrado el contexto, las entidades que hemos obtenido ya no se rastrean y este es el escenario desconectado.

Echemos un vistazo al siguiente código en el que se agrega una nueva entidad Student desconectada a un contexto usando el método 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();
      }
   }
}

Cuando se compile y ejecute el código anterior, recibirá el siguiente resultado.

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

↰ Previous page Next page ↱