Design patterns
Afhankelijkheid injectie
Zoeken…
Invoering
Het algemene idee achter Dependency Injection is dat u uw applicatie ontwerpt rond los gekoppelde componenten terwijl u zich houdt aan het Dependency Inversion Principle. Door niet afhankelijk te zijn van concrete implementaties, kunnen zeer flexibele systemen worden ontworpen.
Opmerkingen
Het basisidee achter afhankelijkheidsinjectie is om meer losjes gekoppelde code te maken. Wanneer een klasse, in plaats van zijn eigen afhankelijkheden te vernieuwen, in plaats daarvan zijn afhankelijkheden opneemt, wordt de klasse eenvoudiger om als eenheid te testen ( eenheid testen ).
Om verder te gaan met losse koppeling - het idee is dat klassen afhankelijk worden van abstracties, in plaats van concreties. Als klasse A afhankelijk is van een andere concrete klasse B , dan is er geen echte test van A zonder B Hoewel dit soort tests OK kan zijn, leent het zich niet voor testbare code-eenheden. Een losjes gekoppeld ontwerp zou een abstractie IB (als een voorbeeld) definiëren waarvan klasse A afhankelijk zou zijn. IB kan vervolgens worden bespot om testbaar gedrag te bieden, in plaats van te vertrouwen op de echte implementatie van B om testbare scenario's aan A te kunnen bieden.
Strak gekoppeld voorbeeld (C #):
public class A
{
public void DoStuff()
{
B b = new B();
b.Foo();
}
}
In het bovenstaande hangt klasse A af van B Er is geen test A zonder het concrete B Hoewel dit prima is in een integratietestscenario, is het moeilijk om test A te testen.
Een meer losjes gekoppelde implementatie van het bovenstaande kan eruit zien als:
public interface IB
{
void Foo();
}
public class A
{
private readonly IB _iB;
public A(IB iB)
{
_iB = iB;
}
public void DoStuff()
{
_b.Foo();
}
}
De twee implementaties lijken redelijk op elkaar, er is echter een belangrijk verschil. Klasse A is niet langer direct afhankelijk van klasse B , het is nu afhankelijk van IB . Klasse A niet langer de verantwoordelijkheid om zijn eigen afhankelijkheden te vernieuwen - deze moeten nu aan A worden verstrekt.
Zetter injectie (C #)
public class Foo
{
private IBar _iBar;
public IBar iBar { set { _iBar = value; } }
public void DoStuff()
{
_iBar.DoSomething();
}
}
public interface IBar
{
void DoSomething();
}
Constructor injectie (C #)
public class Foo
{
private readonly IBar _iBar;
public Foo(IBar iBar)
{
_iBar = iBar;
}
public void DoStuff()
{
_bar.DoSomething();
}
}
public interface IBar
{
void DoSomething();
}