Anuncio de Entity Framework Code-First (CTP5 Release)

Esta semana el equipo de datos ha publicado la CTP5 de la nueva librería de Entity Framework Code-First. EF Code-First permite un flujo de desarrollo centrado en el código para trabajar con datos. Nos permite:

  • Desarrollar sin tener que abrir el diseñador para definir el archivo XML de mapeo.
  • Definir modelos de objetos escribiendo clases planas sin necesidad de tener clases base.
  • Usar una aproximación de "convención sobre configuración" que nos permite persistencia de datos sin tener que configurar nada.
  • Sobreescribir opcionalmente esa convención de persistencia y usar una API fluida para personalizar totalmente el mapeo de la persistencia.

Soy un gran fan de la aproximación de EF Code-First, y he escrito varios post sobre el tema este verano:

Esta nueva CTP incluye varias mejoras sobre la CTP4, y será la última preview de Code First ántes de la release final. Publicaremos la versión final de EF Code First en el próximo cuarto de año 2011. Funciona en todas las aplicaciones .NET (incluyendo ASP.NET Web Forms y ASP.NET MVC).

Instalando EF Code First

Podéis instalar y usar EF Code First CTP5 de dos maneras:

1) Descargando y ejecutando el programa de instalación. Una vez instalado podéis referenciar el assembly EntityFramework.dll en vuestros proyectos.

2) Usando el NuGet PackageManager desde visual studio para descargar e instalar EF Code First en un proyecto. Para hacer esto, tansolo tenéis que mostrar la consola de NuGet en visual Studio (ViewOther WindowsPackage Manager Console) y escribir "install-package EFCodeFirst".

Escribiendo "Install-Package EFCodeFirst" en la consola hará que NuGet se descargue el paquete, y lo añada al proyecto actual.

Esto añadirá una referencia a la dll EntitFramework.dll a tu proyecto:

NuGet nos permite instalar y usar EF CodeFirst en tan solo unos segundos. Cuando la versión final de EF Code First se publice también podremos escribir "Update-Package EFCodeFirst" para actualizar los proyectos existentes con la versión final.

Assembly y Namespace de EF CodeFirst.

La release CTP5 de EF Code First tiene un nuevo nombre de asembly y un nuevo Namespace:

  • Assembly: EntityFramework.dll
  • Namescape: System.Data.Entity

Estos nombres coinciden con el plan que tenemos para la release final de la libreria.

Mejoras en la CTP5

La nueva CTP5 contiene un montón de mejoras y refinamientos. Entre ellas destacamos:

  • Mejor soporte para bases de datos existentes.
  • Validación de nivel de modelos integrados y soporte para DataAnnotations.
  • Mejoras en la fluidez de la API
  • Soporte de Convenios de pluggins. (Pluggable Conventions)
  • Nueva API de seguimiento de cambios (Change Tracking)
  • Mejorada la resolución de conflictos de concurrencias.
  • Soporte de comandos y sentencias Raw SQL.

En el resto del post veremos algunos detalles sobre algunas de las características anteriores.

Mejor soporte para bases de datos existentes.

EF Code First hace muy fácil crear capas de modelos que funcionen con bases de datos existentes. Esta CTP5 incluye algunas mejoras que hacen que el trabajo en estos escenarios sea más fluido.

Vamos a ver los pasos que debemos seguir para crear una capa de modelos para la base de datos Northwind

Paso 1: Creación de las clases de Modelos y la clase DbContext

Aquí tenéis el código necesario para implementar una capa de modelos simple con EF Code First con la base de datos Northwind:

EF Code First nos permiten usar "POCO" - Plain Old CLR Objects - para representar entidades de una base de datos. Esto significa que no tenemos que heredar el modelo de clases de una clase base, ni implementar interfaces ni poner atributos para persistir los cambios en base de datos. Esto permite tener las clases del modelo limpias, fáciles de testear, e ingorantes de la persistencia. Las clases atneriores de Product y Category son ejemplos de un modelo de clases POCO.

EF Code First nos permite conectar fácilmente nuestro modelo de clases POCO a una base de datos creando una clase "DbContext" que expone las propiedades públicas que mapean las propiedades públicas a las tablas de la base de datos. La clase Northwind anterior ilustra cómo se hace. Está mapeando nuestras clases Product y Category con las columnas de las tablas Products y Categories - y cada instancia de un objeto Product/Category se mapea con una fila de las tablas.

El código anterior es todo el que necesitamos para crear nuestro modelo y la capa de acceso a datos. CTPs anteriores de EF Code First requerían algo más para trabajar con bases de datos existentes (una llamada a Database.Initializar<Northwind>(null) para decirle a EF Code First que no crease la base de datos)- este paso ya no es necesario en la CTP5.

Paso 2: Configurar la cadena de conexión a la base de datos.

Hemos escrito todo el código que necesitamos para definir nuestra capa de modelo. El último paso que tenemos que dar antes de usarlo es configurar la cadena de conexión que nos conecta a nuestra base de datos. Para ello añadiremos la cadena de conexión "Northwind" a nuestro web.config (o App.Config en aplicaciones cliente) de la siguiente manera:

 

  <connectionStrings>

    <add name="Northwind"
         connectionString="data source=.SQLEXPRESS;Integrated Security=SSPI;AttachDBFilename=|DataDirectory|northwind.mdf;User Instance=true"
         providerName="System.Data.SqlClient" />

  </connectionStrings>

 

EF Code First usa una convención en la que las clases DbContext buscan por defecto una cadena de conexión con el mismo nombre que la clase context. Como nuestra clase DbContext se llama "Northwind" buscará por defecto esa cadena de conexión. Como vemos, la cadena de conexión está configurada para usar una base de datos SQL Express (guardad en el directorio App_Data de nuestro proyecto). Podemos cambiarlo a un SQL Server remoto.

Paso 3: Usando nuestra capa de modelo Northwind

Podemos empezar a consultar y actualizar nuestra base de datos usando la capa de modelos fuertemente tipados que acabamos de crear con EF Code First.

El siguiente código muestra cómo usar LINQ para consultar los productos de una categoría concreta. Esta consulta devuelve una secuencia fuertemente tipada de objetos Product que coinciden con el criterio de búsqueda:

El código siguiente muestra cómo podemos obtener un objeto producto, actualizar dos de sus propiedades, y guardar los cambios en la base de datos:

EF Code First administra todo el seguimiento de cambios y el trabajo de persistencia por nosotros, y nos permite centrarnos en la lógica de nuestra aplicación y de nuestro negocio sin tener que preocuparnos por todo el trabajo de acceso a datos.

 Validación de nivel de modelos

EF Code First nos permite usar cualquier solución de validación que queramos cuando implementamos lógica de negocio con nuestro modelo de capas. Esto nos permite una gran flexibilidad y potencia.

A partir de esta CTP5, EF Code First incluye el soporte integrado tanto de DataAnnotation y el soporte de validaciones IValidatorObject de .NET 4. Esto nos permite implementar reglas de validación en nuestros modelos, y tener estas reglas reforzadas automáticamente por EF Code First cada vez que guardemos nuestra capa de modelos. Ofrece una forma muy conveniente de habilitar la validación en nuestras aplicaciones.

Aplicando DataAnnotations a nuestro modelo Northwind.

El siguiente código nos muestra cómo podemos añadir algunas reglas de validación declarativas a dos propiedades de nuestra clase "Producto":

Estamos usando los atributos [Required] y [Range]. Estos atributos de validación viven en el namespace System.ComponentModel.DataAnnotations que viene con .NET4, y puede ser usado independientemente de EF. Los mensajes de error indicaso pueden ser definidos explicitamente (como en el ejemplo) - o obtenerlos de archivos de recursos (con lo que conseguimos aplicaciones localizadas mucho más fácilmente).

Aplicar la validación en SaveChanges()

EF Code First (a partir de la CTP 5) aplica automáticamente las reglas de DataAnnotation cuando se actualiza o guarda un objeto del modelo. No tenemos que escribir ningún código para que se apliquen esas validaciones - este soporte está activado por defecto.

Este nuevo soporte implica que en el código siguiente - que no cumple nuestras reglas - lanzará una excepción automáticamente cuando se llame al método "SaveChanges()" en nuestro DbContext:

La DBEntityValidationException que se lanza cuando llamamos al método SaveChanges() contiene una propiedad "EntityValidationErrors" que podemos usar para obtener la lista de todos los errores de validación que han ocurrido en el modelo que intentamos guardar. Esto nos permite guiar al usuario fácilmente sobre cómo corregir esos errores. Fijáos que EF Code First suspendera la transacción completa de cambios si se viola una regla - asegurando que nuestra base de datos siempre estará en un estado consistente.

La aplicación automática de validaciones de EF Code First funciona tanto para los atributos integrados de DataAnnotations de .NET 4(como Required, Range, RegularExpression, StringLength, etc), como para cualquier regla de validación personalizada que creemos heredando de la clase System.ComponentMOdel.DataAnnotations.ValidationAttribute.

Soporte de validación de interfaz de usuario (UI)

Muchos de los frameworks para UI de .NET también soportan las reglas de validación basadas en DataAnnotations. Por ejemplo, ASP.NET MVC, ASP.NET Dynamic Data, y Silverlight (a través de WCF RIA Services) todas soportan mostrar en el lado del cliente las validaciones correspondientes a las reglas DataAnnotation que apliquemos a nuestro modelo de objetos.

El siguiente pantallazo muestra cómo usar la estructura por defecto de la plantilla "Add-View" en una aplicación ASP.NET MVC 3 que causaría los mensajes de error correspondientes a las validaciones que no se cumplen:

ASP.NET MVC 3 soporta la aplicación de estas validaciones tanto en el lado del cliente como en el lado del servidor. Los mensajes de error que se muestrn se cogen automáticamente de los atributos - eliminando la necesidad de escribir ningún código adicional para mostrarlos.

Manteniendo las cosas DRY

El principio "DRY" viene de "Do Not Repeat Yourself" ("No te repitas"), y es una buena práctica recomendad para no duplicar lógica/configuraciones/código en muchos sitios en nuestras aplicaciones, en lugar de eso lo ponemos en un lugar y lo aplicamos donde haga falta.

EF Code First CTP5 nos permite aplicar validaciones DataAnnotations de forma declarativa en nuestro modelo de clases (y especificarlas una sola vez) de manera que aseguramos su ejecución (y mostramos los mensajes de error) en todos los escenarios - incluso en controladores, vistas, scripts de cliente, y en cualqueir código personalizado que actualice y manipule nuestro modelo de objetos.

Esto hace mucho más sencillo crear buenas aplicaciones con código limpio, y crear aplicaciones que pueden evolucionar rápidamente.

Otras mejoras de la CTP 5 de EF Code First.

EF Code First CTP 5 incluye un montón de mejoras más. Aquí tenéis una breve descripción de algunas de ellas: 

  • Mejoras en la fluidez de la API
  • EF Code First no permite sobreescribir el método "OnModelCreating()" de la clase DbContext para poder refinar/sobreescribir las reglas de mapeado del esquema usado para mapear las clases del modelo al esquema de la base de datos. CTP5 incluye algunos refinamientos en la clase ModelBuilder que se le pasa a este método con lo que podemos definir reglas de mapeo más limpias y más concisas. El equipo de ADO.NET ha posteado algunos ejemplos sobre cómo hacer esto aquí.

  • Soporte de Convenios de pluggins. (Pluggable Conventions)
  • EF Code First CTP 5 ofrece el nuevo soporte que nos permite sobreescribir los convenios por defecto que usa EF Code First, y reemplazarlos si queremos con nuestro propio juego de convenios.

  • Nueva API de seguimiento de cambios (Change Tracking)
  • EF Code First CTP 5 ofrece un conjunto de información de seguimiento de cambios que nos permiten acceder a los valores originales, los actuales y los almacenados, el estado (por ejemplo: Added, Unchanged, Modified, Deleted). Este soporte es muy útil en muchos escenarios.

  • Mejorada la resolución de conflictos de concurrencias.
  • EF Code First CTP5 ofrece mensajes de excepcion mejores que nos permiten acceder a la instancia del objeto afectado y nos da la posibilidad de resolver conflictos usando los valores actuales, original y el de la base de datos.

  • Soporte de comandos y sentencias Raw SQL.
  • EF Code First CTP 5 soporta ahora consultas y comandos SQL Raw (incluso en SPROCs) para que se ejecuten a través del método SqlQuery y SQlCommand expuestos en la propiedad DbContext.DataBase. El resultado de las llamadas a estos métodos pueden materializarse en instancias de objetos que pueden hacer el seguimiento por el DbContext. Esto es útil en muchos escenarios.

    • Soporte completo de DataAnnotations

    EF Code First soporta todos los DAtaAnnotations estándares de .NET, y puede usarlos tanto para realizar validaciones como para crear el esquema automáticamente de la base de datos cuando usamos EF Code First en el escenario de creación de base de datos.

    Resúmen

    EF Code First ofrece una forma elegante y poderosa de trabajar con datos. Me gusta mucho ya que es extremadamente limpio y soporta todas las mejores práticas, además de permitir soluciones que se implementan muy, muy rápido. La aproximación code-only de la librería implica que las capas de modelos terminan siendo flexibles y fáciles de personalizar.

    Esta CTP 5 refina EF Code First y ayuda a asegurar que la release de final de año será muy suave. Os recomiendo usar NuGet para instalar y provarlo. Creo que os soprenderá lo increíble que es.

    Espero que sirva,

    Scott.

    Traducido por: Juan María Laó Ramos.

    Artículo original.