有没有办法修改 IOptionsSnapshot<t> 以编程方式而不是更改源文件？</t>

Question

I have a transient class registered in ASP.NET Core's DI.

An IOptions<T> is injected into its constructor. For every request and when needed, during runtime and based on a condition, I want to have another instance of IOptions injected.

Since IOptionsSnapshot<T> gets updated for every request when the source file gets updated, is there a way to mimic this behavior but instead of a change in the file, I want to programmatically make a change in IOptions , and before constructor injection, during runtime when a request comes in?

And use IOptionsSnapshot<T> instead of IOptions<T> for that.

Update:

Condition example to be run before injection happens somewhere in the app like maybe a controller or action custom attribute? In the attribute check a value and so:

if (some condition) 
    Options.cnnectionstring = "string1"; 
else
    Options.cnnectionstring = "string2";

Injected into a class like this:

public class Books
{
    private readonly string connectionString;
    
    public Books(IOptions<DBOptions> options)
    {
        this.connectionString = options.Value.connectionString;
    }
    public void SomeMethod()
    {
        ....  //uses connectionString
    }
}       

Registered like this:

services.Configure<DBOptions>(options =>
{
    options.connectionString = "some connection string";
});     

    

Answer 1

IOption (like IConfiguration) is registered as singleton , but the request is scoped. Then it isn't possible to use request's information to modify the configuration.

You can use a intermediate scoped service, that retrieve the request's information and generate the desired connection string, like:

public class BooksConnectionString
{
    public IConfiguration _configuration;
    public IHttpContextAccessor _httpContextAccessor;

    public BooksConnectionString(IConfiguration configuration, IHttpContextAccessor httpContextAccessor)
    {
        _configuration = configuration;
        _httpContextAccessor = httpContextAccessor;
    }

    public string ConnectionString
    {
        get
        {
            var library = _httpContextAccessor.HttpContext.Request.Query["library"].First();
            return _configuration.GetConnectionString(library);
        }
    }
}

Register the service as scoped:

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        ...
        services.AddHttpContextAccessor();
        services.AddScoped<BooksConnectionString>();
    }
    ...
}

Then you can inject like:

public class Books
{
    private readonly string connectionString;

    public Books(BooksConnectionString options)
    {
        this.connectionString = BooksConnectionString.ConnectionString;
    }
} 

It's suppose you can modify the class where the connection string is injected. If you can't modify this class, then you can register IOption as scoped:

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        ...
        services.AddHttpContextAccessor();
        services.AddScoped<IOptions<DBOptions>>(p =>
        {
            var configuration = p.GetService<IConfiguration>();
            var httpContextAccessor = p.GetService<IHttpContextAccessor>();
            var library = httpContextAccessor.HttpContext.Request.Query["library"].First();
            var dbOptions = configuration.GetSection("Databases").GetSection(library).Get<DBOptions>();
            return Options.Create(dbOptions);
        });
    }
    ...
}

Warning, IOption are expected as singleton. Register IOption as scoped would break this expectation. To be used as a last resort.