Inversion Of Controler -- Dependency Injection

El tema de esta entrada es tratar este patrón. Está realmente muy bien explicado en Wikipedia. En el libro de Carlos Ble, también lo trata fenomena, y es ahí donde lo oí por primera vez y lo entendí.



Ya que tenía un poco de tiempo he decidido estudiar un poco y ver un video sobre este tema de TekPub, que lo explican fenomenalmente bien.

El tema es que tengo una xubuntu 12.04 instala con monodevelop 2.8 y ni corto ni perezoso me puse a reproducir el ejemplo para ver si lo conseguía. Tengo que decir que todo ha ido de maravilla y funciona a la perfección.

Generalmente tengo la manía de hacer un proyecto en blanco y luego le voy añadiendo las distintas partes, si tiene web, pues un proyecto de web, si hay algo de test unitarios, su proyecto de test unitarios, ... También lo que hago es dentro del proyecto hacerme una carpeta, que se llama lib y ahí  meto todo lo externo que utilizo; en este caso el ninject. Por lo tanto como se puede ver en la captura de pantalla un proyecto en blanco y luego el proyecto de consola.

 
using System;
using Ninject;
using Ninject.Modules;

namespace ShoGun.Console
{
 class Program
 {
  public static void Main (string[] args)
  {
   var kernel = new StandardKernel(new RangerModelue());
   var sam = kernel.Get();
   
   sam.Attack("The unwashed masses");
   
   System.Console.Read();
  }
 }
 
 class SamuraiModelue:NinjectModule
 {
  public override void Load()
  {
   Bind<IWarrior>().To<Samurai>();
   Bind<IWeapon>().To<Sword>();
  }
 }
 
 class RangerModelue:NinjectModule
 {
  public override void Load()
  {
   Bind<IWarrior>().To<Ranger>();
   Bind<IWeapon>().To<Shuriken>();
  }
 }
}  

Es la clase principal, donde se juega con las clases Samurai, Sword, Rangery Shuriken, para luego inyectarlas a otras clases.

using System;

namespace ShoGun.Console
{
 public interface IWeapon
 {
  void Hit(string target);
 }
        
        public interface IWarrior
 {
  void Attack(string target);
 }

 }

Interfaces que no falten por favor.

 
using System;

namespace ShoGun.Console
{
 public class Shuriken : IWeapon
 {
  public Shuriken ()
  {
  }
  
  public void Hit(string target)
  {
   System.Console.WriteLine("Pierces {0}'s armor", target);
  }
 }
        public class Sword : IWeapon
 {
  public Sword ()
  {
  }
  
  public void Hit(string target)
  {
   System.Console.WriteLine("Chopped {0} clean in half", target);
  }
 }
}

Las armas, importante para luchar.

 
using System;
using Ninject;

namespace ShoGun.Console
{
 public class Samurai:IWarrior
 {
  private IWeapon _weapon;
  
  [Inject]
  public Samurai (IWeapon weapon)
  {
   _weapon = weapon;
  }
  
  public void Attack(string target)
  {
   _weapon.Hit(target);
  }
 }
}

El guerrero, interesante detalle [Inject], en el constructor, que indica que ese objecto se va a inyectar.
De esta forma también compruebo que  en linux (GNU/Linux, para no ofender a nadie) también funcionan las cosas.