Options 2.0 - Add support for named options, validation, and caching

src/Microsoft.Extensions.Options/ConfigureNamedOptions.cs

@@ -0,0 +1,54 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+
+namespace Microsoft.Extensions.Options
+{
+    /// <summary>
+    /// Implementation of IConfigureNamedOptions.
+    /// </summary>
+    /// <typeparam name="TOptions"></typeparam>
+    public class ConfigureNamedOptions<TOptions> : IConfigureNamedOptions<TOptions> where TOptions : class
+    {
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <param name="name">The name of the options.</param>
+        /// <param name="action">The action to register.</param>
+        public ConfigureNamedOptions(string name, Action<TOptions> action)
+        {
+            Name = name;
+            Action = action;
+        }
+
+        /// <summary>
+        /// The options name.
+        /// </summary>
+        public string Name { get; }
+
+        /// <summary>
+        /// The configuration action.
+        /// </summary>
+        public Action<TOptions> Action { get; }
+
+        /// <summary>
+        /// Invokes the registered configure Action if the name matches.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="options"></param>
+        public virtual void Configure(string name, TOptions options)
+        {
+            if (options == null)
+            {
+                throw new ArgumentNullException(nameof(options));
+            }
+
+            // Null name is used to configure all named options.
+            if (Name == null || name == Name)
+            {
+                Action?.Invoke(options);
+            }
+        }
+    }
+}

src/Microsoft.Extensions.Options/IConfigureNamedOptions.cs

@@ -0,0 +1,20 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.Extensions.Options
+{
+
+    /// <summary>
+    /// Represents something that configures the TOptions type.
+    /// </summary>
+    /// <typeparam name="TOptions"></typeparam>
+    public interface IConfigureNamedOptions<in TOptions> where TOptions : class
+    {
+        /// <summary>
+        /// Invoked to configure a TOptions instance.
+        /// </summary>
+        /// <param name="name">The name of the options instance being configured.</param>
+        /// <param name="options">The options instance to configure.</param>
+        void Configure(string name, TOptions options);
+    }
+}

src/Microsoft.Extensions.Options/IOptionsCache.cs

@@ -0,0 +1,22 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+
+namespace Microsoft.Extensions.Options
+{
+    /// <summary>
+    /// Used to cache TOptions instances.
+    /// </summary>
+    /// <typeparam name="TOptions">The type of options being requested.</typeparam>
+    public interface IOptionsCache<TOptions> where TOptions : class
+    {
+        TOptions GetOrAdd(string name, Func<TOptions> createOptions);
+
+        bool TryAdd(string name, TOptions options);
+
+        bool TryRemove(string name);
+
+        // Do we need a Clear all?
+    }
+}

src/Microsoft.Extensions.Options/IOptionsFactory.cs

@@ -0,0 +1,17 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.Extensions.Options
+{
+    /// <summary>
+    /// Used to create TOptions instances.
+    /// </summary>
+    /// <typeparam name="TOptions">The type of options being requested.</typeparam>
+    public interface IOptionsFactory<TOptions> where TOptions : class, new()
+    {
+        /// <summary>
+        /// Returns a configured TOptions instance with the given name.
+        /// </summary>
+        TOptions Create(string name);
+    }
+}

src/Microsoft.Extensions.Options/IOptionsService.cs

@@ -0,0 +1,21 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.Extensions.Options
+{
+    /// <summary>
+    /// Used to retreive configured and validated TOptions instances.
+    /// </summary>
+    /// <typeparam name="TOptions">The type of options being requested.</typeparam>
+    public interface IOptionsService<TOptions> where TOptions : class, new()
+    {
+        /// <summary>
+        /// Returns a configured and validated TOptions instance with the given name.
+        /// </summary>
+        TOptions Get(string name);
+
+        void Add(string name, TOptions options);
+
+        bool Remove(string name);
+    }
+}

src/Microsoft.Extensions.Options/IOptionsValidator.cs

@@ -0,0 +1,17 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.Extensions.Options
+{
+    /// <summary>
+    /// Used to validate TOptions instances.
+    /// </summary>
+    /// <typeparam name="TOptions">The type of options being requested.</typeparam>
+    public interface IOptionsValidator<TOptions> where TOptions : class, new()
+    {
+        /// <summary>
+        /// Validates the options instance.
+        /// </summary>
+        void Validate(string name, TOptions options);
+    }
+}

src/Microsoft.Extensions.Options/IValidateNamedOptions.cs

@@ -0,0 +1,25 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+
+namespace Microsoft.Extensions.Options
+{
+    /// <summary>
+    /// Represents something that validate the TOptions type.
+    /// </summary>
+    /// <typeparam name="TOptions">The type of options being requested.</typeparam>
+    public interface IValidateNamedOptions<in TOptions> where TOptions : class
+    {
+        /// <summary>
+        /// The name of the options instance to validate.
+        /// </summary>
+        string Name { get; }
+
+        /// <summary>
+        /// Invoked to validate a TOptions instance.
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance to validate.</param>
+        void Validate(string name, TOptions options);
+    }
+}

src/Microsoft.Extensions.Options/LegacyOptionsCache.cs

@@ -0,0 +1,49 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Microsoft.Extensions.Options
+{
+    internal class LegacyOptionsCache<TOptions> where TOptions : class, new()
+    {
+        private readonly Func<TOptions> _createCache;
+        private object _cacheLock = new object();
+        private bool _cacheInitialized;
+        private TOptions _options;
+        private IEnumerable<IConfigureOptions<TOptions>> _setups;
+
+        public LegacyOptionsCache(IEnumerable<IConfigureOptions<TOptions>> setups)
+        {
+            _setups = setups;
+            _createCache = CreateOptions;
+        }
+
+        private TOptions CreateOptions()
+        {
+            var result = new TOptions();
+            if (_setups != null)
+            {
+                foreach (var setup in _setups)
+                {
+                    setup.Configure(result);
+                }
+            }
+            return result;
+        }
+
+        public virtual TOptions Value
+        {
+            get
+            {
+                return LazyInitializer.EnsureInitialized(
+                    ref _options,
+                    ref _cacheInitialized,
+                    ref _cacheLock,
+                    _createCache);
+            }
+        }
+    }
+}

src/Microsoft.Extensions.Options/Microsoft.Extensions.Options.csproj

@@ -4,7 +4,7 @@
 
   <PropertyGroup>
     <Description>Provides a strongly typed way of specifying and accessing settings using dependency injection.</Description>
-    <TargetFramework>netstandard1.0</TargetFramework>
+    <TargetFramework>netstandard1.1</TargetFramework>
     <NoWarn>$(NoWarn);CS1591</NoWarn>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <PackageTags>aspnetcore;options</PackageTags>
@@ -13,7 +13,6 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="$(AspNetCoreVersion)" />
     <PackageReference Include="Microsoft.Extensions.Primitives" Version="$(AspNetCoreVersion)" />
-    <PackageReference Include="System.ComponentModel" Version="$(CoreFxVersion)" />
-  </ItemGroup>
+    <PackageReference Include="System.ComponentModel" Version="$(CoreFxVersion)" />  </ItemGroup>
 
 </Project>

src/Microsoft.Extensions.Options/OptionsCache.cs

@@ -1,49 +1,65 @@
-// Copyright (c) .NET Foundation. All rights reserved.
+// Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
-using System.Collections.Generic;
-using System.Threading;
+using System.Collections.Concurrent;
 
 namespace Microsoft.Extensions.Options
 {
-    internal class OptionsCache<TOptions> where TOptions : class, new()
+    /// <summary>
+    /// Used to cache TOptions instances.
+    /// </summary>
+    /// <typeparam name="TOptions">The type of options being requested.</typeparam>
+    public class OptionsCache<TOptions> : IOptionsCache<TOptions> where TOptions : class
     {
-        private readonly Func<TOptions> _createCache;
-        private object _cacheLock = new object();
-        private bool _cacheInitialized;
-        private TOptions _options;
-        private IEnumerable<IConfigureOptions<TOptions>> _setups;
+        private readonly ConcurrentDictionary<string, Lazy<TOptions>> _cache = new ConcurrentDictionary<string, Lazy<TOptions>>(StringComparer.Ordinal);
 
-        public OptionsCache(IEnumerable<IConfigureOptions<TOptions>> setups)
+        public virtual TOptions GetOrAdd(string name, Func<TOptions> createOptions)
         {
-            _setups = setups;
-            _createCache = CreateOptions;
+            if (name == null)
+            {
+                throw new ArgumentNullException(nameof(name));
+            }
+            if (createOptions == null)
+            {
+                throw new ArgumentNullException(nameof(createOptions));
+            }
+            return _cache.GetOrAdd(name, new Lazy<TOptions>(createOptions)).Value;
         }
 
-        private TOptions CreateOptions()
+        /// <summary>
+        /// Tries to adds a new option to the cache, will return false if the name already exists.
+        /// </summary>
+        /// <param name="name">The name of the options instance.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Whether anything was added.</returns>
+        public virtual bool TryAdd(string name, TOptions options)
         {
-            var result = new TOptions();
-            if (_setups != null)
+            if (name == null)
             {
-                foreach (var setup in _setups)
-                {
-                    setup.Configure(result);
-                }
+                throw new ArgumentNullException(nameof(name));
             }
-            return result;
+            if (options == null)
+            {
+                throw new ArgumentNullException(nameof(options));
+            }
+            return _cache.TryAdd(name, new Lazy<TOptions>(() => options));
         }
 
-        public virtual TOptions Value
+        /// <summary>
+        /// Try to remove an options instance.
+        /// </summary>
+        /// <param name="name">The name of the options instance.</param>
+        /// <returns>Whether anything was removed.</returns>
+        public virtual bool TryRemove(string name)
         {
-            get
+            if (name == null)
             {
-                return LazyInitializer.EnsureInitialized(
-                    ref _options,
-                    ref _cacheInitialized,
-                    ref _cacheLock,
-                    _createCache);
+                throw new ArgumentNullException(nameof(name));
             }
+            return _cache.TryRemove(name, out var ignored);
         }
+
+        // Do we need a Clear all?
     }
 }

src/Microsoft.Extensions.Options/OptionsFactory.cs

@@ -0,0 +1,35 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+
+namespace Microsoft.Extensions.Options
+{
+    /// <summary>
+    /// Implementation of IOptionsFactory.
+    /// </summary>
+    /// <typeparam name="TOptions">The type of options being requested.</typeparam>
+    public class OptionsFactory<TOptions> : IOptionsFactory<TOptions> where TOptions : class, new()
+    {
+        private readonly IEnumerable<IConfigureNamedOptions<TOptions>> _setups;
+
+        /// <summary>
+        /// Initializes a new instance with the specified options configurations.
+        /// </summary>
+        /// <param name="setups">The configuration actions to run.</param>
+        public OptionsFactory(IEnumerable<IConfigureNamedOptions<TOptions>> setups)
+        {
+            _setups = setups;
+        }
+
+        public TOptions Create(string name)
+        {
+            var options = new TOptions();
+            foreach (var setup in _setups)
+            {
+                setup.Configure(name, options);
+            }
+            return options;
+        }
+    }
+}