Tips de Desarrollo Web

Escrito por Juan David Nicholls

NAVEGACIÓN

Arquitectura N-Capas y Entity Framework 5 - Code First

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…

Nueva Solución

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.

Nuevo Proyecto

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

Acceso a Datos

Eliminamos la Clase que se crea por defecto.

Borrar Clase

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

Administrar Paquetes NuGet

La cual encontramos escribiendo Entity en el Buscador Online.

Entity Framework

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

Licencia

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

Nuevo Proyecto

Entidades

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.

DataAnnotations

Entidad de Usuarios

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.

DataAnnotations

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

DataAnnotations

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.

Agregando 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.

  1. using Entities;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Data.Entity;
  5. using System.Linq;
  6. using System.Text;
  7. using System.Threading.Tasks;
  8.  
  9. namespace Data
  10. {
  11.     public class DataContext : DbContext
  12.     {
  13.         public DataContext()
  14.             : base("Data Source=DirecciondelServidor;Initial Catalog=NombreBasedeDatos;User ID=NombreUsuario;Password=Clave")
  15.         {
  16.  
  17.         }
  18.  
  19.         public DbSet<User> Users { get; set; }
  20.         public DbSet<IdentificationType> IdentificationTypes { get; set; }
  21.     }
  22. }

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

  1. using Data;
  2. using Entities;
  3. using System;
  4. using System.Collections.Generic;
  5. using System.Linq;
  6. using System.Text;
  7. using System.Threading.Tasks;
  8.  
  9. namespace Data
  10. {
  11.     public class UserManager
  12.     {
  13.         #region Select
  14.  
  15.         public List<User> GetUsers()
  16.         {
  17.             List<User> users = new List<User>();
  18.             using (var db = new Data.DataContext())
  19.             {
  20.                 users = db.Users.ToList();
  21.             }
  22.             return users;
  23.         }
  24.  
  25.         #endregion
  26.  
  27.         #region Insert
  28.  
  29.         public void InsertUser(User user)
  30.         {
  31.             using (var db = new Data.DataContext())
  32.             {
  33.                 db.Users.Add(user);
  34.                 db.SaveChanges();
  35.             }
  36.         }
  37.  
  38.         #endregion
  39.     }
  40. }

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.

Capa de Negocio

  1. using Data;
  2. using Entities;
  3. using System;
  4. using System.Collections.Generic;
  5. using System.Linq;
  6. using System.Text;
  7. using System.Threading.Tasks;
  8.  
  9. namespace Business
  10. {
  11.     public class UserLogic
  12.     {
  13.         private UserManager umanager;
  14.         private UserManager UManager
  15.         {
  16.             get
  17.             {
  18.                 return umanager ?? (umanager = new UserManager());
  19.             }
  20.         }
  21.  
  22.         public List<User> GetUsers()
  23.         {
  24.             return UManager.GetUsers();
  25.         }
  26.  
  27.         public void InsertUser(User user)
  28.         {
  29.             UManager.InsertUser(user);
  30.         }
  31.     }
  32. }

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.

Nuevo Sitio Web

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

Agregando Referencias

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

  1. using Business;
  2. using Entities;
  3. using System;
  4. using System.Collections.Generic;
  5. using System.Linq;
  6. using System.Web;
  7. using System.Web.Security;
  8. using System.Web.UI;
  9. using System.Web.UI.WebControls;
  10.  
  11. public partial class _Default : System.Web.UI.Page
  12. {
  13.     private UserLogic umanager;
  14.     private UserLogic UManager
  15.     {
  16.         get
  17.         {
  18.             return umanager ?? (umanager = new UserLogic());
  19.         }
  20.     }
  21.  
  22.     private IdentificationTypeLogic itypemanager;
  23.     private IdentificationTypeLogic ITypeManager
  24.     {
  25.         get
  26.         {
  27.             return itypemanager ?? (itypemanager = new IdentificationTypeLogic());
  28.         }
  29.     }
  30.  
  31.     protected void Page_Load(object sender, EventArgs e)
  32.     {
  33.         UManager.InsertUser(new User(){
  34.             UserID = (Guid)Membership.GetUser("jaimito@hotmail.com").ProviderUserKey,
  35.             FirstName = "Jaimito",
  36.             LastName = "Perez",
  37.             BirthDay = DateTime.Parse("1990/12/07"),
  38.             Gender = true,
  39.             Identification = "123456789",
  40.             IdentificationTypeId = ITypeManager.InsertIdentificationType("CC"),
  41.             Address = "Ni idea",
  42.             PostalCode = "00000",
  43.             Phone = "123123123",
  44.             CellPhone = "2232323323",
  45.             CityId = 1
  46.         });
  47.         List<User> users = UManager.GetUsers();
  48.     }
  49. }

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.

Package Manager Console

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

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.

Add-Migration

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

Migrations

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

Update-Database

Espero que les haya gustado, hasta la próxima ;)

PD: Cualquier sugerencia, comentario o crítica es totalmente bienvenida :D

blog comments powered by Disqus