ASP.NET Core Options

First, to understand the configuration in ASP.NET Core, please click here: https://www.cnblogs.com/whuanle/p/13061059.html

1. Options Interfaces

In ASP.NET Core, there are three options interfaces, namely:

• IOptions<TOptions>
• IOptionsSnapshot<TOptions>
• IOptionsMonitor<TOptions>

All three methods can retrieve configuration, but the differences lie in their lifetimes and file monitoring, among other factors.

2. Injecting Configuration with IOptions

First, create an ASP.NET Core API project and add a test.json file with the following content:

{
  "Title": "测试",
  "Name": "测试测试"
}

Next, create a corresponding model class:

    public class TestModel
    {
        public string Title { get; set; }
        public string Name { get; set; }
    }

Then, add the following line in the ConfigureServices method of Startup:

            services.Configure<TestModel>(new ConfigurationBuilder().AddJsonFile("test.json").Build());

This will automatically inject the configuration service. Now, how do we receive this configuration? We can first use IOptions<T> to receive it.

Add a controller with any name, and the content is as follows:

    public class TestController : ControllerBase
    {
        private readonly TestModel _options;
        public TestController(IOptions<TestModel> options)
        {
            _options = options.Value;
        }
    }

Now you can receive the injected configuration.
This is the usage of IOptions<TOptions>.
IOptions<TOptions> has the following characteristics:
Does not support:

• Reading configuration data after the application starts.
• Named options.
  Can:
• Be registered as a singleton instance that can be injected into any service lifetime.

In other words, the configuration file is read before the application starts to create an object (singleton instance). Of course, subsequent modifications to the configuration file (.json) will not affect this object.

3. IOptionsSnapshot

Documentation explains: By using IOptionsSnapshot<TOptions>, options are computed once for each request when accessing and caching options for the request lifetime.

The lifetime of IOptionsSnapshot is scoped, meaning it is valid within a single request cycle.

Other aspects remain unchanged. Usage would be:

        private readonly TestModel _options;
        public TestController(IOptionsSnapshot<TestModel> options)
        {
            _options = options.Value;
        }

As IOptionsSnapshot updates for each request, any changes to the configuration file can be promptly received.
IOptionsMonitor is slightly different:

    public class TestController : ControllerBase
    {
        private readonly IOptionsMonitor<TestModel> _options;
        public TestController(IOptionsMonitor<TestModel> options)
        {
            _options = options;
        }
        [HttpGet("T")]
        public ContentResult T()
        {

            return new ContentResult()
            {
                Content = _options.CurrentValue.Title
            };
        }
    }

Both IOptionsSnapshot and IOptionsMonitor can detect changes in the configuration file, but IOptionsSnapshot creates a new object for each request, while IOptionsMonitor follows the singleton pattern.