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

En el artículo anterior creamos la estructura para nuestros repositorios y creamos el repositorio para acceso a la base de datos en Sql Server a través de Entity Framework Code First, ahora observaremos como crear los repositorios para acceder a los artículos almacenados en MongoDB y también para obtener los datos de contacto de los empleados que nos proveerá una API en Asp.Net Web Api.

Para iniciar veamos cómo quedará la estructura de nuestro repositorio de MongoDB para cuando lo hayamos terminado:

Como podemos ver tiene la misma estructura que nuestro repositorio de Sql Server del artículo anterior, a diferencia que en este repo utilizamos la entidad Articulo podría ser Empleado, DatosContacto o cualquier otra y también tenemos un repositorio base, el cual nos ayudara a realizar operaciones comunes con la base de datos de Mongo, como por ejemplo, conectarse al servidor, obtener la base de datos, obtener una colección en específico y hacer operaciones sobre esta colección, si quieres ver una introducción sobre MongoDB te invito a que leas este artículo que tengo al respecto.

Ahora observemos el código de nuestro repositorio base para MongoDB

    public class BaseRepository<T> where T : class
    {
        private readonly string _nombreColeccion;
        private MongoDatabase database;
 
        public BaseRepository(string nombreColeccion)
        {
            _nombreColeccion = nombreColeccion;
        }
 
        public void ConectarDb()
        {
            const string connectionString = "mongodb://localhost";
            var client = new MongoClient(connectionString);
            MongoServer server = client.GetServer();
            database = server.GetDatabase("RepositoryPatternDemo");
        }
 
        public void Insertar(T entidad)
        {
            var coleccion = database.GetCollection<T>(_nombreColeccion);
            coleccion.Insert(entidad);
        }
 
        public IQueryable<T> ObtenerTodos()
        {
            var coleccion = database.GetCollection<T>(_nombreColeccion);
            return coleccion.FindAll().AsQueryable();
        }
    }

Nuestro repo base nos permite conectarnos a una base de datos MongoDB  usando el string de conexión y base de datos que vemos en el código esto debería estar en un archivo de configuración, pero para este ejemplo no tiene mucha importancia adicional nos permite insertar un nuevo documento en cualquier colección y nos permite obtener todos los documentos de la base de datos. Es un repositorio base bastante simple al cual le podríamos agregar muchas más operaciones.

Ahora veamos la entidad Artículo la cual se almacena directamente en MongoDB como un documento de tipo Json:

    public class Articulo
    {
        public ObjectId Id { get; set; }
 
        public string Titulo { get; set; }
 
        public string ContenidoHtml { get; set; }
 
        public List<string> Etiquetas { get; set; }
 
        public string IdEmpleado { get; set; }
    }

Como podemos ver tenemos una propiedad de tipo ObjectId, el cual se generará al guardar el documento en MongoDB, recordemos que todos los documentos en Mongo deben tener este ObjectId por lo tanto aquí lo tenemos en esta entidad y recordemos también que esta entidad será mapeado por Automapper a nuestra entidad de dominio Articulo que es la que en realidad van a conocer los clientes que usen este repositorio.

Y para finalizar con el repositorio de MongoDB observemos el repo específico:

    public class ArticuloRepository : BaseRepository<Articulo>, IArticuloRepository
    {
        public ArticuloRepository(string nombreColeccion = "Articulos")
            : base(nombreColeccion)
        {
        }
 
        public List<Dominio.Articulo> ObtenerArticulos()
        {
            AutoMapper.Mapper.CreateMap<Articulo, Dominio.Articulo>();
 
            ConectarDb();
            return new List<Dominio.Articulo>(ObtenerTodos().Select(c =>
                AutoMapper.Mapper.Map<Dominio.Articulo>(c)
                ));
        }
 
        public void GuardarArticulo(Dominio.Articulo articulo)
        {
            AutoMapper.Mapper.CreateMap<Dominio.Articulo, Articulo>();
            var art = AutoMapper.Mapper.Map<Articulo>(articulo);
 
            ConectarDb();
            Insertar(art);
        }
    }

Como podemos observar es un repo bastante sencillo con tan solo dos operaciones, podríamos implementar las que fueran necesarias, y podemos ver que se trabaja de igual forma que el repo de Sql Server del artículo anterior usando automapper para mapear la entidad usada por el repo a la entidad de dominio en este caso la entidad de dominio Articulo.

Y para finalizar el artículo implementaremos el último repositorio del ejemplo, el cual nos permite obtener los datos de contacto de un empleado a través de un servicio Asp.net Web Api. Si quieres obtener más información acerca de Web Api, te invito a visitar el blog de mi amigo y Crack Hernan Guzman.

En este repo usaremos directamente la entidad de dominio DatosContacto, por lo que no necesitaremos del uso de automapper, y tendremos como siempre un repositorio base el cual encapsulará la conexión a nuestra Api y tendremos un repo específico que heredará del repo base. Ahora veamos como es el código del repositorio base:

    public class BaseRepository<T> where T : class 
    {
        public string UrlApi { get; set; }
 
        public T ObtenerPorId(string id)
        {
            var client = new HttpClient { BaseAddress = new Uri("http://localhost:38417/") };
 
            client.DefaultRequestHeaders.Accept.Add(
                new MediaTypeWithQualityHeaderValue("application/json"));
 
            HttpResponseMessage response = client.GetAsync(string.Format("api/DatosContacto/{0}", id)).Result;
 
            if (response.IsSuccessStatusCode)
            {
                var datosContacto = response.Content.ReadAsStringAsync();
                return JsonConvert.DeserializeObject<T>(datosContacto.Result);
            }
            else
            {
                return null;
            }
        }
    }

Nuestro repositorio base se encarga de consumir el servicio Web Api, enviando el id del empleado para obtener en formato Json su información de contacto, posteriormente deserializa los datos de contacto en la entidad de dominio DatosContacto y la retorna. (El código de ejemplo del Api lo puedes encontrar en el repositorio en GitHub correspondiente a esta serie de artículos).

Ahora para finalizar observemos como es el código de nuestro repositorio específico para DatosContacto:

    public class DatosContactoRepository : BaseRepository<Dominio.DatosContacto>, IDatosContactoRepository
    {
        public Dominio.DatosContacto ObtenerDatosContactoEmpleado(string idEmpleado)
        {
            return ObtenerPorId(idEmpleado);
        }
    }

Es bastante simple, dado que solo tiene una operación.

Y bueno eso es todo por este artículo, en el cual implementamos los repositorios para acceso a MongoDB y para acceso a Web Api, en el próximo artículo terminaremos esta pequeña serie sobre el patrón repositorio o repositoy pattern observando como consumir los repositorios que hemos creado desde algún cliente, como por ejemplo una aplicación Asp.Net Mvc. Espero sea de utilidad y de interés para ustedes.

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

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!

[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 { get; set; }
 
        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 { get; set; }
 
        [Required]
        [StringLength(50)]
        public string Nombre { get; set; }
 
        [StringLength(10)]
        public string Telefono { get; set; }
 
        [StringLength(50)]
        public string Direccion { get; set; }
    }

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.Empleado, Empleado>();
            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!

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

El patrón repositorio o repository pattern está íntimamente relacionado con el acceso a datos y nos permite tener una abstracción de la implementación de acceso a datos en nuestras aplicaciones, de modo que nuestra lógica de negocio no conozca ni esté acoplada a la fuente de datos. En pocas palabras esto quiere decir que el repositorio actúa como un intermediario entre nuestra lógica de negocio y nuestra lógica de acceso a datos para que se centralice en un solo punto, y de esta forma se logre evitar redundancia de código. Y como dije antes al ser una abstracción del acceso a datos nos permite desacoplar y testear de una forma más sencilla nuestro código, ya que al estar desacoplado podemos generar pruebas unitarias con mayor facilidad. Adicional al estar centralizado en un solo punto de acceso, podemos reutilizar nuestra lógica de acceso a datos desde cualquier cliente, es decir desde otras aplicaciones que tengamos en nuestro entorno corporativo, incluso desde una app móvil si exponemos los repositorios a través de Apis por ejemplo.

Uno de los escenarios donde más se suele usar el patrón repositorio, es cuando tenemos múltiples fuentes de datos. Por ejemplo obtenemos gran parte de la información de una base de datos relacional Sql Server, obtenemos otros datos desde un servicio web y obtenemos otros desde una base de datos No Sql por ejemplo. en este contexto el patrón repositorio nos ayudara a centralizar el acceso a cada una de estas fuentes de datos para que nuestros aplicativos cliente no tengan que lidiar con este engorroso trabajo.

Ahora veamos cual la estructura del patrón para comprenderlo mucho mejor:

Imagen tomada de: http://msdn.microsoft.com/en-us/library/ff649690.aspx

Como podemos observar en la imagen, la lógica de negocio de nuestro cliente no interactúa directamente con la fuente de datos, ya que con este patrón la lógica de negocio es totalmente agnóstica a los datos, es decir no sabe de dónde provienen ni como se obtuvieron. Y también podemos apreciar que se comunica directamente con el repositorio el cual se encarga de hacer los mapeos necesarios y comunicarse con la fuente de datos.

Ahora veamos cómo sería la estructura si utilizamos múltiples fuentes de datos en nuestra aplicación:

Imagen tomada de Pluralsight.

Como vemos el concepto es el mismo, solo que ahora tenemos tres fuentes de datos, y podemos obtener diferentes datos de cada una de ellas, por ejemplo los empleados se obtienen y se gestionan a través de un web service, los productos en una base de datos relacional y los clientes en un archivo o grupo de archivos, también podríamos tener por ejemplo una base de datos No Sql u otro tipo de repositorio de datos. Esto recibe el nombre de persistencia poliglota y es cuando como en este caso usamos múltiples fuentes de datos, y sin lugar a dudas el patrón de repositorio nos facilita el manejo de esto, encapsulando toda la lógica que esto implica y exponiendo a la lógica de negocio de nuestros clientes los datos de tal forma que no se den por enterados de dónde provienen y no tengan que preguntar por el tipo de fuente de datos a la que desean acceder.

Y ahora que conocemos mejor el patrón, su estructura y sabemos en qué escenarios es útil usarlo vamos a ver cómo es su implementación en C#, creando una estructura de repositorios que nos permitan conectarnos a tres fuentes de datos, más exactamente Sql server a través de Entity Framework, MongoDB y una Api web, que nos exponen la información de empleados, artículos escritos por los empleados y sus datos de contacto de redes sociales, respectivamente.

Nuestra solución en Visual Studio tendrá la siguiente estructura:

En nuestro proyecto de dominio tendremos las clases Empleado.cs, Articulo.cs y DatosContacto.cs, que representarán nuestras entidades de dominio. Al interior de la carpeta Repositorios, tendremos un proyecto de repositorio para cada fuente de datos, ya que cada uno se manejará diferente, adicional un proyecto que contendrá el contrato o interfaces que se deberán usar para cada entidad de dominio. Y por último tendremos en la carpeta cliente web, un proyecto para las reglas de negocio especificas del proyecto web y un proyecto web MVC.

Veamos entonces como queda el código de nuestras tres entidades de dominio:

    public class Articulo
    {
        public string Id { get; set; }
 
        public string Titulo { get; set; }
 
        public string ContenidoHtml { get; set; }
 
        public List<string> Etiquetas { get; set; }
    }

    public class Empleado
    {
        public string Id { get; set; }
 
        public string Nombre { get; set; }
 
        public string Telefono { get; set; }
 
        public string Direccion { get; set; }
 
        public List<Articulo> Articulos { get; set; }
 
        public DatosContacto DatosContacto { get; set; }
    }

    public class DatosContacto
    {
        public string SitioWeb { get; set; }
 
        public string FaceBook { get; set; }
 
        public string Twitter { get; set; }
 
        public string LinkedIn { get; set; }
    }

Hasta el momento tenemos, la estructura base de nuestro proyecto y tenemos completo nuestro proyecto de dominio, en la segunda parte de este artículo veremos cómo construir cada uno de los repositorios para las diferentes fuentes de datos.

Bueno amigos eso es todo de esta primera parte del patrón de diseño repositorio o repository pattern, espero sea de utilidad y de interés para ustedes.

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

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!