Design patterns
Beroende på injektion
Sök…
Introduktion
Den allmänna tanken bakom Dependency Injection är att du utformar din applikation kring löst kopplade komponenter samtidigt som du följer principen om Dependency Inversion. Genom att inte bero på konkreta implementationer, gör det möjligt att designa mycket flexibla system.
Anmärkningar
Den grundläggande idén bakom beroendeinjektion är att skapa mer löst kopplad kod. När en klass istället för att uppdatera sina egna beroenden tar i sig sina beroenden istället blir klassen enklare att testa som en enhet ( enhetstestning ).
För att vidareutveckla lös koppling - tanken är att klasser blir beroende av abstraktioner, snarare än konkretioner. Om klass A beror på en annan konkret klass B , finns det ingen verklig testning av A utan B Även om den här typen av test kan vara OK, lämpar det sig inte för enhetens testbara kod. En löst kopplad design skulle definiera en abstraktion IB (som exempel) som klass A skulle bero på. IB kan sedan hånas för att ge testbart beteende, snarare än att förlita sig på den verkliga implementeringen av B för att kunna tillhandahålla testbara scenarier till A
Tätt kopplat exempel (C #):
public class A
{
public void DoStuff()
{
B b = new B();
b.Foo();
}
}
I ovanstående beror klass A på B Det finns ingen test A utan betongen B Även om detta är bra i ett integrationsprovningsscenario är det svårt att enhetstest A
En mer lös kopplad implementering av ovanstående kan se ut:
public interface IB
{
void Foo();
}
public class A
{
private readonly IB _iB;
public A(IB iB)
{
_iB = iB;
}
public void DoStuff()
{
_b.Foo();
}
}
De två implementeringarna verkar ganska lika, det finns dock en viktig skillnad. Klass A är inte längre direkt beroende av klass B , den är nu beroende av IB . Klass A inte längre har ansvar för Newing sina egna depedencies - de måste nu lämnas till A .
Inställningsinjektion (C #)
public class Foo
{
private IBar _iBar;
public IBar iBar { set { _iBar = value; } }
public void DoStuff()
{
_iBar.DoSomething();
}
}
public interface IBar
{
void DoSomething();
}
Constructor Injection (C #)
public class Foo
{
private readonly IBar _iBar;
public Foo(IBar iBar)
{
_iBar = iBar;
}
public void DoStuff()
{
_bar.DoSomething();
}
}
public interface IBar
{
void DoSomething();
}