{"id":1313,"date":"2018-01-29T10:00:06","date_gmt":"2018-01-29T08:00:06","guid":{"rendered":"http:\/\/tpodolak.com\/blog\/?p=1313"},"modified":"2018-02-28T22:33:45","modified_gmt":"2018-02-28T20:33:45","slug":"asp-net-core-make-sure-ioptionst-initialized","status":"publish","type":"post","link":"https:\/\/tpodolak.com\/blog\/2018\/01\/29\/asp-net-core-make-sure-ioptionst-initialized\/","title":{"rendered":"ASP.NET Core – make sure IOptions<T><\/i> is initialized"},"content":{"rendered":"

1. Introduction<\/h3>\n

As most people know IOptions<T><\/i> is a convenient way of handling configuration options in your application. Even though I’ve been using it for quite some time, last week I was unpleasantly surprised by a production bug caused by wrong usage of this mechanism.<\/p>\n

2. Problem<\/h3>\n

Let’s say we have a simple controller which depends on two instances of IOptions<T><\/i><\/p>\n

\r\n[Route(\"api\/[controller]\")]\r\npublic class ValuesController : Controller\r\n{\r\n    private readonly IOptions _paymentOptions;\r\n    private readonly IOptions _notificationOptions;\r\n\r\n    public ValuesController(IOptions paymentOptions, IOptions notificationOptions)\r\n    {\r\n        _paymentOptions = paymentOptions ?? throw new ArgumentNullException(nameof(paymentOptions));\r\n        _notificationOptions = notificationOptions ?? throw new ArgumentNullException(nameof(notificationOptions));\r\n    }\r\n\r\n    \/\/ GET api\/values\r\n    [HttpGet]\r\n    public IEnumerable Get()\r\n    {\r\n        var notificationOptions = _notificationOptions.Value;\r\n        var paymentOptions = _paymentOptions.Value;\r\n            \r\n        return new string[] {\"value1\", \"value2\"};\r\n    }\r\n}\r\n<\/pre>\n
Then we add only IOptions<\/i> in Startup class – IOptions<PaymentOptoins><\/i><\/p>\n
\r\npublic class Startup\r\n{\r\n    \/\/ Rest of the code omitted for brevity\r\n    \/\/ This method gets called by the runtime. Use this method to add services to the container.\r\n    public void ConfigureServices(IServiceCollection services)\r\n    {\r\n        services.AddOptions();\r\n        services.AddMvc();\r\n        services.Configure(Configuration.GetSection(\"PaymentOptions\"));\r\n    }\r\n      \/\/ Rest of the code omitted for brevity\r\n}\r\n<\/pre>\n
Now, when we run the app and hit one of the endpoints in ValuesController<\/i> I was expecting to get an exception, as I didn’t register IOptions<NotificationOptions><\/i>. Surprisingly for me, the application was running normally and IOptions<NotificationOptions><\/i> was created with the new instance of NotificationOptions<\/i> class(with all the properties defaulted).
\n\"\"<\/a>
\nIn order to find out why it behaves like that we have to take a look how services responsible for handling IOptions<T><\/i> are registered in the container.<\/p>\n
\r\npublic static IServiceCollection AddOptions(this IServiceCollection services)\r\n{\r\n    if (services == null)\r\n        throw new ArgumentNullException(nameof (services));\r\n\r\n    services.TryAdd(ServiceDescriptor.Singleton(typeof (IOptions<>), typeof (OptionsManager<>)));\r\n    services.TryAdd(ServiceDescriptor.Scoped(typeof (IOptionsSnapshot<>), typeof (OptionsManager<>)));\r\n    services.TryAdd(ServiceDescriptor.Singleton(typeof (IOptionsMonitor<>), typeof (OptionsMonitor<>)));\r\n    services.TryAdd(ServiceDescriptor.Transient(typeof (IOptionsFactory<>), typeof (OptionsFactory<>)));\r\n    services.TryAdd(ServiceDescriptor.Singleton(typeof (IOptionsMonitorCache<>), typeof (OptionsCache<>)));\r\n    return services;\r\n}\r\n<\/pre>\n
As you can see AddOptions<\/i> method registers open generics for (among others) IOptions<><\/i> which means that you don’t have to register specific types of IOptions<T><\/i>, however, you are responsible for its configuration with<\/p>\n
\r\nservices.Configure(Configuration.GetSection(\"Section\"));\r\n<\/pre>\n
I was always convinced that services.Configure<\/i> registers and configure IOptions<T><\/i> but apparently, I was wrong.<\/p>\n
3. Ensuring initialization <\/h3>\n
As these kind of errors are rather difficult to catch(at least in case of our application) I wanted to minimize the risk of doing the same bug again. The idea was to make sure that at least one IConfigureOptions<T><\/i> or IPostConfigureOptions<T><\/i> service is registered in the container (as these are the services which are responsible for setting the values of T class). My first approach was to replace default OptionsFactory<T><\/i> with a custom one<\/p>\n
\r\npublic class ValidatableOptionsFactory : OptionsFactory where TOptions : class, new()\r\n{\r\n    private static readonly string NamespacePrefix = typeof(Program).Namespace.Split('.').First();\r\n\r\n    public ValidatableOptionsFactory(IEnumerable> setups, IEnumerable> postConfigures)\r\n            : base(setups, postConfigures)\r\n    {\r\n        if (typeof(TOptions).Namespace.StartsWith(NamespacePrefix) && setups.Any() == false && postConfigures.Any() == false)\r\n        {\r\n            throw new InvalidOperationException($\"No configuration options or post configuration options was found to configure {typeof(TOptions)}\");\r\n        }\r\n    }\r\n}\r\n\r\npublic class Startup\r\n{      \r\n    \/\/ This method gets called by the runtime. Use this method to add services to the container.\r\n    public void ConfigureServices(IServiceCollection services)\r\n    {\r\n        services.AddTransient(typeof(IOptionsFactory<>), typeof(ValidatableOptionsFactory<>));\r\n        services.AddOptions();\r\n    }\r\n}\r\n<\/pre>\n
\r\npublic class OptionsTests\r\n{\r\n    private readonly Lazy _webHost = new Lazy(Program.BuildWebHost(null));\r\n\r\n    \/\/ this test will fail as not every option in assembly is configured\r\n    [Fact]\r\n    public void AllConfigurationOptions_HasConfigurationServicesDefined()\r\n    {\r\n        var optionsType = typeof(IOptions<>);\r\n        var constructorParameterTypes = typeof(Program).Assembly.GetExportedTypes()\r\n                .SelectMany(type => type.GetConstructors().SelectMany(ctor => ctor.GetParameters()))\r\n                .Select(parameter => parameter.ParameterType);\r\n\r\n        var optionValueTypes = constructorParameterTypes.Where(parameterType => IsAssignableToGenericType(parameterType, optionsType))\r\n                .Select(options => options.GetGenericArguments().Single())\r\n                .Distinct();\r\n            \r\n        var postConfigureOptionsType = typeof(IPostConfigureOptions<>);\r\n        var configureOptionsType = typeof(IConfigureOptions<>);\r\n\r\n        var postConfiguration = optionValueTypes.Select(type => new\r\n        {\r\n            optionsType = type,\r\n            configureOptionsType = _webHost.Value.Services.GetServices(configureOptionsType.MakeGenericType(type)),\r\n            postConfigureServices = _webHost.Value.Services.GetServices(postConfigureOptionsType.MakeGenericType(type))\r\n        });\r\n\r\n        var emptyConfigurations =\r\n                postConfiguration.Where(item => item.configureOptionsType.Any() == false && item.postConfigureServices.Any() == false)\r\n                    .Select(item => item.optionsType);\r\n\r\n        emptyConfigurations.Should().BeEmpty(\"All options should be configured\");\r\n    }\r\n\r\n    \/\/ https:\/\/stackoverflow.com\/questions\/74616\/how-to-detect-if-type-is-another-generic-type\/1075059#1075059\r\n    public static bool IsAssignableToGenericType(Type givenType, Type genericType)\r\n    {\r\n        var interfaceTypes = givenType.GetInterfaces();\r\n\r\n        if (interfaceTypes.Any(it => it.IsGenericType && it.GetGenericTypeDefinition() == genericType))\r\n        {\r\n            return true;\r\n        }\r\n\r\n        if (givenType.IsGenericType && givenType.GetGenericTypeDefinition() == genericType)\r\n            return true;\r\n\r\n        var baseType = givenType.BaseType;\r\n        if (baseType == null) return false;\r\n\r\n        return IsAssignableToGenericType(baseType, genericType);\r\n    }\r\n}\r\n<\/pre>\n
Running the test shows that NotificationOptions<\/i> was not configured
\n\"\"<\/a>
\nSource code for this post can be found here<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
1. Introduction As most people know IOptions<T> is a convenient way of handling configuration options in your application. Even though I’ve been using it for quite some time, last week I was unpleasantly surprised by a production bug caused by wrong usage of this mechanism. 2. Problem Let’s say we have a simple controller which […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[317],"tags":[318],"class_list":["post-1313","post","type-post","status-publish","format-standard","hentry","category-asp-net-core","tag-asp-net-core"],"_links":{"self":[{"href":"https:\/\/tpodolak.com\/blog\/wp-json\/wp\/v2\/posts\/1313","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/tpodolak.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/tpodolak.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/tpodolak.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/tpodolak.com\/blog\/wp-json\/wp\/v2\/comments?post=1313"}],"version-history":[{"count":17,"href":"https:\/\/tpodolak.com\/blog\/wp-json\/wp\/v2\/posts\/1313\/revisions"}],"predecessor-version":[{"id":1332,"href":"https:\/\/tpodolak.com\/blog\/wp-json\/wp\/v2\/posts\/1313\/revisions\/1332"}],"wp:attachment":[{"href":"https:\/\/tpodolak.com\/blog\/wp-json\/wp\/v2\/media?parent=1313"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/tpodolak.com\/blog\/wp-json\/wp\/v2\/categories?post=1313"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/tpodolak.com\/blog\/wp-json\/wp\/v2\/tags?post=1313"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
This method works fine (although probably needs smarter TOptions filter)
\n\"\"<\/a>
\nhowever I got to conclusion that there is no point to do validation in a runtime, and the integration test might be a better choice. I came up with following code (I am assuming that all configuration options are stored in the same assembly, as this is convention in my project)<\/p>\n