using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.Options;
using Microsoft.Extensions.Primitives;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
namespace ConsoleApp1
{
internal class Program
{
/*
* 1. IOptions单例，获取的值是同一个实例
* 2. IOptionsSnapshot scope， 每次请求获取的值是不同的实例，但是在生命周期内是同一个实例
* 3. IOptionsMonitor单例，获取的值是同一个实例，当配置发生变化时，会更新实例
*
* 4. Configure<>, ConfigureOptions<>, AddOptions<> 三者的区别:
* 4.1 Configure<> 使用ConfigureNamedOptions配置选项
* 4.2 ConfigureOptions<> 使用自定义IConfigureNamedOptions
* 4.3 AddOptions<>, 使用ConfigureNamedOptions<T, Dep>配置选项，使其可以依赖注入
*/
static async Task Main(string[] args)
{
var services = new ServiceCollection();
services.MyConfigure<MyOptions>(x => x.Name = new Random().Next(10000).ToString());
var provider = services.BuildServiceProvider();
var opt1 = provider.GetRequiredService<IOptions<MyOptions>>();
Console.WriteLine(opt1.Value.Name);
var opt2 = provider.GetRequiredService<IOptions<MyOptions>>();
Console.WriteLine(opt2.Value.Name);
var opt3 = provider.GetRequiredService<IOptionsSnapshot<MyOptions>>();
Console.WriteLine(opt3.Get(Options.DefaultName).Name);
var opt4 = provider.GetRequiredService<IOptionsSnapshot<MyOptions>>();
Console.WriteLine(opt4.Get(Options.DefaultName).Name);
using var scope = provider.CreateScope();
var scopeProvider = scope.ServiceProvider;
var opt11 = scopeProvider.GetRequiredService<IOptions<MyOptions>>();
Console.WriteLine(opt11.Value.Name);
var opt21 = scopeProvider.GetRequiredService<IOptions<MyOptions>>();
Console.WriteLine(opt21.Value.Name);
var opt31 = scopeProvider.GetRequiredService<IOptionsSnapshot<MyOptions>>();
Console.WriteLine(opt31.Get(Options.DefaultName).Name);
var opt41 = scopeProvider.GetRequiredService<IOptionsSnapshot<MyOptions>>();
Console.WriteLine(opt41.Get(Options.DefaultName).Name);
Console.ReadKey();
}
}
public class MyOptions
{
public string Name { get; set; }
}
public interface IOptions<T>
{
T Value { get; }
}
public interface IConfigureOptions<T> where T : class
{
void Configure(T config);
}
public interface IConfigureNamedOptions<T> : IConfigureOptions<T> where T : class
{
void Configure(string? name, T options);
}
public interface IPostConfigureOptions<T> where T : class
{
void PostConfigure(string? name, T options);
}
public interface IOptionsFactory<T> where T : class
{
T Create(string name);
}
public interface IOptionsSnapshot<T> where T : class
{
T Get(string? name);
}
public interface IOptionsMonitor<T> where T : class
{
T CurrentValue { get; }
T Get(string? name);
IDisposable? OnChange(Action<T, string?> listener);
}
public interface IOptionsChangeTokenSource<T> where T : class
{
IChangeToken GetChangeToken();
string? Name { get; }
}
public class ConfigureNamedOptions<T> : IConfigureNamedOptions<T> where T : class
{
public ConfigureNamedOptions(string? name, Action<T>? action)
{
Name = name;
Action = action;
}
public string? Name { get; }
public Action<T>? Action { get; }
public virtual void Configure(string? name, T options)
{
// Null name is used to configure all named options.
if (Name == null || name == Name)
{
Action?.Invoke(options);
}
}
public void Configure(T options) => Configure(Options.DefaultName, options);
}
public class ConfigureNamedOptions<TOptions, TDep> : IConfigureNamedOptions<TOptions>
where TOptions : class
where TDep : class
{
public ConfigureNamedOptions(string? name, TDep dependency, Action<TOptions, TDep>? action)
{
Name = name;
Action = action;
Dependency = dependency;
}
public string? Name { get; }
public Action<TOptions, TDep>? Action { get; }
public TDep Dependency { get; }
public virtual void Configure(string? name, TOptions options)
{
// Null name is used to configure all named options.
if (Name == null || name == Name)
{
Action?.Invoke(options, Dependency);
}
}
public void Configure(TOptions options) => Configure(Options.DefaultName, options);
}
public class PostConfigureOptions<T> : IPostConfigureOptions<T> where T : class
{
public PostConfigureOptions(string? name, Action<T>? action)
{
Name = name;
Action = action;
}
public string? Name { get; }
public Action<T>? Action { get; }
public virtual void PostConfigure(string? name, T options)
{
if (Name == null || name == Name)
{
Action?.Invoke(options);
}
}
}
public class OptionsFactory<T> : IOptionsFactory<T> where T : class
{
private readonly IConfigureOptions<T>[] _setups;
private readonly IPostConfigureOptions<T>[] _postConfigures;
public OptionsFactory(IEnumerable<IConfigureOptions<T>> setups, IEnumerable<IPostConfigureOptions<T>> postConfigures)
{
_setups = setups as IConfigureOptions<T>[] ?? new List<IConfigureOptions<T>>(setups).ToArray();
_postConfigures = postConfigures as IPostConfigureOptions<T>[] ?? new List<IPostConfigureOptions<T>>(postConfigures).ToArray();
}
public T Create(string name)
{
T options = CreateInstance(name);
foreach (IConfigureOptions<T> setup in _setups)
{
if (setup is IConfigureNamedOptions<T> namedSetup)
{
namedSetup.Configure(name, options);
}
else if (name == Options.DefaultName)
{
setup.Configure(options);
}
}
foreach (IPostConfigureOptions<T> post in _postConfigures)
{
post.PostConfigure(name, options);
}
return options;
}
protected virtual T CreateInstance(string name)
{
return Activator.CreateInstance<T>();
}
}
public class OptionsManager<T> : IOptions<T>, IOptionsSnapshot<T> where T : class
{
private readonly IOptionsFactory<T> _factory;
private Dictionary<string, T> _cache = new Dictionary<string, T>();
public OptionsManager(IOptionsFactory<T> factory)
{
_factory = factory;
}
public T Value => Get(Options.DefaultName);
public T Get(string? name)
{
name = name ?? Options.DefaultName;
if (!_cache.TryGetValue(name, out var options))
{
options = _factory.Create(name);
_cache.Add(name, options);
}
return options;
}
}
public class UnamedOptionsManager<T> : IOptions<T> where T : class
{
private readonly IOptionsFactory<T> _factory;
private volatile object? _syncObj;
private volatile T? _value;
public UnamedOptionsManager(IOptionsFactory<T> factory)
{
_factory = factory;
}
public T Value
{
get
{
if (_value is T value) // _value is not null
{
return value;
}
lock (_syncObj ?? Interlocked.CompareExchange(ref _syncObj, new object(), null) ?? _syncObj)
{
return _value ??= _factory.Create(Options.DefaultName);
}
}
}
}
public class OptionsMonitor<T> : IOptionsMonitor<T> where T : class
{
private readonly IOptionsFactory<T> _factory;
private readonly Dictionary<string, T> _cache = new Dictionary<string, T>();
internal event Action<T, string>? _onChange;
public OptionsMonitor(IOptionsFactory<T> factory, IEnumerable<IOptionsChangeTokenSource<T>> sources)
{
_factory = factory;
void RegisterSource(IOptionsChangeTokenSource<T> source)
{
IDisposable registration = ChangeToken.OnChange(
() => source.GetChangeToken(),
(name) => InvokeChanged(name),
source.Name);
}
foreach (IOptionsChangeTokenSource<T> source in sources)
{
RegisterSource(source);
}
}
private void InvokeChanged(string? name)
{
name = name ?? Options.DefaultName;
_cache.Remove(name);
T options = Get(name);
if (_onChange != null)
{
_onChange.Invoke(options, name);
}
}
public T CurrentValue
{
get => Get(Options.DefaultName);
}
public T Get(string? name)
{
name = name ?? Options.DefaultName;
if (!_cache.TryGetValue(name, out var options))
{
options = _factory.Create(name);
_cache.Add(name, options);
}
return options;
}
public IDisposable? OnChange(Action<T, string?> listener)
{
throw new NotImplementedException();
}
}
public class OptionsBuilder<T> where T : class
{
public IServiceCollection Services { get; set; }
public string Name { get; }
public OptionsBuilder(IServiceCollection services, string name)
{
this.Services = services;
Name = name ?? Options.DefaultName;
}
public virtual OptionsBuilder<T> Configure(Action<T> configureOptions)
{
Services.AddSingleton<IConfigureOptions<T>>(new ConfigureNamedOptions<T>(Name, configureOptions));
return this;
}
public virtual OptionsBuilder<T> Configure<TDep>(Action<T, TDep> configureOptions)
where TDep : class
{
Services.AddTransient<IConfigureOptions<T>>(sp =>
new ConfigureNamedOptions<T, TDep>(Name, sp.GetRequiredService<TDep>(), configureOptions));
return this;
}
}
public static class OptionsServiceCollectionExtensions
{
public static IServiceCollection AddMyOptions(this IServiceCollection services)
{
services.AddSingleton(typeof(IOptions<>), typeof(UnamedOptionsManager<>));
services.AddSingleton(typeof(IOptionsMonitor<>), typeof(OptionsMonitor<>));
services.AddScoped(typeof(IOptionsSnapshot<>), typeof(OptionsManager<>));
services.AddTransient(typeof(IOptionsFactory<>), typeof(OptionsFactory<>));
return services;
}
public static IServiceCollection MyConfigure<T>(this IServiceCollection services, Action<T> configureOptions) where T : class
=> services.MyConfigure(Options.DefaultName, configureOptions);
public static IServiceCollection MyConfigure<T>(this IServiceCollection services, string? name, Action<T> configureOptions) where T : class
{
services.AddMyOptions();
services.AddSingleton<IConfigureOptions<T>>(new ConfigureNamedOptions<T>(name, configureOptions));
return services;
}
public static IServiceCollection MyConfigureAll<T>(this IServiceCollection services, Action<T> configureOptions) where T : class
=> services.MyConfigure(name: null, configureOptions: configureOptions);
public static IServiceCollection PostConfigure<T>(this IServiceCollection services, Action<T> configureOptions) where T : class
=> services.PostConfigure(Options.DefaultName, configureOptions);
public static IServiceCollection MyPostConfigure<T>(this IServiceCollection services, string? name, Action<T> configureOptions)
where T : class
{
services.AddMyOptions();
services.AddSingleton<IPostConfigureOptions<T>>(new PostConfigureOptions<T>(name, configureOptions));
return services;
}
public static IServiceCollection MyPostConfigureAll<TOptions>(this IServiceCollection services, Action<TOptions> configureOptions) where TOptions : class
=> services.PostConfigure(name: null, configureOptions: configureOptions);
public static IServiceCollection ConfigureOptions(this IServiceCollection services, Type configureType)
{
services.AddMyOptions();
bool added = false;
foreach (Type serviceType in FindConfigurationServices(configureType))
{
services.AddTransient(serviceType, configureType);
added = true;
}
if (!added)
{
//ThrowNoConfigServices(configureType);
}
return services;
}
private static IEnumerable<Type> FindConfigurationServices(Type type)
{
foreach (Type t in GetInterfacesOnType(type))
{
if (t.IsGenericType)
{
Type gtd = t.GetGenericTypeDefinition();
if (gtd == typeof(IConfigureOptions<>) ||
gtd == typeof(IPostConfigureOptions<>))
{
yield return t;
}
}
}
// Extracted the suppression to a local function as trimmer currently doesn't handle suppressions
// on iterator methods correctly.
static Type[] GetInterfacesOnType(Type t)
=> t.GetInterfaces();
}
public static OptionsBuilder<TOptions> AddOptions<TOptions>(this IServiceCollection services) where TOptions : class
=> services.AddOptions<TOptions>(Options.DefaultName);
public static OptionsBuilder<TOptions> AddOptions<TOptions>(this IServiceCollection services, string? name)
where TOptions : class
{
services.AddMyOptions();
return new OptionsBuilder<TOptions>(services, name);
}
}
}
