miércoles, 13 de agosto de 2014

[Patrones] Implementando patrón repositorio - Repository pattern en C# Parte II

En el artículo anterior conocimos y explicamos el patrón repositorio, vimos su propósito, su estructura, algunos casos comunes de uso, adicional creamos la estructura base en una solución de visual estudio, la cual seguiremos desarrollando a lo largo de este artículo y nos centraremos en la implementación de nuestros repositorios, recordemos que vamos a tener un repo para SqlServer, otro para MongoDB y otro para un Api "externa". Recordemos como va hasta el momento nuestra solución y nos enfocaremos en la parte señalada en rojo:


Para iniciar en el proyecto de Contrato vamos a crear las interfaces para cada repositorio, que definirán el contrato a implementar por los repositorios que vamos a crear o nuevos repos que puedan surgir en el futuro y que usen nuestras entidades de dominio Empleado, Artículo y DatosContacto, veamos entonces como quedan dichas interfaces:

    public interface IEmpleadoRepository
    {
        List<Empleado> ObtenerEmpleados();
 
        Empleado ObtenEmpleadoPoId(string id);
 
        void GuardarEmpleado(Empleado empleado);
    }

    public interface IArticuloRepository
    {
        List<Articulo> ObtenerArticulos();
 
        Articulo ObtenArticuloPorId(string id);
 
        ICollection<Articulo> ObtenerArticulosPorIdEmpleado(string idEmpleado);
 
        void GuardarArticulo(Articulo articulo);
    }

    public interface IDatosContactoRepository
    {
        DatosContacto ObtenerDatosContactoEmpleado(string idEmpleado);
    }

Ahora procedemos a crear el repositorio para SqlServer, para esto agregamos la siguiente estructura en el proyecto SqlRepository:


Como podemos ver tenemos una clase llamada Contexto, la que representará nuestro contexto de Entity Framework para interactuar con nuestra base de datos en Sql Server, en esta ocasión usaremos el enfoque de EF llamado Code First, si quieres profundizar más sobre este tema, te invito a leer esta serie de post relacionados. Adicional en la raíz del proyecto también tenemos una clase llamada BaseRepository, la cual contiene todas las operaciones básicas que pueden aplicar para cualquier entidad que se tenga que interactúe con la base de datos. Vamos a ver el código de estas dos clases que menciono:

    public partial class Contexto : DbContext
    {
        public Contexto()
            : base("name=Contexto")
        {
        }
 
        public virtual DbSet<Empleado.Empleado> Empleados { getset; }
 
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Empleado.Empleado>()
                .Property(e => e.Id)
                .IsUnicode(false);
 
            modelBuilder.Entity<Empleado.Empleado>()
                .Property(e => e.Nombre)
                .IsUnicode(false);
 
            modelBuilder.Entity<Empleado.Empleado>()
                .Property(e => e.Telefono)
                .IsUnicode(false);
        }
    }

Tenemos el mapeo a la base de datos de la tabla Empleados, y tenemos algunas configuraciones a través de Fluent Api para esta.

    public class BaseRepository<T> where T : class
    {
        protected DbContext Contexto = new Contexto();
        protected DbSet<T> DbSet;
 
        public BaseRepository()
        {
            DbSet = Contexto.Set<T>();
        }
 
        public void Insertar(T entidad)
        {
            DbSet.Add(entidad);
        }
 
        public void Eliminar(T entidad)
        {
            DbSet.Remove(entidad);
        }
 
        public IQueryable<T> Filtrar(Expression<Func<T, bool>> expresion)
        {
            return DbSet.Where(expresion);
        }
 
        public T ObtenerPorId(string id)
        {
            return DbSet.Find(id);
        }
 
        public IQueryable<T> ObtenerTodos()
        {
            return DbSet;
        }
 
        public void GuardarCambios()
        {
            Contexto.SaveChanges();
        }
    }

Como mencioné antes nuestro repositorio base para Sql Server, nos permite usarlo con cualquier entidad de Code First y realizar algunas operaciones básicas como obtener todos los registros, obtener filtrando por id, realizar una consulta filtrada, insertar y eliminar.

Ahora vamos a observar las entidades que tenemos al interior de la carpeta Empleado, que son Empleado y EmpladoRepository. La clase empleado se encarga de mapear la tabla Empleados de la base de datos y EmpleadoRepository es el repositorio específico para realizar operaciones con la tabla Empleados y hereda de nuestro repositorio base para implementar las operaciones que este expone.

    [Table("Empleados")]
    public partial class Empleado
    {
        [StringLength(50)]
        public string Id { getset; }
 
        [Required]
        [StringLength(50)]
        public string Nombre { getset; }
 
        [StringLength(10)]
        public string Telefono { getset; }
 
        [StringLength(50)]
        public string Direccion { getset; }
    }

Tenemos el mapeo de la tabla Empleados en nuestra base de datos y su configuración a través de Data Anottations.

    public class EmpleadoRepository : BaseRepository<Empleado>IEmpleadoRepository
    {
        public List<Dominio.Empleado> ObtenerEmpleados()
        {
            AutoMapper.Mapper.CreateMap<Empleado, Dominio.Empleado>();
            return
                new List<Dominio.Empleado>(ObtenerTodos().AsEnumerable().Select(AutoMapper.Mapper.Map<Dominio.Empleado>
                    )).ToList();
        }
 
        public Dominio.Empleado ObtenEmpleadoPoId(string id)
        {
            var empleado = ObtenerPorId(id);
 
            AutoMapper.Mapper.CreateMap<Empleado, Dominio.Empleado>();
            return AutoMapper.Mapper.Map<Dominio.Empleado>(empleado);
        }
 
        public void GuardarEmpleado(Dominio.Empleado empleado)
        {
            AutoMapper.Mapper.CreateMap<Dominio.EmpleadoEmpleado>();
            var emple = AutoMapper.Mapper.Map<Empleado>(empleado);
 
            Insertar(emple);
        }
    }

Como podemos ver, el EmpleadoRepository hereda de BaseRepository usando la entidad Empleado para realizar las operaciones, adicional implementa la interfaz IEmpleadoRepository, que define el contrato a implementar para este repositorio. En este repositorio tenemos tres métodos, ObtenerEmpelados(), ObtenerEmpleadoPorId() y GuardarEmpleado() los cuales usan métodos del repositorio base respectivamente.

Por último algo curioso en este repositorio es el uso del AutoMapper, que es una herramienta que nos permite mapear dos objetos que pueden tener una estructura diferente pero contener todos o algunos datos iguales. En este caso lo usamos para mapear la entidad Empleados de CodeFirst a nuestra entidad de domino Empleado, que recordemos se encuentra en el proyecto de dominio, y es la entidad devuelta por el repositorio y usada por los clientes que consuman el repo, esto con el fin de que todos los clientes "hablen" en términos del domino y todo quede centralizado en estas entidades. Si quieres profundizar más acerca del tema AutoMapper puedes observar este artículo del crack JulitoGTU.

Ahora ya tenemos listo el repositorio para interactuar con la base de datos Sql Server, es decir tenemos centralizada toda la lógica de acceso a datos en el repo, ahora podríamos consumir el repo a través de algún cliente (Aplicación web, escritorio, consola, etc.) para interactuar con la base de datos y estos no sabrían sobre la proveniencia de los datos.

Y bueno eso es todo por este artículo, en el cual implementamos el contrato de los repositorios y el repositorio especifico para acceso a datos de Sql Server usando Entity Framework Code First, en el próximo artículo terminaremos los repositorios, implementando el repo para acceso a datos en MongoDB y también para obtener información del servicio web api. Espero sea de utilidad y de interés para ustedes.

Continua en: Implementando patrón repositorio - Repository pattern en C# Parte III

Este ejemplo lo puedes descargar de mi repositorio en GitHub

No olvides visitar mi página en Facebook para mantenerte actualizado de lo que pasa en el Tavo.Net https://www.facebook.com/eltavo.net
Saludos, y buena suerte!

4 comentarios:

  1. Hola.
    Porque no utilizas una interfaz general y una clase también general que implemente esa interfaz? la aproximación en BaseRepository seria un ejemplo de clase general que implemente una interfaz que englobe las operaciones que se realizaran sobre la base de datos, me parece mucho trabajo hacer una interfaz para cada entidad de mi negocio y luego una clase que implemente cada una de esas interfaces.

    tambien queria preguntar si las entidades de dominio que presentas en la parte 1 corresponden con las tablas que me imagino tienes en tu base de datos, de ser asi hubiera sido un buen ejemplo que la clase parcial(que imagino es una buddy class) tubiera todos los campos de tu entidad pues a mi parecer dejaste fuera los mas interesantes.

    Lo del AutoMapper esta de lujo.

    Saludos

    ResponderEliminar
    Respuestas
    1. Hola, muchas gracias por tu aporte, es correcto lo que dices, el patrón repositorio tiene otra variación la cual es denominada Generic Repository, esa es a la que te refieres para no tener que implenetar un repositorio por cada entidad de negocio, en este ejemplo quise centrarme en el repositorio básico ya que es un ejemplo sencillo.

      Con respecto a las entidades de dominio que uso, solo la de empleado persiste en una base de datos Sql Server a través de Entity Framework, la de Articulos persiste a una DB noSql MongoDB, y la otra de DatosContacto se recibe de una Api implementada en Asp.Net Web Api, esa es el propósito del ejemplo, ver como a través del patrón repositorio se puede abstraer la lógica para consumir información desde diferentes repositorios de datos de cualquier tipo, si ves cada parte del ejemplo encontrarás que cada una de esas entidades se usa y se llena usando sus respectivos repositorios.

      Saludos!

      Eliminar
    2. El problema de hace interfaces generales o que tengan la abstracción de todos los métodos es que probablemente viola el principio ISP(Interface segregation principle)

      https://www.youtube.com/watch?v=EzUIbMdxJTk
      https://www.youtube.com/watch?v=mDAQLkdNGHU

      Eliminar
    3. Saludos,
      Buen Post Tavo, recién comienzo con este patrón de diseño y me gustaría saber si tienen algún ejemplo claro utilizando "Generic Repository"
      Muchas gracias

      Eliminar