Implementación de Patron Repository con IoC y DI en Web API

Dependencias:

Instalar el siguiente paquete utilizando la consola de Paquetes Nuget

Install-Package Unity -Version 4.0.1

PerRequestLifetimeManager.cs

namespace WebApiClient.App_Start
{    
    using Microsoft.Practices.Unity;
    using System;
    using System.Web; 

    /// <summary>
    /// Clase que encapsula la gestión del ciclo de vida de los objetos que son generados
    /// por el patron de Inyección de Dependencias.
    /// </summary>
    public class PerRequestLifetimeManager: LifetimeManager, IDisposable
    {        
        // Clave del storage.
        private readonly Guid Key = Guid.NewGuid();     
        
        /// <summary>
        /// Método que obtiene el objeto que se encuentra activo en el storage.
        /// </summary>
        /// <returns>Objeto.</returns>
        public override object GetValue()
        {
            if (HttpContext.Current != null && HttpContext.Current.Items.Contains(Key))            
                return HttpContext.Current.Items[Key];            
            else            
                return null;            
        }

        /// <summary>
        /// Método para quitar el objeto del storage.
        /// </summary>
        public override void RemoveValue()
        {
            if (HttpContext.Current != null)            
                HttpContext.Current.Items.Remove(Key);            
        }

        /// <summary>
        /// Método para almacenar un objeto en el storage.
        /// </summary>
        /// <param name="newValue">Objeto.</param>
        public override void SetValue(object newValue)
        {
            if (HttpContext.Current != null)            
                HttpContext.Current.Items[Key] = newValue;            
        }

        /// <summary>
        /// Método para liberar los recursos de memoria.
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Método para liberar los recursos cuando sea requerido.
        /// </summary>
        /// <param name="disposing">Valor que indica si se desea liberar los recursos.</param>
        protected virtual void Dispose(bool disposing)
        {
            if (disposing)            
                RemoveValue();            
        }
    }
}

IoCFactory.cs

namespace WebApiClient.App_Start
{    
    using Domain.Contracts;
    using Infrastructure.Implementation;
    using Infrastructure.Persistence;
    using Microsoft.Practices.Unity;
    using System.Data.Entity;    

    /// <summary>
    /// Clase que encapsula la implementación del patrón de
    /// inyección de dependencias e inversión de control para
    /// el repositorio genérico y unidad de trabajo.
    /// </summary>
    public class IoCFactory
    {        
		// Propiedad que encapsula el contenedor.		
        private static readonly IUnityContainer UnityContainer = new UnityContainer();
				
		// Propiedad que expone el contenedor.		
        public static IUnityContainer Container { get { return UnityContainer; } }
        
        /// <summary>
        /// Método encargado de llevar acabo los patrones de IoC y DI para el repositorio genérico
        /// y unidad de trabajo.
        /// </summary>
        public static void RegisterTypes()
        {
            UnityContainer.RegisterType(typeof(IRepository<>), typeof(Repository<>));
            UnityContainer.RegisterType(typeof(IUnitOfWork), typeof(UnitOfWork));
            UnityContainer.RegisterType(typeof(DbContext), typeof(Context));
            UnityContainer.RegisterInstance(new DbContextAdapter(UnityContainer.Resolve<DbContext>()), new PerRequestLifetimeManager());            
            UnityContainer.RegisterType<IObjectSetFactory>(new InjectionFactory(x => x.Resolve<DbContextAdapter>()));
            UnityContainer.RegisterType<IObjectContext>(new InjectionFactory(x => x.Resolve<DbContextAdapter>()));
        }        
    }
}

 FabricaCategoria.cs 

namespace WebApiClient.App_Code.Fabricas
{    
    using Infrastructure.Contracts;
    using Domain.Entities;    

    /// <summary>
    /// Fabrica para controlador de categoría.
    /// </summary>
    public class FabricaCategoria
    {        
        // Repositorio que encapsula la gestión de categorias.        
        private IRepository<Categoria> repositorioCategoria;

        // Unidad de trabajo.        
        private IUnitOfWork unidadTrabajo;
 
        // Propiedad publica para recuperar el repositorio de categoría.        
        public IRepository<Categoria> RepositorioCategoria { get { return repositorioCategoria; }}

        // Propiedad publica para recuperar la unidad de trabajo.        
        public IUnitOfWork UnidadTrabajo { get { return unidadTrabajo; }}        
        
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="repositorioCategoria">Repositorio Categoria.</param>
        /// <param name="unidadTrabajo">Unidad de Trabajo.</param>
        public FabricaCategoria(IRepository<Categoria> repositorioCategoria, IUnitOfWork unidadTrabajo)
        {
            this.repositorioCategoria = repositorioCategoria;
            this.unidadTrabajo = unidadTrabajo;
        }        
    }
}

CategoriaController.cs

namespace WebApiClient.Controllers
{    
    using Microsoft.Practices.Unity;
    using Resources;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Web.Http;
    using System.Web.Http.Cors;
    using App_Code;
    using App_Code.Fabricas;
    using App_Start;

    /// <summary>
    /// Controlador que contiene WebMethods para gestionar la información de las categorías.
    /// </summary>
    [EnableCors("*", "*", "*")]
    public class CategoriaController : BaseController
    {        
        // Variable que encapsula la fabrica para la gestión de categorias.        
        private FabricaCategoria fabricaCategoria;        
        
        /// <summary>
        /// Constructor.
        /// </summary>
        public CategoriaController()
        {
            fabricaCategoria = IoCFactory.Container.Resolve<FabricaCategoria>();
        }

        /// <summary>
        /// Método para obtener todas las categorías de un tipo.
        /// </summary>
        /// <param name="tipoCategoriaId">Identificador del tipo de categoría.</param>
        /// <returns>HttpResponseMessage que contiene el resultado de la ejecución del método.</returns>
        [HttpGet]
        public HttpResponseMessage ObtenCategorias(int tipoCategoriaId)
        {            
            try
            {
				return Request.CreateResponse(HttpStatusCode.OK, fabricaCategoria.RepositorioCategoria.Find(x => x.TipoCategoriaId == tipoCategoriaId && x.Activo).OrderBy(x => x.Nombre).ToList());                
            }
            catch (Exception ex)
            {
				return Request.CreateResponse(HttpStatusCode.InternalServerError, "No fue posible obtener la información de las categorias.");                
            }            
        }
    }
}

 

Agregar comentario

Loading