Asp.Net Core Using Ioptions And Ioptionssnapshot Complete Guide

Step 1: Set Up a New ASP.NET Core Project

First, let’s create a new ASP.NET Core Web Application. You can use .NET CLI or Visual Studio.

Using .NET CLI:

dotnet new web -n IOptionsDemo
cd IOptionsDemo

Using Visual Studio:

• Open Visual Studio.
• Create a new project by selecting "ASP.NET Core Web Application".
• Choose "Web Application" and make sure .NET 6.0 LTS or any version is selected.
• Name the project "IOptionsDemo".

Step 2: Create Options Classes

We need some classes to hold our configuration options.

Create a folder named Options in your project and add the following classes:

1. AppSettingsOptions.cs

namespace IOptionsDemo.Options
{
    public class AppSettingsOptions
    {
        public string Title { get; set; }
        public int Timeout { get; set; }
        public bool IsDebug { get; set; }
    }
}

Step 3: Configure Options in appsettings.json

Add the following configuration to your appsettings.json:

{
    "Logging": {
        "LogLevel": {
            "Default": "Information",
            "Microsoft.AspNetCore": "Warning"
        }
    },
    "AllowedHosts": "*",
    "AppSettings": {
        "Title": "My ASP.NET Core App",
        "Timeout": 60,
        "IsDebug": true
    }
}

Step 4: Configure Services in Program.cs

In this step, we will register our options classes and services in the Program.cs file.

Update your Program.cs file as follows:

using IOptionsDemo.Options;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Configure the AppSettingsOptions
builder.Services.Configure<AppSettingsOptions>(builder.Configuration.GetSection("AppSettings"));

// Register services that consume IOptions<T>
builder.Services.AddSingleton<ServiceUsingIOptions>();
builder.Services.AddSingleton<ServiceUsingIOptionsSnapshot>();

// Build the app
var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

Step 5: Create Services to Consume IOptions and IOptionsSnapshot

Create a folder named Services and add the following classes inside it:

1. ServiceUsingIOptions.cs

This service uses IOptions<T>.

using IOptionsDemo.Options;
using Microsoft.Extensions.Options;

public class ServiceUsingIOptions
{
    private readonly AppSettingsOptions _options;

    public ServiceUsingIOptions(IOptions<AppSettingsOptions> options)
    {
        _options = options.Value;
    }

    public void DisplayOptions()
    {
        Console.WriteLine($"Using IOptions: Title = {_options.Title}, Timeout = {_options.Timeout}, IsDebug = {_options.IsDebug}");
    }
}

2. ServiceUsingIOptionsSnapshot.cs

This service uses IOptionsSnapshot<T>.

using IOptionsDemo.Options;
using Microsoft.Extensions.Options;

public class ServiceUsingIOptionsSnapshot
{
    private readonly IOptionsSnapshot<AppSettingsOptions> _optionsSnapshot;

    public ServiceUsingIOptionsSnapshot(IOptionsSnapshot<AppSettingsOptions> optionsSnapshot)
    {
        _optionsSnapshot = optionsSnapshot;
    }

    public void DisplayOptions()
    {
        var options = _optionsSnapshot.Value;
        Console.WriteLine($"Using IOptionsSnapshot: Title = {options.Title}, Timeout = {options.Timeout}, IsDebug = {options.IsDebug}");
    }
}

Step 6: Add a Controller to Use the Services

Now let's create a controller named OptionsController inside the Controllers folder to invoke our services and display the configuration.

using Microsoft.AspNetCore.Mvc;

namespace IOptionsDemo.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class OptionsController : ControllerBase
    {
        private readonly ServiceUsingIOptions _serviceUsingIOptions;
        private readonly ServiceUsingIOptionsSnapshot _serviceUsingIOptionsSnapshot;

        public OptionsController(ServiceUsingIOptions serviceUsingIOptions, ServiceUsingIOptionsSnapshot serviceUsingIOptionsSnapshot)
        {
            _serviceUsingIOptions = serviceUsingIOptions;
            _serviceUsingIOptionsSnapshot = serviceUsingIOptionsSnapshot;
        }

        [HttpGet("ioptions")]
        public IActionResult GetWithIOptions()
        {
            _serviceUsingIOptions.DisplayOptions();
            return Ok("Check the console for IOptions output.");
        }

        [HttpGet("ioptionssnapshot")]
        public IActionResult GetWithIOptionsSnapshot()
        {
            _serviceUsingIOptionsSnapshot.DisplayOptions();
            return Ok("Check the console for IOptionsSnapshot output.");
        }
    }
}

Step 7: Testing the Application

1. Run the application using dotnet run or through Visual Studio.
2. Open your browser and navigate to https://localhost:5001/swagger (or the correct URL if your port number differs).
3. Use the Swagger UI to make requests to the OptionsController endpoints:
   • GET api/options/ioptions should output the configuration with IOptions.
   • GET api/options/ioptionssnapshot should output the configuration with IOptionsSnapshot.

Check the console for the output.

Explanation

IOptions

• Lifetime: Singleton for the application lifetime.
• Usage: Ideal for immutable configuration data.
• Behavior: Once loaded, it won’t reload any changes in the configuration source.

IOptionsSnapshot

• Lifetime: New instance per request.
• Usage: Ideal when you need configuration data that might change during the application’s lifetime.
• Behavior: Reloads configuration data every request. It provides a fresh snapshot of the data.

By following these steps, you should now have a good understanding of how to work with IOptions and IOptionsSnapshot in an ASP.NET Core application.