Я створив кеш, використовуючи клас MemoryCache. Я додаю до нього деякі елементи, але коли мені потрібно перезавантажити кеш, я хочу спершу очистити його. Який найшвидший спосіб зробити це? Чи повинен я переглядати всі елементи та видаляти їх по одному або є кращий спосіб?

Dispose існуючий MemoryCache та створити новий об'єкт MemoryCache.

Проблема з перерахуванням

Розділ зауважень MemoryCache.GetEnumerator () попереджає: "Отримання перечислювача для екземпляра MemoryCache - це ресурсомістка та блокувальна операція. Тому перечислювач не повинен використовуватися у виробничих додатках."

Ось чому , пояснено в псевдокоді реалізації GetEnumerator ():

Create a new Dictionary object (let's call it AllCache)
For Each per-processor segment in the cache (one Dictionary object per processor)
{
    Lock the segment/Dictionary (using lock construct)
    Iterate through the segment/Dictionary and add each name/value pair one-by-one
       to the AllCache Dictionary (using references to the original MemoryCacheKey
       and MemoryCacheEntry objects)
}
Create and return an enumerator on the AllCache Dictionary

Оскільки реалізація розбиває кеш на декілька об'єктів словника, вона повинна об'єднати все в єдину колекцію, щоб повернути перелік. Кожен виклик GetEnumerator виконує повний процес копіювання, детально описаний вище. Щойно створений Словник містить посилання на оригінальний внутрішній ключ та об'єкти значень, тому фактичні значення кешованих даних не дублюються.

Попередження в документації правильне. Уникайте GetEnumerator () - включаючи всі відповіді вище, що використовують запити LINQ.

Краще і гнучкіше рішення

Ось ефективний спосіб очищення кешу, який просто спирається на існуючу інфраструктуру моніторингу змін. Він також забезпечує гнучкість очистити або весь кеш, або лише названий підмножина, і не має жодної з проблем, обговорених вище.

// By Thomas F. Abraham (http://www.tfabraham.com)
namespace CacheTest
{
    using System;
    using System.Diagnostics;
    using System.Globalization;
    using System.Runtime.Caching;

    public class SignaledChangeEventArgs : EventArgs
    {
        public string Name { get; private set; }
        public SignaledChangeEventArgs(string name = null) { this.Name = name; }
    }

    /// <summary>
    /// Cache change monitor that allows an app to fire a change notification
    /// to all associated cache items.
    /// </summary>
    public class SignaledChangeMonitor : ChangeMonitor
    {
        // Shared across all SignaledChangeMonitors in the AppDomain
        private static event EventHandler<SignaledChangeEventArgs> Signaled;

        private string _name;
        private string _uniqueId = Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);

        public override string UniqueId
        {
            get { return _uniqueId; }
        }

        public SignaledChangeMonitor(string name = null)
        {
            _name = name;
            // Register instance with the shared event
            SignaledChangeMonitor.Signaled += OnSignalRaised;
            base.InitializationComplete();
        }

        public static void Signal(string name = null)
        {
            if (Signaled != null)
            {
                // Raise shared event to notify all subscribers
                Signaled(null, new SignaledChangeEventArgs(name));
            }
        }

        protected override void Dispose(bool disposing)
        {
            SignaledChangeMonitor.Signaled -= OnSignalRaised;
        }

        private void OnSignalRaised(object sender, SignaledChangeEventArgs e)
        {
            if (string.IsNullOrWhiteSpace(e.Name) || string.Compare(e.Name, _name, true) == 0)
            {
                Debug.WriteLine(
                    _uniqueId + " notifying cache of change.", "SignaledChangeMonitor");
                // Cache objects are obligated to remove entry upon change notification.
                base.OnChanged(null);
            }
        }
    }

    public static class CacheTester
    {
        public static void TestCache()
        {
            MemoryCache cache = MemoryCache.Default;

            // Add data to cache
            for (int idx = 0; idx < 50; idx++)
            {
                cache.Add("Key" + idx.ToString(), "Value" + idx.ToString(), GetPolicy(idx));
            }

            // Flush cached items associated with "NamedData" change monitors
            SignaledChangeMonitor.Signal("NamedData");

            // Flush all cached items
            SignaledChangeMonitor.Signal();
        }

        private static CacheItemPolicy GetPolicy(int idx)
        {
            string name = (idx % 2 == 0) ? null : "NamedData";

            CacheItemPolicy cip = new CacheItemPolicy();
            cip.AbsoluteExpiration = System.DateTimeOffset.UtcNow.AddHours(1);
            cip.ChangeMonitors.Add(new SignaledChangeMonitor(name));
            return cip;
        }
    }
}

Від http://connect.microsoft.com/VisualStudio/feedback/details/723620/memorycache-class-needs-a-clear-method

Вирішення:

List<string> cacheKeys = MemoryCache.Default.Select(kvp => kvp.Key).ToList();
foreach (string cacheKey in cacheKeys)
{
    MemoryCache.Default.Remove(cacheKey);
}

var cacheItems = cache.ToList();

foreach (KeyValuePair<String, Object> a in cacheItems)
{
    cache.Remove(a.Key);
}

Якщо продуктивність не є проблемою, то цей чудовий однокласник зробить свою справу:

cache.ToList().ForEach(a => cache.Remove(a.Key));

Здається, що існує метод Trim .

Отже, щоб очистити весь вміст, який ви просто зробили

cache.Trim(100)

РЕДАКТУЙТЕ: після копання ще трохи здається, що заглядати в обробку не варто свого часу

https://connect.microsoft.com/VisualStudio/feedback/details/831755/memorycache-trim-method-doesnt-evict-100-of-the-items

Як очистити систему System.Runtime.Caching.MemoryCache

Ви також можете зробити щось подібне:

Dim _Qry = (From n In CacheObject.AsParallel()
           Select n).ToList()
For Each i In _Qry
    CacheObject.Remove(i.Key)
Next

Перебіг цього і на основі цього написав дещо ефективніший, паралельно зрозумілий метод:

    public void ClearAll()
    {
        var allKeys = _cache.Select(o => o.Key);
        Parallel.ForEach(allKeys, key => _cache.Remove(key));
    }

Мене зацікавило лише очищення кешу, і я знайшов це як варіант, коли використовував c # GlobalCachingProvider

                var cache = GlobalCachingProvider.Instance.GetAllItems();
                if (dbOperation.SuccessLoadingAllCacheToDB(cache))
                {
                    cache.Clear();
                }

трохи вдосконалена версія відповіді магрітта.

var cacheKeys = MemoryCache.Default.Where(kvp.Value is MyType).Select(kvp => kvp.Key).ToList();
foreach (string cacheKey in cacheKeys)
{
    MemoryCache.Default.Remove(cacheKey);
}

Ви можете розпоряджатись кешем MemoryCache.Default, а потім знову встановлювати приватне поле singleton на нуль, щоб він відтворив MemoryCache.Default.

       var field = typeof(MemoryCache).GetField("s_defaultCache",
            BindingFlags.Static |
            BindingFlags.NonPublic);
        field.SetValue(null, null);