Tôi đã tạo một bộ nhớ cache bằng cách sử dụng lớp MemoryCache. Tôi thêm một số mục vào nó nhưng khi tôi cần tải lại bộ nhớ cache, tôi muốn xóa nó trước. Cách nhanh nhất để làm điều này là gì? Tôi có nên lặp lại tất cả các mục và xóa từng mục một hay có cách nào tốt hơn?

Dispose MemoryCache hiện có và tạo một đối tượng MemoryCache mới.

Vấn đề với liệt kê

Phần Ghi chú MemoryCache.GetEnumerator () cảnh báo: "Lấy một điều tra viên cho một cá thể MemoryCache là một hoạt động chặn và sử dụng nhiều tài nguyên. Do đó, điều tra viên không nên được sử dụng trong các ứng dụng sản xuất."

Đây là lý do tại sao , được giải thích trong mã giả của việc triển khai 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

Vì quá trình triển khai phân chia bộ nhớ cache trên nhiều đối tượng Từ điển, nên nó phải tập hợp mọi thứ lại với nhau thành một tập hợp duy nhất để giao lại một người điều tra. Mọi cuộc gọi tới GetEnumerator đều thực hiện quy trình sao chép đầy đủ được nêu chi tiết ở trên. Từ điển mới được tạo chứa các tham chiếu đến các đối tượng giá trị và khóa bên trong ban đầu, vì vậy các giá trị dữ liệu được lưu trong bộ nhớ cache thực tế của bạn không bị trùng lặp.

Cảnh báo trong tài liệu là chính xác. Tránh GetEnumerator () - bao gồm tất cả các câu trả lời ở trên sử dụng truy vấn LINQ.

Một giải pháp tốt hơn và linh hoạt hơn

Đây là một cách hiệu quả để xóa bộ nhớ cache mà chỉ đơn giản là xây dựng trên cơ sở hạ tầng giám sát thay đổi hiện có. Nó cũng cung cấp sự linh hoạt để xóa toàn bộ bộ nhớ cache hoặc chỉ một tập hợp con được đặt tên và không có vấn đề nào được thảo luận ở trên.

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

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

Cách giải quyết là:

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

Nếu hiệu suất không phải là vấn đề thì một lớp lót tốt này sẽ thực hiện thủ thuật:

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

Có vẻ như có một Trim phương pháp .

Vì vậy, để xóa tất cả nội dung bạn chỉ cần làm

cache.Trim(100)

CHỈNH SỬA: sau khi tìm hiểu thêm, có vẻ như việc xem xét Trim không đáng để bạn mất thời gian

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

Làm cách nào để xóa System.Runtime.Caching.MemoryCache

Bạn cũng có thể làm điều gì đó như sau:

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

Chạy qua điều này, và dựa trên nó, đã viết một phương pháp rõ ràng song song, hiệu quả hơn một chút:

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

Tôi chỉ quan tâm đến việc xóa bộ nhớ cache và thấy đây là một tùy chọn, khi sử dụng c # GlobalCachingProvider

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

một phiên bản cải tiến một chút của câu trả lời magritte.

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

Bạn có thể loại bỏ bộ nhớ cache MemoryCache.Default và sau đó đặt lại trường riêng tư singleton thành null, để làm cho nó tạo lại MemoryCache.Default.

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