Utworzyłem pamięć podręczną przy użyciu klasy MemoryCache. Dodaje do niego kilka pozycji, ale kiedy muszę ponownie załadować pamięć podręczną, chcę ją najpierw wyczyścić. Jaki jest najszybszy sposób na zrobienie tego? Czy powinienem przejrzeć wszystkie elementy i usuwać je pojedynczo, czy jest lepszy sposób?

Dispose istniejący MemoryCache i utwórz nowy obiekt MemoryCache.

Problem z wyliczeniem

Sekcja Remarks MemoryCache.GetEnumerator () ostrzega: „Pobieranie modułu wyliczającego dla wystąpienia MemoryCache jest operacją intensywnie wykorzystującą zasoby i blokującą. Dlatego moduł wyliczający nie powinien być używany w aplikacjach produkcyjnych”.

Oto dlaczego , wyjaśnione w pseudokodzie implementacji 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

Ponieważ implementacja dzieli pamięć podręczną na wiele obiektów Dictionary, musi połączyć wszystko w jedną kolekcję, aby zwrócić moduł wyliczający. Każde wywołanie GetEnumerator wykonuje pełny proces kopiowania opisany powyżej. Nowo utworzony słownik zawiera odniesienia do oryginalnego klucza wewnętrznego i obiektów wartości, więc rzeczywiste wartości danych w pamięci podręcznej nie są duplikowane.

Ostrzeżenie w dokumentacji jest prawidłowe. Unikaj GetEnumerator () - w tym wszystkie powyższe odpowiedzi, które używają zapytań LINQ.

Lepsze i bardziej elastyczne rozwiązanie

Oto skuteczny sposób czyszczenia pamięci podręcznej, który po prostu opiera się na istniejącej infrastrukturze monitorowania zmian. Zapewnia również elastyczność czyszczenia całej pamięci podręcznej lub tylko nazwanego podzbioru i nie powoduje żadnego z omówionych powyżej problemów.

// 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;
        }
    }
}

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

Sposób obejścia:

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);
}

Jeśli wydajność nie jest problemem, ten fajny, jednoliniowy tekst załatwi sprawę:

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

Wygląda na to, że istnieje metoda przycinania .

Aby wyczyścić całą zawartość, którą po prostu zrobiłbyś

cache.Trim(100)

EDYCJA: po dłuższym kopaniu wydaje się, że zaglądanie do Trim nie jest warte twojego czasu

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

Jak wyczyścić System.Runtime.Caching.MemoryCache

Możesz też zrobić coś takiego:

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

Przebiegłem przez to i na tej podstawie napisałem nieco bardziej efektywną, równoległą przejrzystą metodę:

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

Byłem zainteresowany tylko wyczyszczeniem pamięci podręcznej i znalazłem to jako opcję, używając c # GlobalCachingProvider

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

nieco ulepszona wersja odpowiedzi magritte.

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

Możesz usunąć pamięć podręczną MemoryCache.Default, a następnie ponownie ustawić singleton pola prywatnego na null, aby ponownie utworzył MemoryCache.Default.

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