Explication détaillée de la configuration d'ASP.NET Core par injection de dépendances dans le fichier JSON

Aujourd'hui, je vais vous présenter comment configurer l'injection de dépendances dans un fichier json.

Dans la version précédente d'ASP.NET 4 (MVC, Web Api, Owin, SingalR, etc.), des interfaces propriétaires étaient fournies pour utiliser des composants d'injection de dépendances tiers. Par exemple, nous utilisons couramment Autofac, Untiy, String.Net, etc., ces composants d'injection de dépendances tiers fournissent essentiellement un ensemble de méthodes d'injection de configuration ou de cycle de vie de configuration. En plus de la configuration directe dans la classe, ils fournissent également soit l'utilisation de fichiers XML, soit l'utilisation de json, etc., puis dans le nouvel ASP.NET Core, Microsoft nous a fourni une fonction d'injection de dépendances par défaut. Nous n'avons plus besoin de nous appuyer sur des composants tiers pour implémenter l'injection de dépendances, mais parfois nous souhaitons configurer l'injection de dépendances. dans le fichier, le composant DI de Microsoft ne nous fournit pas de fichier de configuration, nous devons donc implémenter nous-mêmes la fonction de cet élément de configuration. Personnellement, je pense que ses principaux scénarios d'utilisation sont des endroits où l'implémentation ne peut pas être déterminée au moment de la compilation et où l'implémentation doit être modifiée dynamiquement.

Voyons comment procéder.

Mise en route

Tout d'abord, dans l'application, nous créons une interface pour l'utilisation de DI :

public interface IFoo
{
  string GetInputString(string input);
}

Ensuite, ajoutez une implémentation IFoo du interface Foo

public class Foo : IFoo
{
  public string GetInputString(string input)
  {
    return $"输入的字符串为：{ input }";
  }
}

Ensuite, nous devons ajouter l'interface IFoo ci-dessus et son implémentation à la méthode ConfigureServices dans le fichier Startup.cs est principalement utilisée pour configurer le service d'injection de dépendances. Les services sont ensuite injectés via le paramètre d'interface ISerciceCollection fourni par cette méthode.

public void ConfigureServices(IServiceCollection services)
{
  services.Add(new ServiceDescriptor(serviceType: typeof(IFoo),
                    implementationType: typeof(Foo),
                    lifetime: ServiceLifetime.Transient));
}

Ici, nous utilisons la méthode Add dans IServiceCollection pour ajouter une implémentation IFoo avec un cycle de vie transitoire. Transitoire signifie qu'une instance de Foo sera créée à chaque fois qu'elle est demandée.

Ce qui précède est la méthode par défaut fournie par Microsoft pour nous permettre d'ajouter l'injection de dépendances. Voyons comment la transformer de la manière dont nous avons besoin d'utiliser les fichiers json.

Utiliser des fichiers json pour configurer DI

Lorsque nous utilisons des fichiers json pour configurer l'injection de dépendances, nous pouvons choisir de créer un nouveau fichier json ou d'utiliser directement le fichier appsettings.json. Nous allons maintenant ajouter la configuration DI directement au fichier appsettings.json.

appsettings.json

"Logging": {
  "IncludeScopes": false,
  "LogLevel": {
   "Default": "Debug",
   "System": "Information",
   "Microsoft": "Information"
  }
 },
 
 "DIServices": [
  {
   "serviceType": "[namesapce].IFoo",
   "implementationType": "[namesapce].Foo",
   "lifetime": "Transient"
  }
 ]
}

Tout d'abord, ajoutez un nœud de tableau nommé "DIServices". Le tableau contient un ou plusieurs objets qui configurent le service, serviceType représente le. Le type d'interface de service, l'implémentation de l'interface ImplementationType et la durée de vie initialisent le cycle de vie de l'instance.

Remarque : le type dans le fichier de configuration doit être un nom complet, c'est-à-dire inclure l'espace de noms.

Ensuite, ajoutez une classe de service correspondant à l'élément de configuration du fichier Json. Ici, nous devons utiliser la bibliothèque json de Newtonsoft.

using Microsoft.Extensions.DependencyInjection;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
 
public class Service
{
  public string ServiceType { get; set; }
 
  public string ImplementationType { get;set; }
 
  [JsonConverter(typeof(StringEnumConverter))]
  public ServiceLifetime Lifetime { get; set; }
}

Ensuite, vous devez modifier ConfigureServices et lire le fichier json configuré dans ConfigureServices.

public void ConfigureServices(IServiceCollection services)
{
  //services.Add(new ServiceDescriptor(serviceType: typeof(IFoo),
  //            implementationType: typeof(Foo),
  //            lifetime: ServiceLifetime.Transient));
 
  var jsonServices = JObject.Parse(File.ReadAllText("appSettings.json"))["DIServices"];
  var requiredServices = JsonConvert.DeserializeObject<List<Service>>(jsonServices.ToString());
 
  foreach (var service in requiredServices) {
    services.Add(new ServiceDescriptor(serviceType: Type.GetType(service.ServiceType),
                      implementationType: Type.GetType(service.ImplementationType),
                      lifetime: service.Lifetime));
  }
}

Ensuite, nous testons s'il est disponible.

Test

Ouvrez HomeController.cs et ajoutez l'élément d'injection :

public class HomeController : Controller
{
  private readonly IFoo _foo;
 
  public HomeController(IFoo foo)
  {
    _foo = foo;
  }
 
  public IActionResult About()
  {
    ViewData["Message"] = _foo.GetInputString("Your application description page.");
 
    return View();
  }
}

Ajoutez l'interface IFoo dans le constructeur de HomeController, puis dans À propos de Utilisé en action.

Exécutez le programme, ouvrez la page, cliquez sur l'onglet À propos

Résumé

Ce qui précède explique comment configurer l'injection de dépendances dans ASP Fichier json .NET Core, il ne s'agit que d'un exemple simple et ne doit pas être utilisé dans un environnement de production. Dans les projets réels, vous devez également gérer des problèmes tels que les exceptions lors de la lecture de la configuration, l'existence ou non du service, le cycle de vie, etc.

Pour des explications plus détaillées sur la façon dont ASP.NET Core configure l'injection de dépendances dans les fichiers JSON et les articles associés, veuillez prêter attention au site Web PHP chinois !