Extend MemoryCacheOptions with TrackLinkedCacheEntries

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

@@ -43,6 +43,7 @@ public MemoryCacheOptions() { }
  public System.TimeSpan ExpirationScanFrequency { get { throw null; } set { } }
  Microsoft.Extensions.Caching.Memory.MemoryCacheOptions Microsoft.Extensions.Options.IOptions<Microsoft.Extensions.Caching.Memory.MemoryCacheOptions>.Value { get { throw null; } }
  public long? SizeLimit { get { throw null; } set { } }
+ public bool TrackLinkedCacheEntries { get { throw null; } set { } }
  }
  public partial class MemoryDistributedCacheOptions : Microsoft.Extensions.Caching.Memory.MemoryCacheOptions
  {

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

@@ -20,15 +20,15 @@ internal sealed partial class CacheEntry : ICacheEntry
  private TimeSpan? _absoluteExpirationRelativeToNow;
  private TimeSpan? _slidingExpiration;
  private long? _size;
- private CacheEntry _previous; // this field is not null only before the entry is added to the cache
+ private CacheEntry _previous; // this field is not null only before the entry is added to the cache and tracking is enabled
  private object _value;
  private CacheEntryState _state;
 
  internal CacheEntry(object key, MemoryCache memoryCache)
  {
  Key = key ?? throw new ArgumentNullException(nameof(key));
  _cache = memoryCache ?? throw new ArgumentNullException(nameof(memoryCache));
- _previous = CacheEntryHelper.EnterScope(this);
+ _previous = memoryCache.TrackLinkedCacheEntries ? CacheEntryHelper.EnterScope(this) : null;
  _state = new CacheEntryState(CacheItemPriority.Normal);
  }
 
@@ -136,7 +136,10 @@ public void Dispose()
  {
  _state.IsDisposed = true;
 
- CacheEntryHelper.ExitScope(this, _previous);
+ if (_cache.TrackLinkedCacheEntries)
+ {
+ CacheEntryHelper.ExitScope(this, _previous);
+ }
 
  // Don't commit or propagate options if the CacheEntry Value was never set.
  // We assume an exception occurred causing the caller to not set the Value successfully,

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

@@ -64,6 +64,7 @@ public MemoryCache(IOptions<MemoryCacheOptions> optionsAccessor, ILoggerFactory
  }
 
  _lastExpirationScan = _options.Clock.UtcNow;
+ TrackLinkedCacheEntries = _options.TrackLinkedCacheEntries; // we store the setting now so it's consistent for entire MemoryCache lifetime
  }
 
  /// <summary>
@@ -79,6 +80,8 @@ public MemoryCache(IOptions<MemoryCacheOptions> optionsAccessor, ILoggerFactory
  // internal for testing
  internal long Size { get => Interlocked.Read(ref _cacheSize); }
 
+ internal bool TrackLinkedCacheEntries { get; }
+
  private ICollection<KeyValuePair<object, CacheEntry>> EntriesCollection => _entries;
 
  /// <inheritdoc />
@@ -232,7 +235,7 @@ public bool TryGetValue(object key, out object result)
  entry.LastAccessed = utcNow;
  result = entry.Value;
 
- if (entry.CanPropagateOptions())
+ if (TrackLinkedCacheEntries && entry.CanPropagateOptions())
  {
  // When this entry is retrieved in the scope of creating another entry,
  // that entry needs a copy of these expiration tokens.

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

@@ -53,6 +53,12 @@ public double CompactionPercentage
  }
  }
 
+ /// <summary>
+ /// Gets or sets whether to track linked entries. Disabled by default.
+ /// </summary>
+ /// <remarks>Prior to .NET 7 this feature was always enabled.</remarks>
+ public bool TrackLinkedCacheEntries { get; set; }
+
  MemoryCacheOptions IOptions<MemoryCacheOptions>.Value
  {
  get { return this; }