IoC konténer működése

Ahhoz, hogy megértsük, hogyan is működik egy IoC konténer, érdemes egy sajátot készíteni. Ez első ránézésre ijesztően hangozhat, azonban a feladat egyáltalán nem bonyolult.

Először érdemes a tervezést egy interfész definiálásával kezdeni, ami leírja az IoC konténerünk feladatait. A konténernek két feladata van: Típusok regisztrálása (Register) és típusok feloldása (Resolve).

A feloldás jelenthet példányosítást is, vagy már egy meglévő példány visszaadását. A meglévő példány visszaadása művelet lényegében singleton típus kezelést biztosít anélkül, hogy a típusainkat singleton mintára valósítottuk volna meg.

A példaként elkészítendő IoC konténerben már a típus regisztrálásának pillanatában el kell dönteni, hogy példányosítható típust regisztrálunk, vagy singleton példányt. Az IoC konténert leíró interfész legyen a következő:

namespace SimpleIoC
{
    public interface IIoCContainer
    {
        void Register<TInterface, TClass>()
            where TInterface : class
            where TClass : class, TInterface;

        void RegisterSingleton<TInterface, TClass>()
            where TInterface : class
            where TClass : class, TInterface;

        TInterface Resolve<TInterface>()
            where TInterface : class;
    }
}

A regisztráló metódusok esetén meg kell adnunk egy interfészt és egy hozzá tartozó implementációt. Generikus megkötésekkel ki lett kötve, hogy csak olyan típus fogadunk el implementációnak, ami ténylegesen az interfész típusból öröklÅ‘dik. Azt, hogy a TInterface típus valójában interfész-e azt csak futás idÅ‘ben tudjuk ellenÅ‘rizni, mivel nincs generikus megkötés arra, hogy egy típus interfész vagy sem.

A feloldó metódus (Resolve) esetén csak az interfészt kell megadnunk.

Ahhoz, hogy rendes és kulturált hibakezelésünk legyen, definiáljunk egy saját kivétel osztályt, amibe majd az IoC konténer működése során keletkező hibákat csomagoljuk. Az osztály definíciója a következő:

using System;

namespace SimpleIoC
{
    [Serializable]
    public class ResolveException : Exception
    {
        public ResolveException(Type t) :
            base($"A következő típust nem lehet feloldani: {type.FullName}") { }

        public ResolveException() : base() { }

        public ResolveException(string message) :
            base(message) { }

        public ResolveException(string message, Exception innerException) : 
            base(message, innerException) { }
    }
}

A konténer implementációja a következő:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;

namespace SimpleIoC
{
    public class IoCContainer : IIoCContainer
    {
        private Dictionary<Type, Type> _instances;
        private Dictionary<Type, object> _singletons;

        public IoCContainer()
        {
            _instances = new Dictionary<Type, Type>();
            _singletons = new Dictionary<Type, object>();
        }

        public void Register<TInterface, TClass>()
            where TInterface : class
            where TClass : class, TInterface
        {
            _instances.Add(typeof(TInterface), typeof(TClass));
        }

        public void RegisterSingleton<TInterface, TClass>()
            where TInterface : class
            where TClass : class, TInterface
        {
            _singletons.Add(typeof(TInterface), CreteInstance(typeof(TClass)));
        }

        public TInterface Resolve<TInterface>() where TInterface : class
        {
            Type requested = typeof(TInterface);
            return Resolve(requested) as TInterface;
        }

        private object Resolve(Type requested)
        {
            if (_singletons.ContainsKey(requested))
            {
                return _singletons[requested];
            }

            if (_instances.ContainsKey(requested))
            {
                return CreteInstance(_instances[requested]);
            }

            throw new ResolveException(requested);
        }

        private object CreteInstance(Type requested)
        {
            ConstructorInfo[] constructors = requested.GetConstructors();

            ConstructorInfo full = (from constructor in constructors
                                    where
                                        constructor.IsPublic
                                    orderby
                                        constructor.GetParameters().Length descending
                                    select
                                        constructor).FirstOrDefault();

            if (full == null)
                throw new ResolveException($"A következő típusnak nincs publikus konstruktora: {requestedType.FullName}");

            try
            {

                var parameters = full.GetParameters();
                var dependencies = new List<object>(parameters.Length);

                foreach (var parameter in parameters)
                {
                    object resolved = Resolve(parameter.ParameterType);
                    dependencies.Add(resolved);
                }

                return Activator.CreateInstance(requested, dependencies.ToArray());
            }
            catch (Exception ex)
            {
                throw new ResolveException($"A következő típust nem lehet létrehozni: {requestedType.FullName}", ex);
            }
        }
    }
}

A program a példányokat és a singleton típusokat két külön Dictionary típusban tárolja. Típus feloldásnál a singleton típusok élveznek prioritást.

A Register és a RegisterSingleton metódusokban ellenÅ‘rizve van, hogy a TInterface valóban interfész-e. Ha ez nem interfész, vagy már korábban regisztrálva lett a típus, akkor hibát kapunk.

A típusfeloldás egy privát, object típust visszaadó Resolve metóduson keresztül történik Type információk alapján. Erre azért van szükség, mert a típus konstruktorának hívásakor reflection-nel ilyen formában kapjuk vissza a típusinformációkat. A CreteInstance metódus a típus implementációjában megkeresi a legtöbb paraméterrel rendelkezÅ‘ konstruktort, majd a belsÅ‘ Resolve metódust használva rekurzív módon összegyűjti a függÅ‘ségeket. A Ezt követÅ‘en példányosítja a kért típust.

A konténert a következÅ‘ példakóddal teszteljük, amelyben a RandomInstance nevű osztály függ egy ILog és egy IRandomProvider példánytól. A kapott ILog implementációval naplózni tudunk, az IRandomProvider segítségével pedig véletlenszámot tudunk elkérni. Az osztály és a hozzá tartozó interfész a következÅ‘:

namespace SimpleIoCPelda
{
    public interface IRandomInstance
    {
        void Print();
    }

    public class RandomInstance : IRandomInstance
    {
        private readonly ILog _log;
        private readonly int _number;

        public RandomInstance(ILog log, IRandomProvider randomProvider)
        {
            _log = log;
            _number = randomProvider.RandomGenerator.Next(0, 100);
        }

        public void Print()
        {
            _log.Write("Instance created. Random number: {0}", _number);
        }
    }
}

A fÅ‘ program az ILog és az IRandomProvider interfészek implementációit Singleton módban regisztrálja, mert ezekbÅ‘l egy lesz a program teljes életciklusa során. Ezt követÅ‘en a program regisztrálja a RandomInstance osztály implementációját is annak interfészével. Ezt követÅ‘en 10 alkalommal feloldja az osztályhoz tarozó interfészt az IoC konténeren keresztül, ami a függÅ‘ségek feloldása és injektálása után egy példányt fog visszaadni.

Ezen a példányon a Print metódus meghívásával ellenÅ‘rizzük, hogy a függÅ‘ségek feloldása és a példányosítás sikeresen megtörtént-e. A tesztprogram kódja a következÅ‘:

using SimpleIoC;
using System;

namespace SimpleIoCPelda
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                var container = new IoCContainer();
                container.RegisterSingleton<IRandomProvider, RandomProvider>();
                container.RegisterSingleton<ILog, Log>();

                container.Register<IRandomInstance, RandomInstance>();

                for (int i = 0; i < 10; i++)
                {
                    IRandomInstance instance = container.Resolve<IRandomInstance>();
                    instance.Print();
                }
            }
            catch (ResolveException ex)
            {
                Console.WriteLine(ex.Message);
            }

            Console.ReadKey();
        }
    }
}

A program kimenete:

Instance created. Random number: 11
Instance created. Random number: 42
Instance created. Random number: 46
Instance created. Random number: 84
Instance created. Random number: 13
Instance created. Random number: 55
Instance created. Random number: 64
Instance created. Random number: 9
Instance created. Random number: 88
Instance created. Random number: 90

Az ILog és IRandomProvider interfészek és implementációik:

using System;

namespace SimpleIoCPelda
{
    public interface ILog
    {
        void Write(string format, params object[] parameters);
    }

    public class Log : ILog
    {
        public void Write(string format, params object[] parameters)
        {
            Console.WriteLine(format, parameters);
        }
    }
    
    public interface IRandomProvider
    {
        Random RandomGenerator { get; }
    }

    public class RandomProvider : IRandomProvider
    {
        public RandomProvider()
        {
            RandomGenerator = new Random();
        }

        public Random RandomGenerator { get; }
    }
}

IoC konténer projektek

.NET alatt számos IoC konténer implementáció létezik különböző keretrendszerek részeként, vagy önállóan. Ezért, ha nincsenek nagyon speciális igényeink, akkor a projektünkben érdemes egy bejáratott, több funkcióval rendelkező IoC konténert alkalmaznunk. A legnépszerűbb konténer projektek sorrendtől függetlenül:

• Microsoft.Extensions.DependencyInjection – https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection

• Castle.Windsor – https://github.com/castleproject/Windsor

• Ninject – http://www.ninject.org/

• Prism – http://prismlibrary.github.io

• Unity – https://unitycontainer.github.io/index.html

Ezen konténerek közös jellemzője, hogy akár egy szerelvény összes típusát regisztrálni tudják, illetve a konstruktor hívás és példányosítás különböző típusok esetén stratégiákkal módosítható, konfigurálható.