Optimize Microsoft.Extensions.Caching.Memory (#111050)

* Optimize Microsoft.Extensions.Caching.Memory

* AbsoluteExpiration opts

* Address PR feedback

* Fix merge conflicts

* Address PR feedback

Author: pentp

src/libraries/Microsoft.Extensions.Caching.Abstractions/src/CacheEntryExtensions.cs

@@ -91,14 +91,8 @@ public static ICacheEntry SetSlidingExpiration(
         /// <param name="entry">The <see cref="ICacheEntry"/>.</param>
         /// <param name="callback">The callback to run after the entry is evicted.</param>
         /// <returns>The <see cref="ICacheEntry"/> for chaining.</returns>
-        public static ICacheEntry RegisterPostEvictionCallback(
-            this ICacheEntry entry,
-            PostEvictionDelegate callback)
-        {
-            ThrowHelper.ThrowIfNull(callback);
-
-            return entry.RegisterPostEvictionCallbackNoValidation(callback, state: null);
-        }
+        public static ICacheEntry RegisterPostEvictionCallback(this ICacheEntry entry, PostEvictionDelegate callback)
+            => RegisterPostEvictionCallback(entry, callback, state: null);
 
         /// <summary>
         /// Fires the given callback after the cache entry is evicted from the cache.
@@ -114,14 +108,6 @@ public static ICacheEntry RegisterPostEvictionCallback(
         {
             ThrowHelper.ThrowIfNull(callback);
 
-            return entry.RegisterPostEvictionCallbackNoValidation(callback, state);
-        }
-
-        private static ICacheEntry RegisterPostEvictionCallbackNoValidation(
-            this ICacheEntry entry,
-            PostEvictionDelegate callback,
-            object? state)
-        {
             entry.PostEvictionCallbacks.Add(new PostEvictionCallbackRegistration()
             {
                 EvictionCallback = callback,
@@ -179,18 +165,24 @@ public static ICacheEntry SetOptions(this ICacheEntry entry, MemoryCacheEntryOpt
             entry.Priority = options.Priority;
             entry.Size = options.Size;
 
-            foreach (IChangeToken expirationToken in options.ExpirationTokens)
+            if (options.ExpirationTokensDirect is { } expirationTokens)
             {
-                entry.AddExpirationToken(expirationToken);
+                foreach (IChangeToken expirationToken in expirationTokens)
+                {
+                    entry.AddExpirationToken(expirationToken);
+                }
             }
 
-            for (int i = 0; i < options.PostEvictionCallbacks.Count; i++)
+            if (options.PostEvictionCallbacksDirect is { } postEvictionCallbacks)
             {
-                PostEvictionCallbackRegistration postEvictionCallback = options.PostEvictionCallbacks[i];
-                if (postEvictionCallback.EvictionCallback is null)
-                    ThrowNullCallback(i, nameof(options));
-
-                entry.RegisterPostEvictionCallbackNoValidation(postEvictionCallback.EvictionCallback, postEvictionCallback.State);
+                for (int i = 0; i < postEvictionCallbacks.Count; i++)
+                {
+                    PostEvictionCallbackRegistration postEvictionCallback = postEvictionCallbacks[i];
+                    if (postEvictionCallback.EvictionCallback is null)
+                        ThrowNullCallback(i, nameof(options));
+
+                    entry.PostEvictionCallbacks.Add(postEvictionCallback);
+                }
             }
 
             return entry;

src/libraries/Microsoft.Extensions.Caching.Abstractions/src/DistributedCacheEntryOptions.cs

@@ -10,34 +10,29 @@ namespace Microsoft.Extensions.Caching.Distributed
     /// </summary>
     public class DistributedCacheEntryOptions
     {
-        private DateTimeOffset? _absoluteExpiration;
-        private TimeSpan? _absoluteExpirationRelativeToNow;
-        private TimeSpan? _slidingExpiration;
+        private DateTimeOffset _absoluteExpiration;
+        private bool _absoluteExpirationSet;
+        private TimeSpan _absoluteExpirationRelativeToNow;
+        private bool _absoluteExpirationRelativeToNowSet;
+        private TimeSpan _slidingExpiration;
+        private bool _slidingExpirationSet;
+        private bool _frozen;
 
         /// <summary>
         /// Gets or sets an absolute expiration date for the cache entry.
         /// </summary>
         public DateTimeOffset? AbsoluteExpiration
         {
-            get
-            {
-                return _absoluteExpiration;
-            }
-            set
-            {
-                _absoluteExpiration = value;
-            }
+            get => _absoluteExpirationSet ? _absoluteExpiration : null;
+            set => Set(ref _absoluteExpiration, ref _absoluteExpirationSet, value);
         }
 
         /// <summary>
         /// Gets or sets an absolute expiration time, relative to now.
         /// </summary>
         public TimeSpan? AbsoluteExpirationRelativeToNow
         {
-            get
-            {
-                return _absoluteExpirationRelativeToNow;
-            }
+            get => _absoluteExpirationRelativeToNowSet ? _absoluteExpirationRelativeToNow : null;
             set
             {
                 if (value <= TimeSpan.Zero)
@@ -48,7 +43,7 @@ public TimeSpan? AbsoluteExpirationRelativeToNow
                         "The relative expiration value must be positive.");
                 }
 
-                _absoluteExpirationRelativeToNow = value;
+                Set(ref _absoluteExpirationRelativeToNow, ref _absoluteExpirationRelativeToNowSet, value);
             }
         }
 
@@ -58,10 +53,7 @@ public TimeSpan? AbsoluteExpirationRelativeToNow
         /// </summary>
         public TimeSpan? SlidingExpiration
         {
-            get
-            {
-                return _slidingExpiration;
-            }
+            get => _slidingExpirationSet ? _slidingExpiration : null;
             set
             {
                 if (value <= TimeSpan.Zero)
@@ -71,8 +63,27 @@ public TimeSpan? SlidingExpiration
                         value,
                         "The sliding expiration value must be positive.");
                 }
-                _slidingExpiration = value;
+                Set(ref _slidingExpiration, ref _slidingExpirationSet, value);
             }
         }
+
+        internal DistributedCacheEntryOptions Freeze()
+        {
+            _frozen = true;
+            return this;
+        }
+
+        private void Set<T>(ref T field, ref bool isSet, in T? value) where T : struct
+        {
+            if (_frozen)
+            {
+                ThrowFrozen();
+            }
+
+            field = value.GetValueOrDefault();
+            isSet = value.HasValue;
+
+            static void ThrowFrozen() => throw new InvalidOperationException("This instance has been frozen and cannot be mutated");
+        }
     }
 }

src/libraries/Microsoft.Extensions.Caching.Abstractions/src/DistributedCacheExtensions.cs

@@ -13,6 +13,8 @@ namespace Microsoft.Extensions.Caching.Distributed
     /// </summary>
     public static class DistributedCacheExtensions
     {
+        private static readonly DistributedCacheEntryOptions DefaultOptions = new DistributedCacheEntryOptions().Freeze();
+
         /// <summary>
         /// Sets a sequence of bytes in the specified cache with the specified key.
         /// </summary>
@@ -25,7 +27,7 @@ public static void Set(this IDistributedCache cache, string key, byte[] value)
             ThrowHelper.ThrowIfNull(key);
             ThrowHelper.ThrowIfNull(value);
 
-            cache.Set(key, value, new DistributedCacheEntryOptions());
+            cache.Set(key, value, DefaultOptions);
         }
 
         /// <summary>
@@ -42,7 +44,7 @@ public static void Set(this IDistributedCache cache, string key, byte[] value)
             ThrowHelper.ThrowIfNull(key);
             ThrowHelper.ThrowIfNull(value);
 
-            return cache.SetAsync(key, value, new DistributedCacheEntryOptions(), token);
+            return cache.SetAsync(key, value, DefaultOptions, token);
         }
 
         /// <summary>
@@ -54,7 +56,7 @@ public static void Set(this IDistributedCache cache, string key, byte[] value)
         /// <exception cref="System.ArgumentNullException"><paramref name="key"/> or <paramref name="value"/> is null.</exception>
         public static void SetString(this IDistributedCache cache, string key, string value)
         {
-            cache.SetString(key, value, new DistributedCacheEntryOptions());
+            cache.SetString(key, value, DefaultOptions);
         }
 
         /// <summary>
@@ -84,7 +86,7 @@ public static void SetString(this IDistributedCache cache, string key, string va
         /// <exception cref="System.ArgumentNullException"><paramref name="key"/> or <paramref name="value"/> is null.</exception>
         public static Task SetStringAsync(this IDistributedCache cache, string key, string value, CancellationToken token = default(CancellationToken))
         {
-            return cache.SetStringAsync(key, value, new DistributedCacheEntryOptions(), token);
+            return cache.SetStringAsync(key, value, DefaultOptions, token);
         }
 
         /// <summary>

src/libraries/Microsoft.Extensions.Caching.Abstractions/src/MemoryCacheEntryOptions.cs

@@ -16,6 +16,8 @@ public class MemoryCacheEntryOptions
         private TimeSpan? _absoluteExpirationRelativeToNow;
         private TimeSpan? _slidingExpiration;
         private long? _size;
+        private List<IChangeToken>? _expirationTokens;
+        private List<PostEvictionCallbackRegistration>? _postEvictionCallbacks;
 
         /// <summary>
         /// Gets or sets an absolute expiration date for the cache entry.
@@ -81,13 +83,16 @@ public TimeSpan? SlidingExpiration
         /// <summary>
         /// Gets the <see cref="IChangeToken"/> instances which cause the cache entry to expire.
         /// </summary>
-        public IList<IChangeToken> ExpirationTokens { get; } = new List<IChangeToken>();
+        public IList<IChangeToken> ExpirationTokens => _expirationTokens ??= [];
+
+        internal List<IChangeToken>? ExpirationTokensDirect => _expirationTokens;
 
         /// <summary>
         /// Gets or sets the callbacks will be fired after the cache entry is evicted from the cache.
         /// </summary>
-        public IList<PostEvictionCallbackRegistration> PostEvictionCallbacks { get; }
-            = new List<PostEvictionCallbackRegistration>();
+        public IList<PostEvictionCallbackRegistration> PostEvictionCallbacks => _postEvictionCallbacks ??= [];
+
+        internal List<PostEvictionCallbackRegistration>? PostEvictionCallbacksDirect => _postEvictionCallbacks;
 
         /// <summary>
         /// Gets or sets the priority for keeping the cache entry in the cache during a

src/libraries/Microsoft.Extensions.Caching.Abstractions/src/MemoryCacheExtensions.cs

@@ -33,7 +33,8 @@ public static class CacheExtensions
         /// <returns>The value associated with this key, or <c>default(TItem)</c> if the key is not present.</returns>
         public static TItem? Get<TItem>(this IMemoryCache cache, object key)
         {
-            return (TItem?)(cache.Get(key) ?? default(TItem));
+            cache.TryGetValue(key, out object? value);
+            return value is null ? default : (TItem)value;
         }
 
         /// <summary>
@@ -75,8 +76,9 @@ public static bool TryGetValue<TItem>(this IMemoryCache cache, object key, out T
         /// <returns>The value that was set.</returns>
         public static TItem Set<TItem>(this IMemoryCache cache, object key, TItem value)
         {
-            using ICacheEntry entry = cache.CreateEntry(key);
+            ICacheEntry entry = cache.CreateEntry(key);
             entry.Value = value;
+            entry.Dispose();
 
             return value;
         }

src/libraries/Microsoft.Extensions.Caching.Memory/src/CacheEntry.cs

@@ -84,7 +84,11 @@ internal long AbsoluteExpirationTicks
                 {
                     DateTimeOffset expiration = value.GetValueOrDefault();
                     _absoluteExpirationTicks = expiration.UtcTicks;
+#if NET
+                    _absoluteExpirationOffsetMinutes = (short)expiration.TotalOffsetMinutes;
+#else
                     _absoluteExpirationOffsetMinutes = (short)(expiration.Offset.Ticks / TimeSpan.TicksPerMinute);
+#endif
                 }
             }
         }