Introduction aux méthodes d'injection de dépendances dans la configuration .NET JSON

Cet article présente principalement l'explication détaillée de la configuration de l'injection de dépendances ASP.NET Core dans les fichiers JSON. L'éditeur pense que c'est assez bon, je vais donc le partager avec vous maintenant et le donner comme référence. Suivons l'éditeur pour y jeter un œil

Avant-propos

Dans l'article précédent, j'ai écrit comment configurer la configuration globale dans MVC Préfixe de routage , aujourd'hui je vais vous présenter comment configurer l'injection de dépendances dans un fichier json.

Dans le précédent ASP.NET 4+ (MVC, Web Api, Owin, SingalR, etc.), une interface propriétaire était fournie pour une utilisation Dépendance tierce composants d'injection, par exemple, nous utilisons couramment Autofac, Untiy, String.Net, etc. Ces composants d'injection de dépendances tiers fournissent essentiellement un ensemble d'injection de configuration ou de configuration vie Le cycle La méthode, en plus de la configurer directement dans la classe, offre également la possibilité d'utiliser soit des fichiers xml, soit json, etc. Dans le nouvel ASP.NET Core, Microsoft nous l'a donné par défaut. Fournit une dépendance fonction d'injection, nous n'avons plus besoin de recourir à des composants tiers pour implémenter l'injection de dépendances, mais parfois nous souhaitons configurer l'injection de dépendances dans le fichier de configuration Les propres composants DI de Microsoft ne nous sont pas fournis. 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 de l' IFoo interface Foo

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

Ensuite, nous devons ajouter ce qui précède IFoo L'interface et son implémentation sont ajoutés à la méthode ConfigureServices dans le fichier Startup.cs. ConfigureServices est principalement utilisé pour configurer les services d'injection de dépendances. Injectez ensuite des services 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 de 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 appsettings.json déposer. 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 array nommé "DIServices", qui contient un ou plusieurs objets qui configurent le service, serviceType représente le type d'interface de service, implementationType implémentation de l'interface et lifetime initialise 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 les ConfigureServices, il suffit de lire le fichier json de la configuration ConfigureServices dans .

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

et ajoutez des éléments d'injection : HomeController.cs

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();
  }
}

dans Le constructeur

de HomeController ajoute l'interface IFoo, puis l'utilise dans l'action About.

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 un fichier json dans ASP.NET Core. Il s'agit simplement 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.

【Recommandations associées】

1. Recommandation spéciale : Téléchargez la version V0.1 de "php Programmer Toolbox"

2. Tutoriel vidéo ASP gratuit

3 Tutoriel vidéo de base ASP de Li Yanhui

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!