[IoC] Ninject

Ostatni post, dotyczący kontenerów IoC pokazuje możliwości Ninjecta. Jest to stosunkowo nowy (2007), darmowy kontener. W celu dodania go do projektu w Visual Studio korzystamy z NuGeta.

Pracę z kontenerem pokazano poniżej:

using (var ninjectContainer = new StandardKernel())
{
    ninjectContainer.Bind<IEngine>().To<GasEngine>();
    var car4 = ninjectContainer.Get<AudiA4>();
    car4.Run();
}

Podobnie jak w większości przypadków nie musimy rejestrować wszystkich typów (tych, o które nie prosimy przez interfejs). Poniżej kilka innych ciekawych funkcjonalności:

public class AudiA4Module : NinjectModule
{
    public override void Load()
    {
        Kernel.Bind<IEngine>().To<DieselEngine>().InSingletonScope();
        Kernel.Rebind<IEngine>()
            .ToMethod(context =>
                                {
                                    var rnd = new Random();
                                    var num = rnd.Next()%2;
                                    if (num == 1)
                                        return new GasEngine();
                                    else
                                        return new DieselEngine();
                                });
    }
}

using (var ninjectContainer = new StandardKernel(new AudiA4Module()))
{
    var car5 = ninjectContainer.Get<AudiA4>();
    car5.Run();
}

Moduły wspierają separację kodu konfigurującego. Nie musimy bindować koniecznie do typu, możemy dokonać bindingu do metody, gdzie wykonujemy jakąś logikę. Ponadto warto pamiętać, że domyślnie zwrócony zostanie zawsze nowy obiekt. Możemy to zmienić, wywołując na przykład metodę InSingletonScope (dla singletonów). Co więcej binding można odwołać metodą Rebind.

[IoC] StructureMap

Kolejnym ciekawym kontenerem IoC, po Unity i Castle of Windsor, jest StructureMap. API wszystkich trzech jest bardzo podobne, choć StructureMap rozwijany jest od 2004 roku i początkowo korzystało się z niego w zupełnie inny sposób. W celu dodania go do projektu w Visual Studio korzystamy z NuGeta.

Aby wykorzystać StructureMap, musimy pamiętać, aby używać .NET Framework 4.0 w wersji pełnej (nie zadziała wersja Client Profile. Pracę z kontenerem pokazano poniżej:

using(var structureMapContainer = new Container())
{
    structureMapContainer.Configure(x => x.For<IEngine>().Use<GasEngine>());
    var car3 = structureMapContainer.GetInstance<AudiA4>();
    car3.Run();
}

Konfiguracja odbywa się przez lambda expressions, nie musimy rejestrować wszystkich typów (tych, o które nie prosimy przez interfejs). Poniżej kilka innych użytecznych funkcjonalności:

public class AudiA4Registry : Registry
{
    public AudiA4Registry()
    {
        For<IEngine>().LifecycleIs(new SingletonLifecycle()).Use<DieselEngine>();
    }

using (var structureMapContainer = new Container(new AudiA4Registry()))
{
    var car3 = structureMapContainer.TryGetInstance<AudiA4>();
    if(car3 != null)
        car3.Run();
}

Rejestry pozwalają na odseparowanie kodu konfigurującego kontener. Metoda TryGetInstance zwróci w przypadku powyższego kodu null, ponieważ typ nie jest jawnie zarejestrowany.

[IoC] Castle Windsor

Obok Unity, drugim interesującym kontenerem IoC jest Castle Windsor. Oba kontenery udostępniają całkiem podobne API, warto jednak znać podstawowe różnice. Castle Windsor jest open - sourcowym projektem, jednym z pierwszych .NET-owych kontenerów IoC.W celu dodania go do projektu w Visual Studio korzystamy z NuGeta.

Podstawową przewagą nad Unity jest możliwość stworzenia własnych instalatorów - obiektów implementujących interfejs IWindsorInstaller. W instalatorze takim możemy skonfigurować część zależności. Podczas tworzenia kontenera mamy możliwość dodania wielu instalatorów.

public class AudiA4Installer : IWindsorInstaller
{
    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        container.Register(Component.For<AudiA4>().LifeStyle.Transient);
        container.Register(Component.For<IEngine>()
            .ImplementedBy<DieselEngine>().LifeStyle.Transient);
    }
}

Różnice w stosunku do Unity są dwie: musimy rejestrować typy o które prosimy bezpośrednio (nie przez interfejs), domyślny cykl życia obiektu to Singleton, dlatego konieczne jest ustawienie Transient - tworzenie nowej instancji przy każdym Resolve.

using (var windsorContainer = new WindsorContainer())
{
    windsorContainer.Install(new AudiA4Installer());
    var car2 = windsorContainer.Resolve<AudiA4>();
    car2.Run();
}

Castle Windsor wstrzykuje zarówno przez konstruktor jak i przez setter, tak więc klasa wyższego poziomu może być skonstruowana na dwa sposoby.

[IoC] Unity

Unity jest kontenerem IoC dostarczanym przez firmę Microsoft. Można go spotkać, jako część biblioteki Enterprise Library, lub pograć managerem pakietów NuGet.

Do projektu dodajemy poniższą referencję:

using Microsoft.Practices.Unity;

Przykład użycia kontenera Unity:

using (var unityContainer = new UnityContainer())
{
    unityContainer.RegisterType<IEngine, DieselEngine>();
    //Setter Injection
    unityContainer.RegisterType<IEngine, DieselEngine>(new InjectionProperty("Power", "100"));
    var car2 = unityContainer.Resolve<AudiA4>();
    car2.Run();
}

Z przykładu tego wynikają dwa fakty. Po pierwsze, jeżeli chcemy dostać typ i prosimy o niego metodą Resolve, a jako parametr generyczny podajemy typ, a nie interfejs, to nie musimy takiego typu rejestrować. Po drugie możemy wstrzykiwać także pojedyncze propercje poprzez klasę InjectionProperty.

Jeżeli chcemy zarejestrować jakiś obiekt, jako singleton, to podajemy przez parametr sposób, w jaki kontener ma zarządzać takim obiektem. Domyślnie mamy typ TransientLifetimeManager, który za każdym razem tworzy nową instancję. Dla singletonów wybieramy ContainerControlledLifetimeManager.

using (var unityContainer = new UnityContainer())
{
    //Singleton
    unityContainer.RegisterType<IEngine, GasEngine>(new ContainerControlledLifetimeManager());
    var car2 = unityContainer.Resolve<AudiA4>();
    car2.Run();
}

Widzimy, że za Unity przemawia proste API zaspokajające podstawowe potrzeby przy wstrzykiwaniu zależności.

[IoC] Kontenery IoC

Kontenerem IoC można w skrócie nazwać pewien mechanizm wykonujący wstrzykiwanie zależności (Dependency Injection). Funkcjonalnością kontenera musi być możliwość konfiguracji zależności jakie zachodzą między obiektami. Kiedy prosimy kontener o typ podając mu na przykład interfejs, wie co ma nam zwrócić, a także wie jakie zależności powinien dany obiekt posiadać (czym różni się od wzorca ServiceLocatora).

Przykład zależności pomiędzy obiektami:

public class AudiA4
    {
        private readonly IEngine _engine;

        public AudiA4(IEngine engine)
        {
            _engine = engine;
        }

        public void Run()
        {
            _engine.Run();
        }
    }

    public interface IEngine
    {
        void Run();
    }

    public class DieselEngine : IEngine
    {
        public void Run()
        {
            Console.Write("Diesel engine running...");
        }
    }

Kontener tworzą dwie metody. Pierwsza pozwala na rejestrowanie typów w słowniku. Typy rejestrowane powinny być po interfejsach tylko wtedy jeżeli implementujemy dany interfejs więcej niż raz. W przeciwnym wypadku tworzymy niepotrzebne byty. Druga metoda tworzy obiekt na podstawie wcześniej skonfigurowanych zależności. W C# możemy skorzystać z mechanizmu Reflection, przez co zajmuje nam to bardzo mało kodu. Ponieważ w bardziej rozbudowany aplikacjach możemy mieć wielopoziomowe grafy obiektów, metodę Resolve wołamy rekurencyjnie, aby rozwiązać wszystkie zależności.

public class IocContainer
{
    private Dictionary<Type, Type> dependencyMap;

    public IocContainer()
    {
        dependencyMap = new Dictionary<Type, Type>();
    }

    public T Resolve<T>()
    {
        return (T) Resolve(typeof(T));
    }

    private object Resolve(Type type)
    {
        Type resolvedType = null;
        try
        {
            resolvedType = dependencyMap[type];
        }
        catch
        {
            throw new KeyNotFoundException(String.Format("Cannot resolve type {0}", type.FullName));
        }
        var ctor = resolvedType.GetConstructors().First();
        var parameters = ctor.GetParameters();
        if (parameters.Count() == 0)
            return Activator.CreateInstance(resolvedType);
        IList<object> @params = new List<object>();
        foreach (var parameter in parameters)
        {
            @params.Add(Resolve(parameter.ParameterType));
        }
        return ctor.Invoke(@params.ToArray());
    }

    public void Register<TFrom, TTo>()
    {
        dependencyMap.Add(typeof(TFrom), typeof(TTo));
    }
}

Przykład użycia kontenera:

static void Main(string[] args)
{
    var container = new IocContainer();
    container.Register<AudiA4, AudiA4>();
    //zależnie od konfiguracji
    container.Register<IEngine, DieselEngine>();
    var car = container.Resolve<AudiA4>();
    car.Run();
}