Saya telah membuat cache menggunakan kelas MemoryCache. Saya menambahkan beberapa item ke dalamnya tetapi ketika saya perlu memuat ulang cache saya ingin menghapusnya terlebih dahulu. Apa cara tercepat untuk melakukan ini? Haruskah saya mengulang semua item dan menghapusnya satu per satu atau adakah cara yang lebih baik?

Dispose MemoryCache yang ada dan buat objek MemoryCache baru.

Masalah dengan pencacahan

Bagian MemoryCache.GetEnumerator () Keterangan memperingatkan: "Mengambil enumerator untuk instance MemoryCache adalah operasi pemblokiran dan sumber daya intensif. Oleh karena itu, enumerator tidak boleh digunakan dalam aplikasi produksi."

Inilah alasannya , dijelaskan dalam pseudocode implementasi 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

Karena implementasi membagi cache di beberapa objek Dictionary, itu harus menyatukan semuanya menjadi satu koleksi untuk mengembalikan enumerator. Setiap panggilan ke GetEnumerator menjalankan proses penyalinan lengkap yang dijelaskan di atas. Dictionary yang baru dibuat berisi referensi ke kunci internal asli dan objek nilai, sehingga nilai data cache Anda yang sebenarnya tidak diduplikasi.

Peringatan di dokumentasi benar. Hindari GetEnumerator () - termasuk semua jawaban di atas yang menggunakan kueri LINQ.

Solusi yang lebih baik dan lebih fleksibel

Berikut adalah cara efisien untuk membersihkan cache yang hanya dibangun di atas infrastruktur pemantauan perubahan yang ada. Ini juga memberikan fleksibilitas untuk menghapus seluruh cache atau hanya subset bernama dan tidak memiliki masalah yang dibahas di atas.

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

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

Solusinya adalah:

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

Jika kinerja tidak menjadi masalah maka satu baris yang bagus ini akan melakukan trik:

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

Sepertinya ada Trim metode .

Jadi untuk menghapus semua konten yang baru saja Anda lakukan

cache.Trim(100)

EDIT: setelah menggali lagi, tampaknya melihat Trim tidak sepadan dengan waktu Anda

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

Bagaimana cara menghapus System.Runtime.Caching.MemoryCache

Anda juga bisa melakukan sesuatu seperti ini:

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

Berlari melintasi ini, dan berdasarkan itu, menulis metode paralel yang sedikit lebih efektif dan jelas:

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

Saya hanya tertarik untuk membersihkan cache dan menemukan ini sebagai opsi, saat menggunakan c # GlobalCachingProvider

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

versi jawaban magritte yang sedikit lebih baik.

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

Anda dapat membuang cache MemoryCache.Default dan kemudian menyetel ulang kolom privat tunggal menjadi nol, untuk membuatnya membuat ulang MemoryCache.Default.

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