He creado un caché usando la clase MemoryCache. Le agrego algunos elementos, pero cuando necesito recargar el caché, primero quiero borrarlo. ¿Cuál es la forma más rápida de hacer esto? ¿Debo recorrer todos los elementos y eliminarlos uno a la vez o hay una manera mejor?

Dispose MemoryCache existente y cree un nuevo objeto MemoryCache.

El problema de la enumeración

La sección Comentarios de MemoryCache.GetEnumerator () advierte: "Recuperar un enumerador para una instancia de MemoryCache es una operación de bloqueo y que consume muchos recursos. Por lo tanto, el enumerador no debe usarse en aplicaciones de producción".

Este es el motivo , explicado en pseudocódigo de la implementación 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

Dado que la implementación divide la caché en varios objetos Dictionary, debe reunir todo en una sola colección para poder devolver un enumerador. Cada llamada a GetEnumerator ejecuta el proceso de copia completo detallado arriba. El Diccionario recién creado contiene referencias a la clave interna original y a los objetos de valor, por lo que sus valores de datos almacenados en caché reales no se duplican.

La advertencia en la documentación es correcta. Evite GetEnumerator (), incluidas todas las respuestas anteriores que usan consultas LINQ.

Una solución mejor y más flexible

Esta es una forma eficiente de borrar la caché que simplemente se basa en la infraestructura de monitoreo de cambios existente. También proporciona la flexibilidad de borrar todo el caché o solo un subconjunto con nombre y no tiene ninguno de los problemas discutidos anteriormente.

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

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

La solución alternativa es:

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 el rendimiento no es un problema, este buen resumen hará el truco:

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

Parece que hay un recorte método .

Entonces, para borrar todos los contenidos, simplemente harías

cache.Trim(100)

EDITAR: después de investigar un poco más, parece que no vale la pena dedicar tiempo a buscar en Trim

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

¿Cómo borro un System.Runtime.Caching.MemoryCache?

También puedes hacer algo como esto:

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

Me encontré con esto y, basándose en él, escribí un método claro paralelo ligeramente más efectivo:

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

Solo estaba interesado en borrar el caché y encontré esto como una opción, al usar c # GlobalCachingProvider

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

una versión un poco mejorada de magritte answer.

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

Puede deshacerse del caché MemoryCache.Default y luego restablecer el campo privado singleton en nulo, para que vuelva a crear el MemoryCache.Default.

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