MemoryCache.cs

// 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;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Configuration;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.Caching.Configuration;
using System.Runtime.Caching.Resources;
using System.Runtime.Versioning;
using System.Security;
using System.Threading;

namespace System.Runtime.Caching
{
    public class MemoryCache : ObjectCache, IEnumerable, IDisposable
    {
        private const DefaultCacheCapabilities CAPABILITIES = DefaultCacheCapabilities.InMemoryProvider
                                                              | DefaultCacheCapabilities.CacheEntryChangeMonitors
                                                              | DefaultCacheCapabilities.AbsoluteExpirations
                                                              | DefaultCacheCapabilities.SlidingExpirations
                                                              | DefaultCacheCapabilities.CacheEntryUpdateCallback
                                                              | DefaultCacheCapabilities.CacheEntryRemovedCallback;
        private static readonly TimeSpan s_oneYear = new TimeSpan(365, 0, 0, 0);
        private static readonly object s_initLock = new object();
        private static MemoryCache s_defaultCache;
        private static readonly CacheEntryRemovedCallback s_sentinelRemovedCallback = new CacheEntryRemovedCallback(SentinelEntry.OnCacheEntryRemovedCallback);
        private GCHandleRef<MemoryCacheStore>[] _storeRefs;
        private int _storeCount;
        private int _disposed;
        private MemoryCacheStatistics _stats;
        private readonly string _name;
        private Counters _perfCounters;
        private readonly bool _configLess;
        private bool _useMemoryCacheManager = true;
        private bool _throwOnDisposed;
        private EventHandler _onAppDomainUnload;
        private UnhandledExceptionEventHandler _onUnhandledException;
#if NET
        [UnsupportedOSPlatformGuard("browser")]
        private static bool _countersSupported => !OperatingSystem.IsBrowser();
#else
        private static bool _countersSupported => true;
#endif

        private bool IsDisposed { get { return (_disposed == 1); } }
        internal bool ConfigLess { get { return _configLess; } }

        private sealed class SentinelEntry
        {
            private readonly string _key;
            private readonly ChangeMonitor _expensiveObjectDependency;
            private readonly CacheEntryUpdateCallback _updateCallback;

            internal SentinelEntry(string key, ChangeMonitor expensiveObjectDependency, CacheEntryUpdateCallback callback)
            {
                _key = key;
                _expensiveObjectDependency = expensiveObjectDependency;
                _updateCallback = callback;
            }

            internal string Key
            {
                get { return _key; }
            }

            internal ChangeMonitor ExpensiveObjectDependency
            {
                get { return _expensiveObjectDependency; }
            }

            internal CacheEntryUpdateCallback CacheEntryUpdateCallback
            {
                get { return _updateCallback; }
            }

            private static bool IsPolicyValid(CacheItemPolicy policy)
            {
                if (policy == null)
                {
                    return false;
                }
                // see if any change monitors have changed
                bool hasChanged = false;
                Collection<ChangeMonitor> changeMonitors = policy.ChangeMonitors;
                if (changeMonitors != null)
                {
                    foreach (ChangeMonitor monitor in changeMonitors)
                    {
                        if (monitor != null && monitor.HasChanged)
                        {
                            hasChanged = true;
                            break;
                        }
                    }
                }
                // if the monitors haven't changed yet and we have an update callback
                // then the policy is valid
                if (!hasChanged && policy.UpdateCallback != null)
                {
                    return true;
                }
                // if the monitors have changed we need to dispose them
                if (hasChanged)
                {
                    foreach (ChangeMonitor monitor in changeMonitors)
                    {
                        monitor?.Dispose();
                    }
                }
                return false;
            }

            internal static void OnCacheEntryRemovedCallback(CacheEntryRemovedArguments arguments)
            {
                MemoryCache cache = arguments.Source as MemoryCache;
                SentinelEntry entry = arguments.CacheItem.Value as SentinelEntry;
                CacheEntryRemovedReason reason = arguments.RemovedReason;
                switch (reason)
                {
                    case CacheEntryRemovedReason.Expired:
                        break;
                    case CacheEntryRemovedReason.ChangeMonitorChanged:
                        if (entry.ExpensiveObjectDependency.HasChanged)
                        {
                            // If the expensiveObject has been removed explicitly by Cache.Remove,
                            // return from the SentinelEntry removed callback
                            // thus effectively removing the SentinelEntry from the cache.
                            return;
                        }
                        break;
                    case CacheEntryRemovedReason.Evicted:
                        Debug.Fail("Reason should never be CacheEntryRemovedReason.Evicted since the entry was inserted as NotRemovable.");
                        return;
                    default:
                        // do nothing if reason is Removed or CacheSpecificEviction
                        return;
                }

                // invoke update callback
                try
                {
                    CacheEntryUpdateArguments args = new CacheEntryUpdateArguments(cache, reason, entry.Key, null);
                    entry.CacheEntryUpdateCallback(args);
                    object expensiveObject = args.UpdatedCacheItem?.Value;
                    CacheItemPolicy policy = args.UpdatedCacheItemPolicy;
                    // Only update the "expensive" object if the user returns a new object,
                    // a policy with update callback, and the change monitors haven't changed.  (Inserting
                    // with change monitors that have already changed will cause recursion.)
                    if (expensiveObject != null && IsPolicyValid(policy))
                    {
                        cache.Set(entry.Key, expensiveObject, policy);
                    }
                    else
                    {
                        cache.Remove(entry.Key);
                    }
                }
                catch
                {
                    cache.Remove(entry.Key);
                    // Review: What should we do with this exception?
                }
            }
        }

        // private and internal

        internal MemoryCacheStore GetStore(MemoryCacheKey cacheKey)
        {
            int hashCode = cacheKey.Hash;
            if (hashCode < 0)
            {
                hashCode = (hashCode == int.MinValue) ? 0 : -hashCode;
            }
            int idx = hashCode % _storeCount;
            return _storeRefs[idx].Target;
        }

        internal object[] AllSRefTargets
        {
            get
            {
                var allStores = new MemoryCacheStore[_storeCount];
                for (int i = 0; i < _storeCount; i++)
                {
                    allStores[i] = _storeRefs[i].Target;
                }
                return allStores;
            }
        }

        private void InitDisposableMembers(NameValueCollection config)
        {
            bool dispose = true;
            try
            {
                try
                {
                    if (_countersSupported)
                    {
                        _perfCounters = new Counters(_name);
                    }
                }
                catch
                {
                    // ignore exceptions from perf counters
                }
                for (int i = 0; i < _storeCount; i++)
                {
                    _storeRefs[i] = new GCHandleRef<MemoryCacheStore>(new MemoryCacheStore(this, _perfCounters));
                }
                _stats = new MemoryCacheStatistics(this, config);
                AppDomain appDomain = Thread.GetDomain();
                EventHandler onAppDomainUnload = new EventHandler(OnAppDomainUnload);
                appDomain.DomainUnload += onAppDomainUnload;
                _onAppDomainUnload = onAppDomainUnload;
                UnhandledExceptionEventHandler onUnhandledException = new UnhandledExceptionEventHandler(OnUnhandledException);
                appDomain.UnhandledException += onUnhandledException;
                _onUnhandledException = onUnhandledException;
                dispose = false;
            }
            finally
            {
                if (dispose)
                {
                    Dispose();
                }
            }
        }

        private void OnAppDomainUnload(object unusedObject, EventArgs unusedEventArgs)
        {
            Dispose();
        }

        private void OnUnhandledException(object sender, UnhandledExceptionEventArgs eventArgs)
        {
            // if the CLR is terminating, dispose the cache.
            // This will dispose the perf counters
            if (eventArgs.IsTerminating)
            {
                Dispose();
            }
        }

        private static void ValidatePolicy(CacheItemPolicy policy)
        {
            if (policy.AbsoluteExpiration != ObjectCache.InfiniteAbsoluteExpiration
                && policy.SlidingExpiration != ObjectCache.NoSlidingExpiration)
            {
                throw new ArgumentException(SR.Invalid_expiration_combination, nameof(policy));
            }
            if (policy.SlidingExpiration < ObjectCache.NoSlidingExpiration || s_oneYear < policy.SlidingExpiration)
            {
                throw new ArgumentOutOfRangeException(nameof(policy), RH.Format(SR.Argument_out_of_range, "SlidingExpiration", ObjectCache.NoSlidingExpiration, s_oneYear));
            }
            if (policy.RemovedCallback != null
                && policy.UpdateCallback != null)
            {
                throw new ArgumentException(SR.Invalid_callback_combination, nameof(policy));
            }
            if (policy.Priority != CacheItemPriority.Default && policy.Priority != CacheItemPriority.NotRemovable)
            {
                throw new ArgumentOutOfRangeException(nameof(policy), RH.Format(SR.Argument_out_of_range, "Priority", CacheItemPriority.Default, CacheItemPriority.NotRemovable));
            }
        }

        // public

        // Amount of memory that can be used before
        // the cache begins to forcibly remove items.
        public long CacheMemoryLimit
        {
            get
            {
                return _stats.CacheMemoryLimit;
            }
        }

        public static MemoryCache Default
        {
            get
            {
                if (s_defaultCache == null)
                {
                    lock (s_initLock)
                    {
                        s_defaultCache ??= new MemoryCache();
                    }
                }
                return s_defaultCache;
            }
        }

        public override DefaultCacheCapabilities DefaultCacheCapabilities
        {
            get
            {
                return CAPABILITIES;
            }
        }

        public override string Name
        {
            get { return _name; }
        }

        internal bool UseMemoryCacheManager
        {
            get { return _useMemoryCacheManager; }
        }

        // Percentage of physical memory that can be used before
        // the cache begins to forcibly remove items.
        public long PhysicalMemoryLimit
        {
            get
            {
                return _stats.PhysicalMemoryLimit;
            }
        }

        // The maximum interval of time after which the cache
        // will update its memory statistics.
        public TimeSpan PollingInterval
        {
            get
            {
                return _stats.PollingInterval;
            }
        }

        // Only used for Default MemoryCache
        private MemoryCache()
        {
            _name = "Default";
            Init(null);
        }

        public MemoryCache(string name, NameValueCollection config = null)
        {
            if (name is null)
            {
                throw new ArgumentNullException(nameof(name));
            }

            if (name.Length == 0)
            {
                throw new ArgumentException(SR.Empty_string_invalid, nameof(name));
            }
            if (string.Equals(name, "default", StringComparison.OrdinalIgnoreCase))
            {
                throw new ArgumentException(SR.Default_is_reserved, nameof(name));
            }
            _name = name;
            Init(config);
        }

        // ignoreConfigSection is used when redirecting ASP.NET cache into the MemoryCache.  This avoids infinite recursion
        // due to the fact that the (ASP.NET) config system uses the cache, and the cache uses the config system.
        public MemoryCache(string name, NameValueCollection config, bool ignoreConfigSection)
        {
            if (name is null)
            {
                throw new ArgumentNullException(nameof(name));
            }

            if (name.Length == 0)
            {
                throw new ArgumentException(SR.Empty_string_invalid, nameof(name));
            }
            if (string.Equals(name, "default", StringComparison.OrdinalIgnoreCase))
            {
                throw new ArgumentException(SR.Default_is_reserved, nameof(name));
            }
            _name = name;
            _configLess = ignoreConfigSection;
            Init(config);
        }

        private void Init(NameValueCollection config)
        {
            _storeCount = Environment.ProcessorCount;
            _storeRefs = new GCHandleRef<MemoryCacheStore>[_storeCount];
            if (config != null)
            {
                _useMemoryCacheManager = ConfigUtil.GetBooleanValue(config, ConfigUtil.UseMemoryCacheManager, true);
                _throwOnDisposed = ConfigUtil.GetBooleanValue(config, ConfigUtil.ThrowOnDisposed, false);
            }
            InitDisposableMembers(config);
        }

        private object AddOrGetExistingInternal(string key, object value, CacheItemPolicy policy)
        {
            if (key is null)
            {
                throw new ArgumentNullException(nameof(key));
            }

            DateTimeOffset absExp = ObjectCache.InfiniteAbsoluteExpiration;
            TimeSpan slidingExp = ObjectCache.NoSlidingExpiration;
            CacheItemPriority priority = CacheItemPriority.Default;
            Collection<ChangeMonitor> changeMonitors = null;
            CacheEntryRemovedCallback removedCallback = null;
            if (policy != null)
            {
                ValidatePolicy(policy);
                if (policy.UpdateCallback != null)
                {
                    throw new ArgumentException(SR.Update_callback_must_be_null, nameof(policy));
                }
                absExp = policy.AbsoluteExpiration;
                slidingExp = policy.SlidingExpiration;
                priority = policy.Priority;
                changeMonitors = policy.ChangeMonitors;
                removedCallback = policy.RemovedCallback;
            }
            if (IsDisposed)
            {
                if (changeMonitors != null)
                {
                    foreach (ChangeMonitor monitor in changeMonitors)
                    {
                        monitor?.Dispose();
                    }
                }

                IsDisposedOrThrow();

                return null;
            }
            MemoryCacheKey cacheKey = new MemoryCacheKey(key);
            MemoryCacheStore store = GetStore(cacheKey);
            MemoryCacheEntry entry = store.AddOrGetExisting(cacheKey, new MemoryCacheEntry(key, value, absExp, slidingExp, priority, changeMonitors, removedCallback, this));
            return entry?.Value;
        }

        public override CacheEntryChangeMonitor CreateCacheEntryChangeMonitor(IEnumerable<string> keys, string regionName = null)
        {
            if (regionName != null)
            {
                throw new NotSupportedException(SR.RegionName_not_supported);
            }
            if (keys == null)
            {
                throw new ArgumentNullException(nameof(keys));
            }
            List<string> keysClone = new List<string>(keys);
            if (keysClone.Count == 0)
            {
                throw new ArgumentException(RH.Format(SR.Empty_collection, nameof(keys)));
            }

            foreach (string key in keysClone)
            {
                if (key == null)
                {
                    throw new ArgumentException(RH.Format(SR.Collection_contains_null_element, nameof(keys)));
                }
            }

            return new MemoryCacheEntryChangeMonitor(keysClone.AsReadOnly(), regionName, this);
        }

        public void Dispose()
        {
            if (Interlocked.Exchange(ref _disposed, 1) == 0)
            {
                // unhook domain events
                DisposeSafeCritical();
                // stats must be disposed prior to disposing the stores.
                _stats?.Dispose();
                if (_storeRefs != null)
                {
                    foreach (var storeRef in _storeRefs)
                    {
                        storeRef?.Dispose();
                    }
                }
                if (_perfCounters != null)
                {
                    if (_countersSupported)
                    {
                        _perfCounters.Dispose();
                    }
                }
                GC.SuppressFinalize(this);
            }
        }

        private void DisposeSafeCritical()
        {
            AppDomain appDomain = Thread.GetDomain();
            if (_onAppDomainUnload != null)
            {
                appDomain.DomainUnload -= _onAppDomainUnload;
            }
            if (_onUnhandledException != null)
            {
                appDomain.UnhandledException -= _onUnhandledException;
            }
        }

        private object GetInternal(string key, string regionName)
        {
            if (regionName != null)
            {
                throw new NotSupportedException(SR.RegionName_not_supported);
            }
            if (key == null)
            {
                throw new ArgumentNullException(nameof(key));
            }
            MemoryCacheEntry entry = GetEntry(key);
            return entry?.Value;
        }

        internal MemoryCacheEntry GetEntry(string key)
        {
            if (IsDisposedOrThrow())
            {
                return null;
            }
            MemoryCacheKey cacheKey = new MemoryCacheKey(key);
            MemoryCacheStore store = GetStore(cacheKey);
            return store.Get(cacheKey);
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            Hashtable h = new Hashtable();

            if (!IsDisposedOrThrow())
            {
                foreach (var storeRef in _storeRefs)
                {
                    storeRef.Target.CopyTo(h);
                }
            }
            return h.GetEnumerator();
        }

        protected override IEnumerator<KeyValuePair<string, object>> GetEnumerator()
        {
            Dictionary<string, object> h = new Dictionary<string, object>();

            if (!IsDisposedOrThrow())
            {
                foreach (var storeRef in _storeRefs)
                {
                    storeRef.Target.CopyTo(h);
                }
            }
            return h.GetEnumerator();
        }

        internal MemoryCacheEntry RemoveEntry(string key, MemoryCacheEntry entry, CacheEntryRemovedReason reason)
        {
            MemoryCacheKey cacheKey = new MemoryCacheKey(key);
            MemoryCacheStore store = GetStore(cacheKey);
            return store.Remove(cacheKey, entry, reason);
        }

        public long Trim(int percent)
        {
            long trimmed = 0;
            if (percent > 100)
            {
                percent = 100;
            }

            if (!IsDisposedOrThrow())
            {
                foreach (var storeRef in _storeRefs)
                {
                    trimmed += storeRef.Target.TrimInternal(percent);
                }
            }
            return trimmed;
        }

        //Default indexer property
        public override object this[string key]
        {
            get
            {
                return GetInternal(key, null);
            }
            set
            {
                Set(key, value, ObjectCache.InfiniteAbsoluteExpiration);
            }
        }

        //Existence check for a single item
        public override bool Contains(string key, string regionName = null)
        {
            return (GetInternal(key, regionName) != null);
        }

        public override bool Add(CacheItem item, CacheItemPolicy policy)
        {
            CacheItem existingEntry = AddOrGetExisting(item, policy);
            return (existingEntry == null || existingEntry.Value == null);
        }

        public override object AddOrGetExisting(string key, object value, DateTimeOffset absoluteExpiration, string regionName = null)
        {
            if (regionName != null)
            {
                throw new NotSupportedException(SR.RegionName_not_supported);
            }
            CacheItemPolicy policy = new CacheItemPolicy();
            policy.AbsoluteExpiration = absoluteExpiration;
            return AddOrGetExistingInternal(key, value, policy);
        }

        public override CacheItem AddOrGetExisting(CacheItem item, CacheItemPolicy policy)
        {
            if (item is null)
            {
                throw new ArgumentNullException(nameof(item));
            }

            return new CacheItem(item.Key, AddOrGetExistingInternal(item.Key, item.Value, policy));
        }

        public override object AddOrGetExisting(string key, object value, CacheItemPolicy policy, string regionName = null)
        {
            if (regionName != null)
            {
                throw new NotSupportedException(SR.RegionName_not_supported);
            }
            return AddOrGetExistingInternal(key, value, policy);
        }

        public override object Get(string key, string regionName = null)
        {
            return GetInternal(key, regionName);
        }

        public override CacheItem GetCacheItem(string key, string regionName = null)
        {
            object value = GetInternal(key, regionName);
            return (value != null) ? new CacheItem(key, value) : null;
        }

        public override void Set(string key, object value, DateTimeOffset absoluteExpiration, string regionName = null)
        {
            if (regionName != null)
            {
                throw new NotSupportedException(SR.RegionName_not_supported);
            }
            CacheItemPolicy policy = new CacheItemPolicy();
            policy.AbsoluteExpiration = absoluteExpiration;
            Set(key, value, policy);
        }

        public override void Set(CacheItem item, CacheItemPolicy policy)
        {
            if (item is null)
            {
                throw new ArgumentNullException(nameof(item));
            }

            Set(item.Key, item.Value, policy);
        }

        public override void Set(string key, object value, CacheItemPolicy policy, string regionName = null)
        {
            if (regionName != null)
            {
                throw new NotSupportedException(SR.RegionName_not_supported);
            }
            if (key == null)
            {
                throw new ArgumentNullException(nameof(key));
            }
            DateTimeOffset absExp = ObjectCache.InfiniteAbsoluteExpiration;
            TimeSpan slidingExp = ObjectCache.NoSlidingExpiration;
            CacheItemPriority priority = CacheItemPriority.Default;
            Collection<ChangeMonitor> changeMonitors = null;
            CacheEntryRemovedCallback removedCallback = null;
            if (policy != null)
            {
                ValidatePolicy(policy);
                if (policy.UpdateCallback != null)
                {
                    Set(key, value, policy.ChangeMonitors, policy.AbsoluteExpiration, policy.SlidingExpiration, policy.UpdateCallback);
                    return;
                }
                absExp = policy.AbsoluteExpiration;
                slidingExp = policy.SlidingExpiration;
                priority = policy.Priority;
                changeMonitors = policy.ChangeMonitors;
                removedCallback = policy.RemovedCallback;
            }
            if (IsDisposed)
            {
                if (changeMonitors != null)
                {
                    foreach (ChangeMonitor monitor in changeMonitors)
                    {
                        monitor?.Dispose();
                    }
                }

                IsDisposedOrThrow();

                return;
            }
            MemoryCacheKey cacheKey = new MemoryCacheKey(key);
            MemoryCacheStore store = GetStore(cacheKey);
            store.Set(cacheKey, new MemoryCacheEntry(key, value, absExp, slidingExp, priority, changeMonitors, removedCallback, this));
        }

        internal void Set(string key,
                          object value,
                          Collection<ChangeMonitor> changeMonitors,
                          DateTimeOffset absoluteExpiration,
                          TimeSpan slidingExpiration,
                          CacheEntryUpdateCallback onUpdateCallback)
        {
            if (key is null)
            {
                throw new ArgumentNullException(nameof(key));
            }

            if (changeMonitors == null
                && absoluteExpiration == ObjectCache.InfiniteAbsoluteExpiration
                && slidingExpiration == ObjectCache.NoSlidingExpiration)
            {
                throw new ArgumentException(SR.Invalid_argument_combination);
            }
            if (onUpdateCallback == null)
            {
                throw new ArgumentNullException(nameof(onUpdateCallback));
            }
            if (IsDisposed)
            {
                if (changeMonitors != null)
                {
                    foreach (ChangeMonitor monitor in changeMonitors)
                    {
                        monitor?.Dispose();
                    }
                }

                IsDisposedOrThrow();

                return;
            }
            // Insert updatable cache entry
            MemoryCacheKey cacheKey = new MemoryCacheKey(key);
            MemoryCacheStore store = GetStore(cacheKey);
            MemoryCacheEntry cacheEntry = new MemoryCacheEntry(key,
                                                               value,
                                                               ObjectCache.InfiniteAbsoluteExpiration,
                                                               ObjectCache.NoSlidingExpiration,
                                                               CacheItemPriority.NotRemovable,
                                                               null,
                                                               null,
                                                               this);
            store.Set(cacheKey, cacheEntry);

            // Ensure the sentinel depends on its updatable entry
            string[] cacheKeys = { key };
            ChangeMonitor expensiveObjectDep = CreateCacheEntryChangeMonitor(cacheKeys);
            changeMonitors ??= new Collection<ChangeMonitor>();
            changeMonitors.Add(expensiveObjectDep);

            // Insert sentinel entry for the updatable cache entry
            MemoryCacheKey sentinelCacheKey = new MemoryCacheKey("OnUpdateSentinel" + key);
            MemoryCacheStore sentinelStore = GetStore(sentinelCacheKey);
            MemoryCacheEntry sentinelCacheEntry = new MemoryCacheEntry(sentinelCacheKey.Key,
                                                                       new SentinelEntry(key, expensiveObjectDep, onUpdateCallback),
                                                                       absoluteExpiration,
                                                                       slidingExpiration,
                                                                       CacheItemPriority.NotRemovable,
                                                                       changeMonitors,
                                                                       s_sentinelRemovedCallback,
                                                                       this);
            sentinelStore.Set(sentinelCacheKey, sentinelCacheEntry);
            cacheEntry.ConfigureUpdateSentinel(sentinelStore, sentinelCacheEntry);
        }

        public override object Remove(string key, string regionName = null)
        {
            return Remove(key, CacheEntryRemovedReason.Removed, regionName);
        }

        public object Remove(string key, CacheEntryRemovedReason reason, string regionName = null)
        {
            if (regionName != null)
            {
                throw new NotSupportedException(SR.RegionName_not_supported);
            }
            if (key == null)
            {
                throw new ArgumentNullException(nameof(key));
            }
            if (IsDisposedOrThrow())
            {
                return null;
            }
            MemoryCacheEntry entry = RemoveEntry(key, null, reason);
            return entry?.Value;
        }

        public override long GetCount(string regionName = null)
        {
            if (regionName != null)
            {
                throw new NotSupportedException(SR.RegionName_not_supported);
            }

            long count = 0;

            if (!IsDisposedOrThrow())
            {
                foreach (var storeRef in _storeRefs)
                {
                    count += storeRef.Target.Count;
                }
            }
            return count;
        }

        public long GetLastSize(string regionName = null)
        {
            if (regionName != null)
            {
                throw new NotSupportedException(SR.RegionName_not_supported);
            }

            return _stats.GetLastSize();
        }

        public override IDictionary<string, object> GetValues(IEnumerable<string> keys, string regionName = null)
        {
            if (regionName != null)
            {
                throw new NotSupportedException(SR.RegionName_not_supported);
            }
            if (keys == null)
            {
                throw new ArgumentNullException(nameof(keys));
            }

            Dictionary<string, object> values = null;

            if (!IsDisposedOrThrow())
            {
                foreach (string key in keys)
                {
                    if (key == null)
                    {
                        throw new ArgumentException(RH.Format(SR.Collection_contains_null_element, nameof(keys)));
                    }
                    object value = GetInternal(key, null);
                    if (value != null)
                    {
                        values ??= new Dictionary<string, object>();
                        values[key] = value;
                    }
                }
            }
            return values;
        }

        // used when redirecting ASP.NET cache into the MemoryCache.  This avoids infinite recursion
        // due to the fact that the (ASP.NET) config system uses the cache, and the cache uses the
        // config system.
        internal void UpdateConfig(NameValueCollection config)
        {
            if (config is null)
            {
                throw new ArgumentNullException(nameof(config));
            }

            if (!IsDisposed)
            {
                _stats.UpdateConfig(config);
            }
        }

        private bool IsDisposedOrThrow()
        {
            if (!IsDisposed)
                return false;

            if (_throwOnDisposed)
            {
                string cacheName = $"{this.GetType().FullName}({_name})";
                throw new ObjectDisposedException(cacheName);
            }

            return true;
        }
    }
}