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

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

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

Use json file to configure DI

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

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

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.

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

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

Test

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

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

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.

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!