Introduction to dependency injection methods in .NET configuration JSON

This article mainly introduces the detailed explanation of ASP.NET Core configuring dependency injection in JSON files. The editor thinks it is quite good, so I will share it with you now and give it as a reference. Let’s follow the editor and take a look.

Preface

In the previous article, I wrote how to configure global in MVC Routing prefix, today I will introduce to you how to configure dependency injection in a json file.

In the previous ASP.NET 4+ (MVC, Web Api, Owin, SingalR, etc.), proprietary interfaces were provided for use Third-party dependency injection components, for example, we commonly use Autofac, Untiy, String.Net, etc. These third-party dependency injection components basically provide a set of configuration injection or configuration life The cycle method, in addition to directly configuring it into the class, also provides the option of using xml files, or using json, etc. In the new ASP.NET Core, Microsoft has given us this by default Provides a dependency injection function, we no longer need to resort to third-party components to implement dependency injection, but sometimes we want to configure dependency injection in Configuration File, Microsoft's own DI component does not We are not provided with a configuration file, so we need to implement the function of this configuration item ourselves. Personally, I feel that its main usage scenarios are places where the implementation cannot be determined at compile time and the implementation needs to be modified dynamically.

Let’s take a look at how to do this.

Getting Started

First, in the application we create an interface for DI use:

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

Then, add a IFoo implementation of the interface Foo

##

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

Next, we need to add the above

The IFoo interface and its implementation are added to the ConfigureServices method in the Startup.cs file. ConfigureServices is mainly used to configure dependency injection services. Then inject Services through the ISerciceCollection interface parameter provided by this method.

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

Here, we use the Add method in IServiceCollection to add an implementation of

IFoo with a transient life cycle. Transient means that an instance of Foo will be created every time a request is made.

The above is the default method of adding dependency injection provided by Microsoft. Let's take a look at how to transform it into the way we need to use json files.

Use json file to configure DI

When we use json file to configure dependency injection, we can choose to create a new json file or directly use the appsettings.json file. Now we will add the DI configuration directly to the appsettings.json file.

appsettings.json

 "Logging": {
  "IncludeScopes": false,
  "LogLevel": {
   "Default": "Debug",
   "System": "Information",
   "Microsoft": "Information"
  }
 },

 "DIServices": [
  {
   "serviceType": "[namesapce].IFoo",
   "implementationType": "[namesapce].Foo",
   "lifetime": "Transient"
  }
 ]
}

First, add an

arraynode named "DIServices", which contains one or more A object that configures service, serviceType represents the type of service interface, implementationType the implementation of the interface, lifetime initializes the life cycle of the instance.

Note: The type in the configuration file must be the full name, that is, include the namespace.

Next, add a service class corresponding to the Json file configuration item. Here we need to use the Newtonsoft json library.

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

Then you need to modify the ConfigureServices, and

read the json file of the configuration in 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));
  }
}

Then we test whether it is available.

Test

Open

HomeController.cs , add the injection item:

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

Add the IFoo interface in HomeController's

constructor , and then use it in About's Action.

Run the program, open the page, click the About tab

##Summary

The above is to configure dependency injection into a json file in ASP.NET Core. This is just a simple example and should not be used in a production environment. In actual projects, you also need to deal with issues such as exceptions when reading configuration, whether the service exists, life cycle, etc.

【Related Recommendations】

1. Special Recommendation: "php Programmer Toolbox" V0.1 version download

2. ASP Free Video Tutorial

3. Li Yanhui ASP Basic Video Tutorial

The above is the detailed content of Introduction to dependency injection methods in .NET configuration JSON. For more information, please follow other related articles on the PHP Chinese website!