Tips de Desarrollo Web

Arquitectura N-Capas y Entity Framework 5 - Code First

31. julio 2013 03:01 / Nicholls / .NET . SQL / Comentarios (0)

En este artículo explicaré como desarrollar una arquitectura N-Capas con Entity Framework 5 definiendo el modelo mediante el código, el cual generará nuestra nueva Base de Datos y que por lo tanto será realmente útil para nuevos desarrollos.

Desarrollando una Aplicación de 4 Capas (Presentación, Negocio, Acceso a Datos y Entidades)

La principal diferencia de esta arquitectura con la tradicional, es que la Capa de Entidades nos permite comunicar entre las diversas Capas el tipo de Colecciones que estemos definiendo en nuestra Base de Datos, de esta manera nuestra Capa de Presentación podrá recibir Colecciones (Listas por ejemplo) y saber el tipo de Dato que se esta comunicando para poder acceder a sus propiedades.

Para iniciar, crearemos en Visual Studio una nueva Solución. File, New, Project…

Después de Seleccionar la ubicación, asignarle un nombre a nuestra Solución y crearla, procedemos a agregar nuestra Capa de Acceso a Datos. Click derecho en la Solución.

Seleccionamos Biblioteca de Clases y de nuevo seleccionamos la Ubicación de nuestro Proyecto.

Eliminamos la Clase que se crea por defecto.

Y agregaremos la referencia de Entity Framework 5 mediante el administrador de paquetes NuGet.

La cual encontramos escribiendo Entity en el Buscador Online.

Aceptamos los términos de Licencia de Uso y se instalará en nuestra Capa de Acceso a Datos todas las referencias necesarias.

Antes de continuar procederemos a crear nuestra Capa de Entidades, la cual como su nombre lo indica es donde se definirá nuestro modelo.

Crearemos en este ejemplo dos Clases, User el cual es la representación de un Usuario e IdentificationType el cual es la representación de un tipo de documento como la Cédula. Para estos vamos a hacer uso de las anotaciones, por lo tanto agregamos la siguiente referencia.

Para Solucionar el Error le damos Click derecho a alguna anotación, resolver y agregamos la referencia a la Clase. Podemos observar que estamos definiendo de las propiedades, cuál va a ser la Clave Primaria, cuales serán los campos requeridos, la longitud máxima de cada uno, etc que nos permiten por lo tanto tener el control total de nuestro modelo.

Con respecto a las Claves Foráneas se debe agregar otra referencia.

Al tener ya definida nuestras Entidades o al menos algunas, volvemos a nuestra Capa de Acceso a Datos y procedemos a agregar la Referencia de nuestra Capa de Entidades.

Estando en nuestra Capa de Acceso a Datos procedemos a generar manualmente el Contexto de nuestra nueva Base de Datos, para esto creamos una Clase la cual heredará de DbContext de la referencia System.Data.Entity, a esta le asignaremos nuestra cadena de Conexión de nuestra nueva Base de Datos y por último enlistaremos nuestras Colecciones de Entidades.

using Entities;
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Data
{
    public class DataContext : DbContext
    {
        public DataContext()
            : base("Data Source=DirecciondelServidor;Initial Catalog=NombreBasedeDatos;User ID=NombreUsuario;Password=Clave")
        {

        }

        public DbSet<User> Users { get; set; }
        public DbSet<IdentificationType> IdentificationTypes { get; set; }
    }
}

Ahora crearemos las Clases que se encargaran de Administrar(CRUD) a nuestras colecciones, que en definitiva vienen siendo las Tablas de la Base de Datos.

Ejemplo de la Clase Administradora de Usuarios UserManager

using Data;
using Entities;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Data
{
    public class UserManager
    {
        #region Select

        public List<User> GetUsers()
        {
            List<User> users = new List<User>();
            using (var db = new Data.DataContext())
            {
                users = db.Users.ToList();
            }
            return users;
        }

        #endregion

        #region Insert

        public void InsertUser(User user)
        {
            using (var db = new Data.DataContext())
            {
                db.Users.Add(user);
                db.SaveChanges();
            }
        }

        #endregion
    }
}

Podemos observar que realizamos el CRUD a nuestra base de datos e inmediatamente se libera el DataContext de memoria.

Ahora procedemos a agregar nuestra Capa de Negocio, en esta se definirá la lógica de negocio, en donde se llamará a nuestra Capa de Acceso a Datos para interactuar con la Base de Datos y se conocerá los tipos de respuesta que involucren nuestras Entidades gracias a la Capa de Entidades.

using Data;
using Entities;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Business
{
    public class UserLogic
    {
        private UserManager umanager;
        private UserManager UManager
        {
            get
            {
                return umanager ?? (umanager = new UserManager());
            }
        }

        public List<User> GetUsers()
        {
            return UManager.GetUsers();
        }

        public void InsertUser(User user)
        {
            UManager.InsertUser(user);
        }
    }
}

Y por último creamos nuestra Capa de Presentación el cual será el encargado de validar las interfaces de Usuario y comunicarse con nuestra Capa de Negocio.

Agregamos la referencia de nuestra Capa de Negocio y la de nuestra Capa de Entidades.

Y por lo tanto ya nos podremos comunicar con nuestra Capa de Negocio mediante nuestro código.

using Business;
using Entities;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class _Default : System.Web.UI.Page
{
    private UserLogic umanager;
    private UserLogic UManager
    {
        get
        {
            return umanager ?? (umanager = new UserLogic());
        }
    }

    private IdentificationTypeLogic itypemanager;
    private IdentificationTypeLogic ITypeManager
    {
        get
        {
            return itypemanager ?? (itypemanager = new IdentificationTypeLogic());
        }
    }

    protected void Page_Load(object sender, EventArgs e)
    {
        UManager.InsertUser(new User(){
            UserID = (Guid)Membership.GetUser("jaimito@hotmail.com").ProviderUserKey,
            FirstName = "Jaimito",
            LastName = "Perez",
            BirthDay = DateTime.Parse("1990/12/07"),
            Gender = true,
            Identification = "123456789",
            IdentificationTypeId = ITypeManager.InsertIdentificationType("CC"),
            Address = "Ni idea",
            PostalCode = "00000",
            Phone = "123123123",
            CellPhone = "2232323323",
            CityId = 1
        });
        List<User> users = UManager.GetUsers();
    }
}

Como es posible que tengamos que estar modificando nuestra Entidades y por lo tanto cambiar nuestro Modelo, debemos de habilitar las Migraciones. Estas nos permiten llevar un historial de las modificaciones realizadas a nuestra Base de Datos por si nos queremos devolver luego y por lo tanto modificar nuestra Base de Datos, este proceso se realiza mediante el Package Manager Console.

Procedemos a Habilitar las Migraciones en nuestra Capa de Acceso a Datos, mediante el Comando Enable-Migrations.

Para Agregar una nueva Migración debemos ejecutar el Comando Add-Migration Name –StartupProjectName "Data" en donde Name es el nombre que le queramos dar a la Migración y Data es el nombre del Proyecto que contiene nuestra Cadena de Conexión.

Las Migraciones las podemos observar en la Carpeta Migrations, la cual se genera automáticamente.

Para aplicar la Migración procedemos a ejecutar el comando Update-Database –StartupProjectName "Data"