DependencyInjectionRepository

Injection de dépendance

Exemple d'exemple utilisant le noyau Asp.net

Lien vidéo enregistré : https://www.youtube.com/watch?v=oVj1IHw8GLU

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

ASP.NET Core prend en charge le modèle de conception logicielle d'injection de dépendances (DI), qui est une technique permettant de réaliser l'inversion de contrôle (IoC) entre les classes et leurs dépendances.

Grâce au conteneur IoC, nous pouvons réaliser

1. Classes faiblement couplées
2. Gestion de la durée de vie d'un objet
3. Injecte des dépendances dans la classe
4. Facile à modifier la mise en œuvre
5. Développement piloté par les tests (TDD)

Dans le noyau Asp.net, IoC Container possède des interfaces intégrées.

1. IServiceProvider
2. IServiceCollection

Le cycle de vie DI suivant sera

1. Registre:-
   1. Le conteneur doit savoir quel type d'objet/dépendance doit instancier.
   2. Dans le noyau Asp.net, les services sont enregistrés à l’aide de « IServiceCollection ».
   3. ces services sont généralement enregistrés dans la méthode "Startup.ConfigureServices" de l'application.
2. Résoudre:-
   1. Lorsque nous utilisons le conteneur IoC, nous ne créons pas d'objets manuellement, Container le fait pour nous.
   2. Dans le noyau Asp.net, le framework assume la responsabilité de créer une instance de la dépendance avec la prise en charge du conteneur intégré (IServiceProvider).
3. Dispose : - La durée de vie de l'objet/de la dépendance sera prise en charge uniquement par le conteneur IOC.

Il existe essentiellement deux types de services dans ASP.NET Core :

Services de framework : services qui font partie du framework ASP.NET Core tels que IApplicationBuilder, IHostingEnvironment, ILoggerFactory, etc.

Services d'application : services (types ou classes personnalisés) que vous, en tant que programmeur, créez pour votre application.

Injection de dépendances dans le contrôleur (MVC) : -

Dépendances de demande du contrôleur Asp.Net Core MVC explicitement via les constructeurs 1. Injection de constructeur 2. Injection de méthode (niveau d'action) 3. Injection de propriété (non prise en charge) 4. Injection de vue

1. Injection de constructeur : - Les services sont ajoutés en tant que paramètre de constructeur et le runtime résout le service à partir du conteneur de services (IServiceCollection-- DiContainer). Les servicesa sont généralement définis à l'aide d'une classe non concrète (interfaces)

2. Injection de méthode : - L'utilisation de l'attribut [FromService] permet d'injecter un service directement dans une méthode d'action sans utiliser l'injection de contrôleur.

3. Injection de propriétés Actuellement (noyau Asp.net), le conteneur IOC intégré ne prend pas en charge l'injection de propriétés. Pour cela, vous pouvez opter pour des conteneurs de services intégrés (IOC) tiers.

4. La directive View Injection Using [Inject] permet d'injecter le service directement dans la page d'affichage sans utiliser de contrôleur ou d'injection de méthode.

Durée de vie

Le conteneur IoC intégré prend en charge trois types de durée de vie :

1. Singleton:
   1. Les services à vie Singleton (service d'État) sont créés la première fois qu'ils sont demandés (ou lorsque ConfigureServices est exécuté si vous y spécifiez une instance), puis chaque demande ultérieure utilisera la "même instance", tout au long de la durée de vie de l'application.
   2. Core vous fournit des méthodes d'extension intégrées
      1. Ajouter() (ServiceLifetime.Singleton)
      2. AjouterSingleton()
2. Transitoire :
   1. Les services à durée de vie transitoire sont créés à chaque fois qu'ils sont demandés. Cette durée de vie fonctionne mieux pour les « services légers et sans état ».
   2. Core vous fournit des méthodes d'extension intégrées
      1. Ajouter() avec (ServiceLifetime.Transient)
      2. AjouterTransient()
3. Portée :
   1. Les services à vie étendus sont créés une fois par demande et seront partagés en une seule demande.
   2. Core vous fournit des méthodes d'extension intégrées
      1. Ajouter() avec (ServiceLifetime.Scoped)
      2. AddScoped()
      3. AjouterDBContext()

Enregistrement du service d'application simple

Dans l'exemple d'exemple, l'interface de service « IMyDependency » définit la méthode « WriteMessage »

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

Cette interface est implémentée par un type concret, MyDependency :

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

Maintenant, enregistre le service "IMyDependency" avec le type concret "MyDependency" (dans startup.cs)

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

  }

Ici, la méthode Add() de l'instance "IServiceCollection" est utilisée pour enregistrer un service auprès d'un conteneur IoC. Le « ServiceDescriptor » permet de préciser le type de service et sa mise en œuvre concrète. Cela enregistrera notre service dans un conteneur avec par défaut "Singleton".

Maintenant, injectons des services avec des durées de vie différentes

1. Singleton (Cas d'utilisation : lorsqu'on doit créer un service d'état) :

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

2. Transitoire (Cas d'utilisation : lorsque nous devons créer un service sans état) :

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

3. Portée (Cas d'utilisation : Service de base de données) :

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

Nous pouvons également injecter les services en utilisant des méthodes d'extension intégrées

1. Singleton

   services.AddSingleton(); ou services.AddSingleton(typeof(IMyDependency), typeof(MyDependency));

2. Transitoire

   services.AddTransisent(); ou services.AddTransient(typeof(IMyDependency), typeof(MyDependency));

3. Portée

   services.AddScoped(); ou services.AddScoped(typeof(IMyDependency), typeof(MyDependency));

Exemple avec injection de constructeur

public class HomeController : Contrôleur {privé en lecture seule IMyDependency _service ;

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

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

}

Exemple avec injection d'action

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

Exemple avec injection de vue

classe publique HomeController : Contrôleur {

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

}

Dans Index.cshtml

@{ ViewData["Titre"] = "Page d'accueil"; }

 //using Inject directive

@inject IMyDependency service

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

Sans injection, obtenez les services manuellement à l'aide de HttpContext

classe publique HomeController : Contrôleur {

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

}