Change IOptionsSnapshot to reuse options instances across scopes

src/libraries/Microsoft.Extensions.Options/src/OptionsServiceCollectionExtensions.cs

@@ -27,7 +27,7 @@ public static IServiceCollection AddOptions(this IServiceCollection services)
             }
 
             services.TryAdd(ServiceDescriptor.Singleton(typeof(IOptions<>), typeof(UnnamedOptionsManager<>)));
-            services.TryAdd(ServiceDescriptor.Scoped(typeof(IOptionsSnapshot<>), typeof(OptionsManager<>)));
+            services.TryAdd(ServiceDescriptor.Scoped(typeof(IOptionsSnapshot<>), typeof(OptionsSnapshot<>)));
             services.TryAdd(ServiceDescriptor.Singleton(typeof(IOptionsMonitor<>), typeof(OptionsMonitor<>)));
             services.TryAdd(ServiceDescriptor.Transient(typeof(IOptionsFactory<>), typeof(OptionsFactory<>)));
             services.TryAdd(ServiceDescriptor.Singleton(typeof(IOptionsMonitorCache<>), typeof(OptionsCache<>)));

src/libraries/Microsoft.Extensions.Options/src/OptionsSnapshot.cs

@@ -0,0 +1,66 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Concurrent;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading;
+
+namespace Microsoft.Extensions.Options
+{
+    /// <summary>
+    /// Implementation of <see cref="IOptionsSnapshot{TOptions}"/>.
+    /// </summary>
+    /// <typeparam name="TOptions">Options type.</typeparam>
+    internal sealed class OptionsSnapshot<[DynamicallyAccessedMembers(Options.DynamicallyAccessedMembers)] TOptions> :
+        IOptionsSnapshot<TOptions>
+        where TOptions : class
+    {
+        private readonly IOptionsMonitor<TOptions> _optionsMonitor;
+
+        private volatile ConcurrentDictionary<string, TOptions> _cache;
+        private volatile TOptions _unnamedOptionsValue;
+
+        /// <summary>
+        /// Initializes a new instance with the specified options configurations.
+        /// </summary>
+        /// <param name="optionsMonitor">The options monitor to use to provide options.</param>
+        public OptionsSnapshot(IOptionsMonitor<TOptions> optionsMonitor)
+        {
+            _optionsMonitor = optionsMonitor;
+        }
+
+        /// <summary>
+        /// The default configured <typeparamref name="TOptions"/> instance, equivalent to Get(Options.DefaultName).
+        /// </summary>
+        public TOptions Value => Get(Options.DefaultName);
+
+        /// <summary>
+        /// Returns a configured <typeparamref name="TOptions"/> instance with the given <paramref name="name"/>.
+        /// </summary>
+        public TOptions Get(string name)
+        {
+            if (name == null || name == Options.DefaultName)
+            {
+                if (_unnamedOptionsValue is TOptions value)
+                {
+                    return value;
+                }
+
+                return _unnamedOptionsValue = _optionsMonitor.Get(Options.DefaultName);
+            }
+
+            var cache = _cache ?? Interlocked.CompareExchange(ref _cache, new(concurrencyLevel: 1, capacity: 5, StringComparer.Ordinal), null) ?? _cache;
+
+#if NETSTANDARD2_1
+            TOptions options = cache.GetOrAdd(name, static (name, optionsMonitor) => optionsMonitor.Get(name), _optionsMonitor);
+#else
+            if (!cache.TryGetValue(name, out TOptions options))
+            {
+                options = cache.GetOrAdd(name, _optionsMonitor.Get(name));
+            }
+#endif
+            return options;
+        }
+    }
+}

src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/OptionsSnapshotTest.cs

@@ -131,12 +131,14 @@ public void Configure(string name, FakeOptions options)
         [Fact]
         public void SnapshotOptionsAreCachedPerScope()
         {
+            var config = new ConfigurationBuilder().AddInMemoryCollection().Build();
             var services = new ServiceCollection()
                 .AddOptions()
-                .AddScoped<IConfigureOptions<FakeOptions>, TestConfigure>()
+                .AddSingleton<IConfigureOptions<FakeOptions>, TestConfigure>()
+                .AddSingleton<IOptionsChangeTokenSource<FakeOptions>>(new ConfigurationChangeTokenSource<FakeOptions>(Options.DefaultName, config))
+                .AddSingleton<IOptionsChangeTokenSource<FakeOptions>>(new ConfigurationChangeTokenSource<FakeOptions>("1", config))
                 .BuildServiceProvider();
 
-            var cache = services.GetRequiredService<IOptionsMonitorCache<FakeOptions>>();
             var factory = services.GetRequiredService<IServiceScopeFactory>();
             FakeOptions options = null;
             FakeOptions namedOne = null;
@@ -148,18 +150,30 @@ public void SnapshotOptionsAreCachedPerScope()
                 namedOne = scope.ServiceProvider.GetRequiredService<IOptionsSnapshot<FakeOptions>>().Get("1");
                 Assert.Equal(namedOne, scope.ServiceProvider.GetRequiredService<IOptionsSnapshot<FakeOptions>>().Get("1"));
                 Assert.Equal(2, TestConfigure.ConfigureCount);
+
+                // Reload triggers Configure for the two registered change tokens.
+                config.Reload();
+                Assert.Equal(4, TestConfigure.ConfigureCount);
+
+                // Reload should not affect current scope.
+                var options2 = scope.ServiceProvider.GetRequiredService<IOptionsSnapshot<FakeOptions>>().Value;
+                Assert.Equal(options, options2);
+                var namedOne2 = scope.ServiceProvider.GetRequiredService<IOptionsSnapshot<FakeOptions>>().Get("1");
+                Assert.Equal(namedOne, namedOne2);
             }
             Assert.Equal(1, TestConfigure.CtorCount);
+
+            // Reload should be reflected in a fresh scope.
             using (var scope = factory.CreateScope())
             {
                 var options2 = scope.ServiceProvider.GetRequiredService<IOptionsSnapshot<FakeOptions>>().Value;
                 Assert.NotEqual(options, options2);
-                Assert.Equal(3, TestConfigure.ConfigureCount);
+                Assert.Equal(4, TestConfigure.ConfigureCount);
                 var namedOne2 = scope.ServiceProvider.GetRequiredService<IOptionsSnapshot<FakeOptions>>().Get("1");
-                Assert.NotEqual(namedOne2, namedOne);
+                Assert.NotEqual(namedOne, namedOne2);
                 Assert.Equal(4, TestConfigure.ConfigureCount);
             }
-            Assert.Equal(2, TestConfigure.CtorCount);
+            Assert.Equal(1, TestConfigure.CtorCount);
         }
 
         [Fact]