Avoid allocating a delegate in OptionsMonitor.Get() when possible.

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

@@ -31,14 +31,44 @@ public class OptionsCache<[DynamicallyAccessedMembers(Options.DynamicallyAccesse
         public virtual TOptions GetOrAdd(string? name, Func<TOptions> createOptions!!)
         {
             name ??= Options.DefaultName;
-            Lazy<TOptions>? value;
+            Lazy<TOptions> value;
 
-#if NETSTANDARD2_1
+#if NET || NETSTANDARD2_1
             value = _cache.GetOrAdd(name, static (name, createOptions) => new Lazy<TOptions>(createOptions), createOptions);
 #else
             if (!_cache.TryGetValue(name, out value))
             {
-                value = _cache.GetOrAdd(name, new Lazy<TOptions>(createOptions));
+                Func<TOptions> localCreateOptions = createOptions;
+                value = _cache.GetOrAdd(name, new Lazy<TOptions>(localCreateOptions));
+            }
+#endif
+
+            return value.Value;
+        }
+
+        internal TOptions GetOrAdd<TArg>(string? name, Func<string, TArg, TOptions> createOptions, TArg factoryArgument)
+        {
+            // For compatibility, fall back to public GetOrAdd() if we're in a derived class.
+            if (GetType() != typeof(OptionsCache<TOptions>))
+            {
+                string? localName = name;
+                Func<string, TArg, TOptions> localCreateOptions = createOptions;
+                TArg localFactoryArgument = factoryArgument;
+                return GetOrAdd(name, () => localCreateOptions(localName ?? Options.DefaultName, localFactoryArgument));
+            }
+
+            name ??= Options.DefaultName;
+            Lazy<TOptions> value;
+
+#if NET || NETSTANDARD2_1
+            value = _cache.GetOrAdd(name, static (name, arg) => new Lazy<TOptions>(arg.createOptions(name, arg.factoryArgument)), (createOptions, factoryArgument));
+#else
+            if (!_cache.TryGetValue(name, out value))
+            {
+                string? localName = name;
+                Func<string, TArg, TOptions> localCreateOptions = createOptions;
+                TArg localFactoryArgument = factoryArgument;
+                value = _cache.GetOrAdd(name, new Lazy<TOptions>(() => localCreateOptions(localName, localFactoryArgument)));
             }
 #endif
 
@@ -72,7 +102,7 @@ internal bool TryGetValue(string? name, [MaybeNullWhen(false)] out TOptions opti
         public virtual bool TryAdd(string? name, TOptions options!!)
         {
             return _cache.TryAdd(name ?? Options.DefaultName, new Lazy<TOptions>(
-#if !NETSTANDARD2_1
+#if NETSTANDARD2_0 || NETFRAMEWORK
                 () =>
 #endif
                 options));

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

@@ -85,8 +85,9 @@ public TOptions CurrentValue
         /// </summary>
         public virtual TOptions Get(string? name)
         {
-            name = name ?? Options.DefaultName;
-            return _cache.GetOrAdd(name, () => _factory.Create(name));
+            return _cache is OptionsCache<TOptions> optionsCache
+                ? optionsCache.GetOrAdd(name, (name, factory) => factory.Create(name), _factory)
+                : _cache.GetOrAdd(name ??= Options.DefaultName, () => _factory.Create(name));
         }
 
         /// <summary>

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

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
@@ -418,5 +419,51 @@ public ChangeTokenSource(IChangeToken changeToken)
 
             public IChangeToken GetChangeToken() => _changeToken;
         }
+
+        [Fact]
+        public void CallsPublicGetOrAddForCustomOptionsCache()
+        {
+            DerivedOptionsCache derivedOptionsCache = new();
+            CreateMonitor(derivedOptionsCache).Get(null);
+            Assert.Equal(1, derivedOptionsCache.GetOrAddCalls);
+
+            ImplementedOptionsCache implementedOptionsCache = new();
+            CreateMonitor(implementedOptionsCache).Get(null);
+            Assert.Equal(1, implementedOptionsCache.GetOrAddCalls);
+
+            static OptionsMonitor<FakeOptions> CreateMonitor(IOptionsMonitorCache<FakeOptions> cache) =>
+                new OptionsMonitor<FakeOptions>(
+                    new OptionsFactory<FakeOptions>(Enumerable.Empty<IConfigureOptions<FakeOptions>>(), Enumerable.Empty<IPostConfigureOptions<FakeOptions>>()),
+                    Enumerable.Empty<IOptionsChangeTokenSource<FakeOptions>>(),
+                    cache);
+        }
+
+        private class DerivedOptionsCache : OptionsCache<FakeOptions>
+        {
+            public int GetOrAddCalls { get; private set; }
+
+            public override FakeOptions GetOrAdd(string? name, Func<FakeOptions> createOptions)
+            {
+                GetOrAddCalls++;
+                return base.GetOrAdd(name, createOptions);
+            }
+        }
+
+        private class ImplementedOptionsCache : IOptionsMonitorCache<FakeOptions>
+        {
+            public int GetOrAddCalls { get; private set; }
+
+            public void Clear() => throw new NotImplementedException();
+
+            public FakeOptions GetOrAdd(string? name, Func<FakeOptions> createOptions)
+            {
+                GetOrAddCalls++;
+                return createOptions();
+            }
+
+            public bool TryAdd(string? name, FakeOptions options) => throw new NotImplementedException();
+
+            public bool TryRemove(string? name) => throw new NotImplementedException();
+        }
     }
 }