DependencyInjectionRepository

Abhängigkeitsinjektion

Beispielbeispiel mit Asp.net-Kern

Link zum aufgezeichneten Video: https://www.youtube.com/watch?v=oVj1IHw8GLU

OverviewOfDI: https://github.com/sandeepmvn/DependencyInjectionRepository/blob/master/OverviewOfDI.txt

ASP.NET Core unterstützt das Softwareentwurfsmuster Dependency Injection (DI), eine Technik zum Erreichen der Inversion of Control (IoC) zwischen Klassen und ihren Abhängigkeiten.

Durch den IoC-Container können wir dies erreichen

1. Lose gekoppelte Klassen
2. Verwalten der Lebensdauer des Objekts
3. Fügt der Klasse Abhängigkeiten hinzu
4. Einfache Änderung der Implementierung
5. Testgetriebene Entwicklung (TDD)

Im Asp.net-Kern verfügt der IoC-Container über integrierte Schnittstellen.

1. IServiceProvider
2. IServiceCollection

Der folgende DI-Lebenszyklus wird sein

1. Registrieren:-
   1. Der Container muss wissen, welcher Objekt-/Abhängigkeitstyp instanziiert werden soll.
   2. Im Asp.net-Kern werden Dienste mithilfe von „IServiceCollection“ registriert.
   3. Diese Dienste werden normalerweise in der Methode „Startup.ConfigureServices“ der App registriert.
2. Lösen:-
   1. Wenn wir einen IoC-Container verwenden, erstellen wir Objekte nicht manuell, sondern Container übernimmt dies für uns.
   2. Im Asp.net-Kern übernimmt das Framework die Verantwortung für die Erstellung einer Instanz der Abhängigkeit mit Unterstützung des integrierten Containers (IServiceProvider).
3. Entsorgen: – Die Lebensdauer des Objekts/der Abhängigkeit wird nur vom IOC-Container verwaltet

Grundsätzlich gibt es in ASP.NET Core zwei Arten von Diensten:

Framework-Dienste: Dienste, die Teil des ASP.NET Core-Frameworks sind, wie IApplicationBuilder, IHostingEnvironment, ILoggerFactory usw.

Anwendungsdienste: Die Dienste (benutzerdefinierte Typen oder Klassen), die Sie als Programmierer für Ihre Anwendung erstellen.

Abhängigkeitsinjektion in Controller (MVC): -

Asp.Net Core MVC-Controller fordert Abhängigkeiten explizit über Konstruktoren an: 1. Konstruktorinjektion, 2. Methodeninjektion (Aktionsebene), 3. Propery-Injektion (nicht unterstützt), 4. View-Injektion

1. Konstruktorinjektion: – Dienste werden als Konstruktorparameter hinzugefügt und lösen den Dienst zur Laufzeit aus dem Dienstcontainer (IServiceCollection – DiContainer) auf. Dienste werden normalerweise mithilfe nicht-konkreter Klassen (Schnittstellen) definiert.

2. Methodeninjektion: – Die Verwendung des Attributs [FromService] ermöglicht die direkte Injektion eines Dienstes in eine Aktionsmethode, ohne die Controller-Injektion zu verwenden

3. Property-Injection Derzeit unterstützt der integrierte IOC-Container (Asp.net-Kern) keine Property-Injection. Hierfür können Sie sich für integrierte Service-Container (IOC) von Drittanbietern entscheiden.

4. View-Injection Mit der [Inject]-Direktive können Sie den Dienst direkt in die Ansichtsseite einfügen, ohne einen Controller oder eine Methodeninjektion zu verwenden

Lebensdauer

Der integrierte IoC-Container unterstützt drei Arten von Lebensdauer:

1. Singleton:
   1. Singleton-Lebensdauerdienste (Statusdienst) werden erstellt, wenn sie zum ersten Mal angefordert werden (oder wenn „ConfigureServices“ ausgeführt wird, wenn Sie dort eine Instanz angeben), und jede nachfolgende Anforderung verwendet dann während der gesamten Anwendungslebensdauer „dieselbe Instanz“.
   2. Core bietet Ihnen integrierte Erweiterungsmethoden
      1. Add() (ServiceLifetime.Singleton)
      2. AddSingleton()
2. Vorübergehend:
   1. Vorübergehende lebenslange Dienste werden bei jeder Anforderung erstellt. Diese Lebensdauer eignet sich am besten für einfache, „zustandslose Dienste“.
   2. Core bietet Ihnen integrierte Erweiterungsmethoden
      1. Add() mit (ServiceLifetime.Transient)
      2. AddTransient()
3. Umfang:
   1. Umfangreiche lebenslange Dienste werden einmal pro Anfrage erstellt und in einer einzigen Anfrage geteilt.
   2. Core bietet Ihnen integrierte Erweiterungsmethoden
      1. Add() mit (ServiceLifetime.Scoped)
      2. AddScoped()
      3. AddDBContext()

Registrieren des Simple Application Service

Im Beispielbeispiel definiert die Dienstschnittstelle „IMyDependency“ die Methode „WriteMessage“.

  public interface IMyDependency
  {
      void WriteMessage(string message);
  }

Diese Schnittstelle wird durch einen konkreten Typ, MyDependency, implementiert:

  public class MyDependency : IMyDependency
  {
      public void WriteMessage(string message)
      {
          Console.WriteLine($"MyDependency.WriteMessage Message: {message}");
      }
  }

Registriert nun den Dienst „IMyDependency“ mit dem konkreten Typ „MyDependency“ (in Startup.cs).

  public class Startup
  {
      public void ConfigureServices(IServiceCollection services)
      {
          services.Add(new ServiceDescriptor(typeof(IMyDependency), new MyDependency()));        
      }

  }

Hier wird die Add()-Methode der Instanz „IServiceCollection“ verwendet, um einen Dienst bei einem IoC-Container zu registrieren. Der „ServiceDescriptor“ dient zur Angabe der Art des Dienstes und der konkreten Implementierung. Dadurch wird unser Dienst im Container standardmäßig als „Singleton“ registriert.

Lassen Sie uns nun Dienste mit unterschiedlichen Lebenszeiten einfügen

1. Singleton (Anwendungsfall: wenn wir einen Staatsdienst erstellen müssen):

   Services.Add(new ServiceDescriptor(typeof(IMyDependency), new MyDependency(),ServiceLifetime.Singleton));

2. Vorübergehend (Anwendungsfall: wenn wir einen zustandslosen Dienst erstellen müssen):

   Services.Add(new ServiceDescriptor(typeof(IMyDependency), new MyDependency(),ServiceLifetime.Transient));

3. Geltungsbereich (Anwendungsfall: Datenbankdienst):

   Services.Add(new ServiceDescriptor(typeof(IMyDependency), new MyDependency(),ServiceLifetime.Scoped));

Wir können die Dienste auch mithilfe integrierter Erweiterungsmethoden einbinden

1. Singleton

   Services.AddSingleton(); oder Services.AddSingleton(typeof(IMyDependency), typeof(MyDependency));

2. Vorübergehend

   Services.AddTransisent(); oder Services.AddTransient(typeof(IMyDependency), typeof(MyDependency));

3. Zielfernrohr

   Services.AddScoped(); oder Services.AddScoped(typeof(IMyDependency), typeof(MyDependency));

Beispiel mit Konstruktorinjektion

öffentliche Klasse HomeController: Controller { private readonly IMyDependency _service;

 public HomeController(IMyDependency service)
{
    _service = service;
}

public IActionResult Index()
{
    _service.WriteMessage("Constructor level injection")
   
    return View();
}

}

Beispiel mit Aktionsinjektion

 public class HomeController : Controller
{
  //Fromservice attribute
  public IActionResult Index([FromService]IMyDependency service)
  {
      service.WriteMessage("Action level injection")
      return View();
  }
}

Beispiel mit View-Injection

öffentliche Klasse HomeController: Controller {

 public IActionResult Index()
{
    return View();
}

}

In Index.cshtml

@{ ViewData["Title"] = "Homepage"; }

 //using Inject directive

@inject IMyDependency service

//code block
@{
  service.WriteMessage("View level Injection");
}

Rufen Sie Dienste ohne Injektion manuell mithilfe von HttpContext ab

öffentliche Klasse HomeController: Controller {

 public IActionResult Index()
{
    var services = this.HttpContext.RequestServices;
    var dependencyservice = (IMyDependency)services.GetService(typeof(IMyDependency));
    dependencyservice.WriteMessage("without injection, accessing dependent services");
    return View();
}

}