Implementación Patrón Repositorio C# Entity Framework .Net Core | Parte 1

Muchas o casi todas las aplicaciones que desarrollamos, utilizan algún modo de almacenamiento de información en base de datos.

Y no siempre hablamos de una base de datos relacional como SQL Server, puede ser una base de datos documental o una lista de SharePoint.

En este sentido, es fundamental separar la lógica de negocio del acceso a base de datos, es decir evitar que la capa de negocio acceda directamente lo cual nos puede llevar a:

  • Duplicar código.
  • Posibilidad de errores a la hora de desarrollar.
  • Capa de negocios fuertemente acoplada con la capa de acceso a datos.
  • Dificultad para realizar pruebas unitarias de la capa de negocio sin dependencias externas.

Es aquí donde el patrón repositorio entra en acción.

Patrón repositorio

El patrón repositorio se encarga de separar la lógica mediante la cual se accede a los datos almacenados para ser mapeados al modelo de mi negocio o dominio de aplicación, realizar las consultas a la base de datos o impactar nuestra entidad del modelo al origen de datos utilizado. En este sentido nos permite que la capa de negocio sea agnóstica en cierta forma de la tecnología de almacenamiento que se utilice.

Esto no quiere decir que cada vez que cambio la tecnología de almacenamiento no debo tocar mi repositorio, pero la lógica de negocios no debería tener que modificarse.

How -to

Prerrequisitos

  • Visual Studio 2017 (Community Edition en mi caso)

Paso a paso

Primero generamos un proyecto de librería de clases:

1

Para contar con soporte para Entity Framework Core, debemos agregar el paquete NuGet, para ello lo haremos ejecutando la siguiente línea en la consola de administración de paquetes NuGet:

Install-Package Microsoft.EntityFrameworkCore

En mi caso agregaré una carpeta “Data” en mi proyecto “RepositoryPattern.Common”, con el objetivo de poder poner más “servicios comunes” en todo mi proyecto para ser utilizados y separarlos por lógicamente por carpeta.

2

Agregamos una interfaz de la siguiente forma:

  • Botón derecho sobre la carpeta “Data”, “Add –> New Item…”
  • Seleccionamos “Interface” y la llamaremos “IGenericRepository.cs”

Dentro de la interfaz definiremos la operaciones básicas para un CRUD o AMBL en español (Alta, modificación, eliminar, y listar)

Lo primero que haremos es importar los espacios de nombres necesarios de la siguiente forma:

using System.Linq;
using System.Linq.Expressions;

Luego definimos las operaciones:

    public interface IGenericRepository<T> where T : class
    {

        IQueryable<T> GetAll();
        IQueryable<T> Find(Expression<Func<T, bool>> predicate);
        void Add(T entity);
        void Delete(T entity);
        void Edit(T entity);
        void Save();

    }

Si observan, estamos definiendo lo siguiente

where T : class

Esto quiere decir que estamos trabajando con Generics, para poder tener mayor reutilización de código entre otras cosas, pero este punto lo dejaremos para otra publicación.

Ahora es momento de implementar nuestra interfaz, para ello agregamos una clase dentro de la carpeta “Data”, la cual llameremos “GenericRepository.cs”.

Lo primero que haremos es importar los espacios de nombres necesarios:

using System;
using System.Linq;
using System.Linq.Expressions;
using Microsoft.EntityFrameworkCore;

Luego realizamos la implementación de la interfaz:

public class GenericRepository<T> : IGenericRepository<T> where T : class
    {
        internal DbContext _context;

        public GenericRepository(DbContext context)
        {
            _context = context;
        }

        public void Add(T entity)
        {
            _context.Set<T>().Add(entity);
        }

        public void Delete(T entity)
        {
            _context.Set<T>().Remove(entity);
        }

        public void Edit(T entity)
        {
            _context.Entry(entity).State = EntityState.Modified;
        }

        public IQueryable<T> Find(Expression<Func<T, bool>> predicate)
        {
            IQueryable<T> query = _context.Set<T>().Where(predicate);
            return query;
        }

        public IQueryable<T> GetAll()
        {
            IQueryable<T> query = _context.Set<T>();
            return query;
        }

        public void Save()
        {
            _context.SaveChanges();
        }
    }

Listo, ya tenemos nuestro patrón repositorio con Entity Framework para ser utilizado en nuestras aplicaciones.

Conclusión

Mediante el patrón repositorio visto hasta el momento logramos separar la lógica de negocio del acceso a base de datos evitando:

  • Duplicar código.
  • Posibilidad de errores a la hora de desarrollar.
  • Capa de negocios fuertemente acoplada con la capa de acceso a datos.
  • Dificultad para realizar pruebas unitarias de la capa de negocio sin dependencias externas.

En la parte 2, veremos cómo utilizar lo implementado hasta el momento en una aplicación web.

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Create a free website or blog at WordPress.com.

Up ↑

%d bloggers like this: