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

En el artículo anterior observamos cómo crear los repositorios para MongoDB y para Asp.Net Web Api, ahora observaremos como consumir estos repositorios que hemos creado a lo largo de esta serie desde una aplicación, en este caso usaremos una aplicación web Asp.Net MVC, desde la cual consumiremos todos los repositorios. Entonces crearemos un módulo para administrar los empleados que recordemos están en una base de datos Sql Server, incluyendo sus datos de contacto que recordemos están expuestos en un servicios Web Api y un módulo para administrar los artículos escritos por estos empleados que recordemos están almacenados en una base de datos documental en MongoDB. Lo primero que vamos a hacer es crear un sitio Asp.Net MVC en Visual Studio, y una vez lo tengamos vamos a crear los controladores para el formulario de empleados y para el formulario de artículos, y obviamente vamos a crear sus vistas, teniendo una estructura como la siguiente:

Recordemos que nuestros controladores se comunicarán con nuestros repositorios, por lo cual los debemos referenciar a nuestro proyecto Asp.Net MVC, de esta forma vamos a utilizar todo el acceso a las diferentes fuentes de datos (Sql server, MongoDB y Web Api) y nuestra aplicación web no sabrá de donde provienen los datos y por ende estará desacoplada del acceso a datos. Visualmente tendremos un Crud bastante sencillo para los empleados y sus datos de contacto y un crud para los artículos como se aprecia en las siguientes imágenes:

Ahora veamos el código de nuestros controladores y como se comunican con los repositorios:

        private IEmpleadoRepository empleadoRepository;
 
        // GET: Empleado
        public ActionResult Index()
        {
            empleadoRepository = new EmpleadoRepository();
            var empleados = empleadoRepository.ObtenerEmpleados();
            return View(empleados);
        }
 
        // GET: Empleado/Details/5
        public ActionResult Details(string id)
        {
            empleadoRepository = new EmpleadoRepository();
            var empleado = empleadoRepository.ObtenEmpleadoPoId(id.ToString());
 
            var datosRepository = new DatosContactoRepository();
            empleado.DatosContacto = datosRepository.ObtenerDatosContactoEmpleado(id.ToString());
 
            return View(empleado);
        }
 
        // POST: Empleado/Create
        [HttpPost]
        public ActionResult Create(Empleado model)
        {
            try
            {
                empleadoRepository = new EmpleadoRepository();
                model.Id = DateTime.Now.Ticks.ToString();
                empleadoRepository.GuardarEmpleado(model);
 
                return RedirectToAction("Index");
            }
            catch
            {
                return View(model);
            }
        }

Como podemos ver, en nuestro controlador de Empleados, en la acción Index creamos una instancia de EmpleadoRepository y hacemos uso del método ObtenerEmpleados, el cual se encarga de obtener los empleados almacenados en la base de datos Sql Server, recordemos que dicho repositorio implementa una interface y adicional hereda de un repositorio base, lo cual nos brinda la oportunidad de cambiar por otra implementación concreta en caso de que sea necesario.

De esta forma nuestros repositorios nos ayudan a aislar todas las operaciones de acceso a datos, por ejemplo en este caso, obtuvimos datos de Sql Server y adicional datos de un Web Api, y nuestra aplicación Asp.Net MVC no se dio por enterada de dónde salieron los datos. Ahora observemos el controlador para interactuar con los artículos escritos por los empleados que recordemos están en una base de datos No Sql como lo es MongoDB.

        private IArticuloRepository _articuloRepository;
 
        // GET: Articulo
        public ActionResult Index()
        {
            _articuloRepository = new ArticuloRepository();
            var articulos = _articuloRepository.ObtenerArticulos();
            return View(articulos);
        }
 
        // GET: Articulo/Create
        public ActionResult Create()
        {
            return View();
        }
 
        // POST: Articulo/Create
        [HttpPost]
        [ValidateInput(false)]
        public ActionResult Create(Articulo model)
        {
            try
            {
                _articuloRepository = new ArticuloRepository();
                _articuloRepository.GuardarArticulo(model);
 
                return RedirectToAction("Index");
            }
            catch
            {
                return View();
            }
        }

Como podemos observar, de igual forma nuestro controlador de artículos se comunica solo con nuestro repositorio y en ningún momento sabe que los datos provienen o se llevan a una base de datos MongoDB.

Y bueno amigos, con esto damos por terminada esta mini serie sobre el patrón repositorio o repository pattern, espero que sea de utilidad para ustedes.

Artículos anteriores de la serie:

Implementando patrón repositorio - Repository pattern en C# Parte III
Implementando patrón repositorio - Repository pattern en C# Parte II
Implementando patrón repositorio - Repository pattern en C# Parte I

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 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!

[WebCast] Avanet - Web móvil, Introducción a No Sql, KnocKoutJS, EmberJS, Google DART

Hola amigos, les comparto el evento virtual de nuestra comunidad Avanet realizado el día de hoy 30/11/2013, donde se tocan bastantes temas interesantes como Web Móvil con BootStrap, knockoutjs, MVC 5, Ember.js, No sql y demás, en esta oportunidad estuve compartiendo una introducción a las bases de datos No Sql y como usar MongoDB con C#, espero les sea de utilidad:

Creando un mini blog con Asp.net y MongoDB

En este artículo vamos a ver como crear un mini blog utilizando asp.net conectándonos a una base de datos no sql como lo es MongoDB, que es una base de datos documental que usa archivos en formato JSON para almacenar información. para mayor detalle acerca de esta base de datos remitirse al su sitio oficial http://www.mongodb.org/

Para una introducción a las bases de datos no sql, recomiendo observar mi presentación anterior:
http://eltavodev.blogspot.com/2013/07/introduccion-las-bases-de-datos-no-sql.html

Lo primero que debemos hacer para realizar nuestro ejemplo es descargar e instalar la base de datos MongoDB, para su instalación se deben seguir las siguientes instrucciones:
http://docs.mongodb.org/manual/installation/

Una vez instalada nuestra base de datos, debemos descargar las dll que ofrece MongoDB para trabajar en la plataforma .NET, estas dll las descargamos en la siguiente url:
http://docs.mongodb.org/ecosystem/tutorial/getting-started-with-csharp-driver/#getting-started-with-csharp-driver

Ahora creamos un proyecto web asp.net en nuestro Visual Studio, y agregamos la referencia de la dll MongoDB.Driver.dll, y en nuestra página agregamos la instrucción:

using MongoDB.Driver;
using MongoDB.Driver.Builders;

Con estas referencias ya podemos interactuar con la base de datos.

Ahora vamos a iniciar a implementar nuestro ejemplo, en el cual podremos guardar un nuevo articulo en nuestro blog y buscarlo posteriormente. Visualmente es de la siguiente forma:

En primera instancia vamos a crear un método para abrir la conexión con nuestra base de datos y especificamos en que colección vamos a guardar o consultar:

private void ConectarDB()
{
      string connectionString = "mongodb://localhost";
      MongoClient client = new MongoClient(connectionString);
      MongoServer server = client.GetServer();
      MongoDatabase database = server.GetDatabase("MiBlog");
      this.collection = database.GetCollection<Articulo>("Articulos");
}

En el fragmento de código anterior especificamos una cadena de conexión básica, con los objetos MongoClient y MongoServer obtenemos acceso al servidor de base de datos, con el objeto MongoDataBase especificamos a que base de datos nos deseamos conectar y con el método GetCollection indicamos que queremos efectuar operaciones sobre la colección Articulos, el termino colección en Mongo se puede homologar como una tabla en una base de datos relacional.

Como en nuestro ejemplo vamos a usar nuestros objetos del dominio para almacenarlos en la base de datos, y no estructuras dinámicas vamos a crear una entidad Articulo para almacenarla en nuestra colección de artículos:

public class Articulo
{
      public ObjectId Id { get; set; }
 
      public string Titulo { get; set; }
 
      public string Contenido { get; set; }
}

Ahora en el evento click de nuestro botón guardar vamos a copiar lo siguiente:

this.ConectarDB();
 
Articulo articulo = new Articulo { Titulo = this.txtTitulo.Text, Contenido = this.txtContenido.Text };
this.collection.Insert(articulo);

En el fragmento de código anterior, en primer lugar nos conectamos a nuestra base de datos, posteriormente creamos un nuevo objeto artículo con los datos digitados por el usuario y por ultimo lo insertamos en la base de datos.

Para finalizar nuestro ejemplo vamos a ver como recuperar un artículo de nuestra base de datos, donde el titulo contenga las palabras digitadas por el usuario en el cuadro de texto de búsqueda, para ello copiamos lo siguiente en el evento click del botón Buscar:

this.ConectarDB();
var query = Query<Articulo>.Matches(c => c.Titulo, this.txtBusqueda.Text);
Articulo articulo = collection.FindOne(query);
 
this.txtTitulo.Text = articulo.Titulo;
this.txtContenido.Text = articulo.Contenido;

Con el fragmento de código anterior, en primer lugar nos conectamos a nuestra base de datos, luego con una expresión lambda especificamos que se busquen los artículos cuyo titulo contenga las palabras digitadas en el cuadro de texto de búsqueda, y posteriormente decimos que nos traiga un solo artículo con la extensión FinOne, y por ultimo mostramos el artículo al usuario.

Con esto damos por terminado nuestro ejemplo de como crear un blog básico con Asp.net y MongoDB, espero los sea de gran utilidad, a continuación el link de descarga del código de ejemplo:

https://www.dropbox.com/s/le3xw5opf7ry8cp/Ejemplo%20MongoDB.rar

Saludos y buena suerte!!!