J'ai créé un cache en utilisant la classe MemoryCache. J'y ajoute quelques éléments, mais lorsque j'ai besoin de recharger le cache, je veux d'abord l'effacer. Quelle est la manière la plus rapide de procéder? Dois-je parcourir tous les éléments et les supprimer un par un ou y a-t-il un meilleur moyen?

Dispose le MemoryCache existant et créez un nouvel objet MemoryCache.

Le problème de l'énumération

La section Notes de MemoryCache.GetEnumerator () avertit: "La récupération d'un énumérateur pour une instance de MemoryCache est une opération de blocage et gourmande en ressources. Par conséquent, l'énumérateur ne doit pas être utilisé dans les applications de production."

Voici pourquoi , expliqué dans le pseudocode de l'implémentation 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

Étant donné que l'implémentation divise le cache entre plusieurs objets Dictionary, elle doit tout rassembler dans une seule collection afin de rendre un énumérateur. Chaque appel à GetEnumerator exécute le processus de copie complet détaillé ci-dessus. Le dictionnaire nouvellement créé contient des références aux objets clé et valeur internes d'origine, de sorte que vos valeurs de données mises en cache réelles ne sont pas dupliquées.

L'avertissement dans la documentation est correct. Évitez GetEnumerator () - y compris toutes les réponses ci-dessus qui utilisent des requêtes LINQ.

Une solution meilleure et plus flexible

Voici un moyen efficace de vider le cache qui s'appuie simplement sur l'infrastructure de surveillance des changements existante. Il offre également la flexibilité de vider le cache entier ou juste un sous-ensemble nommé et ne présente aucun des problèmes évoqués ci-dessus.

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

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

La solution de contournement est:

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

Si les performances ne sont pas un problème, ce joli one-liner fera l'affaire:

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

Il semble qu'il existe une méthode Trim .

Donc pour effacer tout le contenu que vous venez de faire

cache.Trim(100)

EDIT: après avoir creusé un peu plus, il semble que regarder dans Trim ne vaut pas votre temps

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

Comment effacer un System.Runtime.Caching.MemoryCache

Vous pouvez également faire quelque chose comme ceci:

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

J'ai couru à travers cela et, sur cette base, a écrit une méthode claire et parallèle légèrement plus efficace:

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

Je n'étais intéressé que par l'effacement du cache et j'ai trouvé cela comme une option, lors de l'utilisation du c # GlobalCachingProvider

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

une version un peu améliorée de la réponse magritte.

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

Vous pouvez supprimer le cache MemoryCache.Default, puis redéfinir le singleton de champ privé sur null, pour qu'il recrée le MemoryCache.Default.

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