Inversion of Control és Dependency Injection

Az Inversion of Control (röviden IoC) alapelv egyfajta tervezési minta. Magyarul szokás emlegetni "kontrol megfordítása mintának". Sok esetben a Dependency Injection mintával jár együtt, amit szokás nevezni "függőség injektálásnak". Mindkét minta célja a modularitás növelése azáltal, hogy a kódunkból az osztályok létrehozását, paraméterezését kiemeljük és egy külső, erre a célra írt komponensre bízzuk.

Nézzünk egy példát. Tételezzük fel, hogy van egy osztályunk, ami belül példányosít még egy osztályt:

class Pelda
{
    private Pelda2 _belsoOsztaly;

    public Pelda()
    {
        _belsoOsztaly = new Pelda2();
    }
}

A fenti kódrészlettel az lesz a probléma, hogy a két osztály között direkt függőséget képez, ami a kód tesztelhetőségét nehezíti. Ha tesztelni akarjuk a Pelda osztályt, akkor Pelda2 osztályt is teszteljük indirekt módon, így önmagáról a Pelda osztály helyes működéséről nem tudunk meggyőződni, csak feltételezhetjük, hogy minden esetben jól fog működni.

Itt jön képbe a Dependency Injection. Pelda2 osztály példányosítását kiemeljük és a konstruktorhoz külső függőségként hozzáadjuk.

class Pelda
{
    private Pelda2 _belsoOsztaly;

    public Pelda(Pelda2 fuggoseg)
    {
        _belsoOsztaly = fuggoseg;
    }
}

Ez egy fokkal jobb megoldás, de még mindig direkt függőségünk van a Pelda2 osztályra. Éppen ezért a függőségeket interfészekre szokás cserélni. Az interfész leírja az osztály viselkedését, de az implementációját nem határozza meg. Ezáltal a kód újrahasználhatósága is növekszik.

class Pelda
{
    private IPelda2 _belsoFelulet;

    public Pelda(IPelda2 fuggoseg)
    {
        _belsoFelulet = fuggoseg;
    }
}

Az IoC és a Dependency Injection tipikus megvalósítási módja az, hogy használunk egy IoC konténert. Az IoC konténerben bekonfiguráljuk, hogy melyik interfész megvalósításért melyik osztályt szeretnénk példányosíttatni. Ezek után a konténerből kérjük el az interfészekhez tartozó példányokat. Ekkor a konténer megnézi, hogy az adott interfészhez melyik típust kell visszaadni. A kért típus és a konstruktor paramétereinek típusa alapján már létre tudja hozni az interfésznek megfelelő objektumot.

A .NET beépítetten nem tartalmaz IoC konténert, de számos .NET könyvtár létezik a célra. Azonban IoC konténer nélkül is tudunk IoC-t készíteni reflection segítségével.¹

Az alábbi kódrészlet egy egyszerű moduláris parancsértelmezÅ‘t mutat be. A modulok alapja az IModule interfész. Ez két taggal rendelkezik: Egy string típusú tulajdonsággal, ami a parancs nevét tárolja és egy Run metódussal, ami a modul kódját futtatja.

namespace PeldaReflection2
{
    interface IModule
    {
        string Name { get; }
        void Run();
    }
}

Ezt az interfészt két egyszerű osztály is megvalósítja.

using System;

namespace PeldaReflection2
{
    public class ModuleHello : IModule
    {
        public string Name => "Hello";

        public void Run()
        {
            Console.WriteLine("Hello");
        }
    }

    public class ModuleCls : IModule
    {
        public string Name => "Clear";

        public void Run()
        {
            Console.Clear();
        }
    }
}

Az érdekesség a fÅ‘ programban található. Ez elÅ‘ször az IModule típusa alapján beazonosítja azt a szerelvényt (dll vagy exe fájl), ami tartalmazza a típust. Majd a szerelvénybÅ‘l lekérdezi az összes olyan típust, ami létrehozható az IModule típusból. Itt érdemes megjegyezni, hogy a reflection szempontjából az interfészek is létrehozhatóak a szűrésnél használt interfészbÅ‘l, ezért érdemes tovább szűkíteni a kört osztályokra és azokon belül is nem absztrakt osztályokra.

Ezt követÅ‘en már csak a példányok létrehozására van szükség. Példányosítani az Activator osztály CreateInstance metódusával tudunk, ami jelen esetben az alapértelmezett, paraméter nélküli konstruktort hívja. De természetesen extra logikával fel tudnánk vértezni és függÅ‘ségeket is tudnánk injektálni az osztályunkba.

A fő logikája a programnak egy ciklusból áll, ami a tárolt példányok közül kikeresi a parancshoz tartozó példányt és végrehajtja a hozzárendelt kódot. A kilépés parancsát "beégetetten" definiálja a program.

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

namespace PeldaReflection2
{
    class Program
    {
        static void Main(string[] args)
        {
            //jelenlegi szerelvény lekérése
            Assembly current = typeof(IModule).Assembly;

            //Minden IModule interfészt megvalósító osztály-típus lekérése,
            //ami osztály
            var modules = from type in current.GetTypes()
                          where
                             typeof(IModule).IsAssignableFrom(type)
                             && type.IsClass
                             && !type.IsAbstract
                          select
                            type;

            //Lista a példányok tárolására
            List<IModule> instances = new List<IModule>();

            foreach (var module in modules)
            {
                //Példányosítás paraméter nélküli konstruktorral
                IModule instance = Activator.CreateInstance(module) as IModule;
                if (instance != null)
                {
                    //Példány tárolása
                    instances.Add(instance);
                }
            }

            Console.WriteLine("Parancsok: {0}", instances.Count);

            //Példányok közül megadott névvel rendelkező keresése, majd a Run metódusának hívása
            do
            {
                Console.Write("Parancs: ");
                var cmd = Console.ReadLine();

                var selected = instances.Where(i => i.Name == cmd).FirstOrDefault();
                if (selected != null)
                {
                    selected.Run();
                }
                else if (cmd == "Exit")
                {
                    break;
                }
                else
                {
                    Console.WriteLine("Nem található: {0}", cmd);
                }
            }
            while (true);

        }
    }
}

A program egy lehetséges kimenete:

Parncsok: 2
Command: Hello
Hello
Command: Exit

Függőség injektálást egyébként tudunk tulajdonságokon keresztül is végezni. Ez manuális injektálásnál vagy IoC konténer használatának mellőzésekor hasznos, de egy veszélyt rejt magában. A konstruktor injektálással biztosak lehetünk benne, hogy megkaptuk a függőségeket, mert máskülönben az osztály példánya létre se jönne, helyette valahol kivétel keletkezne.

Azonban, ha tulajdonságokon keresztül adunk át függőséget, akkor nem lehetünk benne biztosak, hogy a függőséget valóban megkaptuk. Ezért az ilyen típusú függőség injektálásnál ügyeljünk a null ellenőrzésre minden használat előtt, mert a függőségünk így külső beavatkozás következtében is null értéket vehet fel menet közben.