Muster: Dependency Injection

Version: 2.0
.NET Version: .NET, .NET Framework

Dependeny Injection ist ein Muster zur Erstellung eines Objekts bzw. einer Objektstruktur samt seiner Abhängigkeiten, wobei diese durch einen Dritten (also durch ein anderes Objekt) injiziert, also von außen reingegeben werden. Diese Abhängigkeiten werden im Allgemeinen zur Laufzeit angebunden (spätes Binden). Im Standardfall hat dabei eine Klasse eine Abhängigkeit zu einer Schnittstelle, die dann zur Laufzeit an eine konkrete Implementierung gebunden wird.

Damit ist es möglich, die Objektstrukturen unabhängig vom Ersteller zu halten - also hat man keine Kopplung zum Ersteller. Zudem bietet es eine saubere Trennung der Belange bzgl. Objekterstellung und der Nutzung der Abhängigkeiten. Dadurch, dass die Kontrolle der Erstellung quasi nach "außen" gegeben wird, spricht man auch von Inversion of Control.

Weitere Informationen befinden sich u.a. hier: http://martinfowler.com/articles/injection.html.

Diese Muster-Version setzt eine deutliche Performance-Verbesserung bei der Initialisierung des DI-Containers Windsor

Design

Dependency Injection wird in der Regel zum Aufbau der Struktur des Strategiemusters http://de.wikipedia.org/wiki/Strategie_(Entwurfsmuster) verwendet. Hierzu wird die Abhängigkeit von außen in das Objekt gegeben, also injiziert. Im Standardfall wird bei Schleupen dieses in den Konstruktor gegeben. Das wird als Constructor Injection bezeichnet. Neben der Constructor Injection verwenden wir in wenigen Fällen auch die Property Injection, bei der eine Abhängigkeit über eine Eigenschaft injiziert wird.

Property Injection sollte nur dann verwendet werden, wenn die Eigenschaft optional ist. Denn wenn das nicht der Fall ist und die Klasse z.B. im Test von Hand erstellt werden soll, wird das Prinzip der kleinsten Verwunderung verletzt. Daher nutzen wir dies nur in absoluten Ausnahmefällen.

Dependency Injection ist ein Muster, welches nicht notwendigerweise mithilfe einer Technologie implementiert werden muss! Wir schauen uns dies nun genauer an.

Die folgende Abbildung stellt die Abhängigkeitsbeziehung von A auf IB dar:

Über den Konstruktor kann IB dabei in A gegeben werden. Die Abhängigkeit wird wie folgt durch einen Dritten - in der Abbildung Object2 - aufgelöst:

Dieser Punkt, dass Objekte durch einen dritten zusammengestellt werden, ist wichtig. Denn es wird hierbei das Ziel verfolgt, die Abhängigkeit zu Object2 außen vor zu halten. Im Normalfall ist Object2 nämlich eine spezielle Technologie - im Allgemeinen als DI-Container bezeichnet - die wir gemäß Onion Model auf der äußersten Schale halten wollen.
Das hierzu häufig als Anti-Pattern bezeichnete Muster lautet Service Locator. Siehe hierzu Service Locator is an Anti-Pattern, aber auch https://www.jimmybogard.com/service-locator-is-not-an-anti-pattern/. Wir implementieren nicht gemäß Service Locator, da wir die Kapslung aufrecht erhalten wollen und die Abhängigkeit in den tieferen Schalen nicht wollen.

In C# sieht das ganze wie folgt aus:

public class A
{
    private readonly IB b;

    public Auto(IB b)
    {
        this.b = b;
    }
}

public interface IB 
{ }

public class B : IB 
{ }

Die Dependency Injection zeigt sich dann zur Laufzeit - hier per frühem Binden gelöst:

IB b = new B(); // spätes Binden würde z.B. durch Konfiguration den konkreten Typ ermitteln und instanziieren
A a = new(b);

DI-Container

Nun wäre es relativ aufwendig, z.B. die Erstellung einer Service-Instanz mit alle seinen Abhängigkeiten (Assembler, Usecase Controller, Repository, Gateway sowie der dazu benötigten Bibliotheken) von Hand zu implementieren. Einfacher hierzu ist es, einen sogenannten Depencency Injection Container (kurz: DI-Container) zu verwenden. Dies ist eine Bibliothek / Klasse, mit der man einfach Objektstrukturen wie oben beschrieben erstellen kann.

Konventionsbasierte Registrierung im DI-Container

Ein DI-Container muss zudem aber auch wissen, welche Objekte er erstellen soll und welchen Lebenszyklus diese besitzen sollen (Singleton, transient, etc.). Über den Konstruktor-Parameter kann dieser erkennen, welche Abhängigkeiten er auflösen muss. Dies erfolgt dann entsprechend rekursiv.

Da diese Registrierung auch recht mühsam sein kann, benutzen wir Konventionen, um den Aufwand manueller Registrierungen zu vermeiden. In Schleupen.CS werden Typen, die eine gleichlautende Schnittstelle plus "I" als Präfix haben automatisch registriert.

Beispiel:
Ein BuchRepository mit der Schnittstelle IBuchRepository wird automatisch mit dem Lebenszyklus einer Service-Operation (oder transient für andere Kontexte) registriert. Siehe hierzu: Muster: Anschluss Dependency Injection in WCF-Service.

Implementierung

Das folgenden Beispiel demonstriert das Konzept noch einmal:

Gegeben sei ein Auto, das mit irgendeinem Motor bestückt werden soll:

In C# sieht das wie folgt aus:

public class Auto
{
    private readonly IMotor motor;

    public Auto(IMotor motor)
    {
        this.motor = motor;
    }

    public void LasseAn()
    {
        ...
        motor.Starte();
    }
}

public interface IMotor
{
    void Starte();
}

public class Motor : IMotor
{
    public void Starte()
    {
        // ...
    }
}

Der Typ Auto kann dann einfach über den DI-Container erstellt werden, wobei Auto ebenfalls eine passende Schnittstelle IAuto erhält:

IAuto auto = diContainer.Resolve<IAuto>();
auto.LasseAn();

Die Registrierung erfolgt in den Nutzungskontexten unterschiedlich, für Services ist dies in Muster: Anschluss Dependency Injection in WCF-Service beschrieben. Manuell geht das beispielsweise so:

IAuto Auto = diContainer.Register(Component.For<IAuto>().ImplementedBy<Auto>().LifestyleTransient());

Abgrenzung

Dieses Muster klärt nicht, wie Domänenmodelle zusammengesetzt, das heißt instanziiert werden. Dieses Muster ist nur für Architekturkomponenten wie Service, Usecase Controller, (Assembler,) Repository zu verwenden.

Für Aggregate verwenden wir keinen DI-Container.

Stärken und Schwächen

Stärken
  • Fördert Schnittstellen-orientiertes Design
  • Sorgt für lose Kopplung
  • Hält Technik in den äußeren Schichten
  • Die Software wird erweiterbar, testbar, parallel entwickelbar
Schwächen
  • Loose Kopplung erhöht die Komplexität
  • Missbrauch durch exzessive Nutzung möglich

Benutzte Muster

Chatbot not allowed
Cookie Consent mit Real Cookie Banner