Inversion Of Control


Inversion Of Control

La Inversion Of Control o IOC es un patrón de desarrollo que oculta la implementación de nuestro código mediante una Interfaz. Dos son las principales ventajas que aporta:

  • Rompe dependencias: Permite reemplazar una parte del código sin afectar al resto; posibilitando ser más flexible frente cambios.
  • TDD: Aísla el código, permitiendo aplicar test unitarios.

Su uso se complementa con otros dos patrones:

  • Dependency Injection: Permite crear la clases a partir de la interfaz.
  • Service Locator: Permite definir que clase corresponde al interfaz.

Existen diferentes librerías que proporcionan soporte a IOC:
Microsoft Unity framework, Castle Windsor, NInject,…

Ejemplo en Unity

Se adjunta un ejemplo rápido usando la libraria de Microsoft Unity de este patrón.

  • 1.- Incluir Unity Package en los proyectos.
    Unity Package
  • 2.- Definimos la interfaz que define la funcionalidad.
    namespace Core.Import.Customer
    {
        public interface ICustomerImportService
        {
            void Import();
        }
    }
    
  • 3.- Definimos la clase que implementa la interfaz.
    namespace Core.Import.Customer
    {
        public class CustomerImportService: ICustomerImportService
        {
            public void Import()
            {
               Código que implementa la interfaz....
            }
        }
    }
    
  • 4.- Clase de infraestructura accesible desde todos los proyectos.
    using Microsoft.Practices.Unity;
    
    namespace Infrastructure.Ioc
    {
        public static class UnityContainerFactory
            {
                public static IUnityContainer Container { get; set; }
            }
    }
    
  • 5.- Clase BootStrapper que definen que clases que implementan las interfaces.
    using Microsoft.Practices.Unity;
    using Infrastructure.Ioc;
    using Core.Import.Customer;
    
    namespace App.Ioc
    {
        public static class BootStrapper
        {
            public static void Register()
            {
                var container = new UnityContainer();
                container.RegisterType<ICustomerImportService, CustomerImportService>();
                UnityContainerFactory.Container = container;
            }
        }
    }
    

    NOTA: Al registrar la clase se puede indicar; como se obtendrá la instancia (LifeTime Managers). Los principales 3 son:

    • TransientLifetimeManager: Siempre se crea nueva instancia.
    • ContainerControlledLifetimeManager: Singleton, es decir siempre la misma instancia.
    • PerThreadLifetimeManager: La misma instancia por Thread.
  • 6.- Ya podemos instanciar la clase definida de la interfaz ;-).
    var customerImportService = UnityContainerFactory.Container.Resolve<ICustomerImportService>();
    customerImportService.Import();
    
    • Anuncios
Esta entrada fue publicada en net, Patron Software. Guarda el enlace permanente.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s