Sperrmuster für die ordnungsgemäße Verwendung von .NET MemoryCache

Ich gehe davon aus, dass dieser Code Probleme mit der Parallelität hat:

const string CacheKey = "CacheKey";
static string GetCachedData()
{
    string expensiveString =null;
    if (MemoryCache.Default.Contains(CacheKey))
    {
        expensiveString = MemoryCache.Default[CacheKey] as string;
    }
    else
    {
        CacheItemPolicy cip = new CacheItemPolicy()
        {
            AbsoluteExpiration = new DateTimeOffset(DateTime.Now.AddMinutes(20))
        };
        expensiveString = SomeHeavyAndExpensiveCalculation();
        MemoryCache.Default.Set(CacheKey, expensiveString, cip);
    }
    return expensiveString;
}

Der Grund für das Problem der Parallelität besteht darin, dass mehrere Threads einen Nullschlüssel erhalten und dann versuchen können, Daten in den Cache einzufügen.

Was wäre der kürzeste und sauberste Weg, um diesen Code gleichzeitig zu prüfen? Ich folge gerne einem guten Muster in meinem Cache-Code. Ein Link zu einem Online-Artikel wäre eine große Hilfe.

AKTUALISIEREN:

Ich habe diesen Code basierend auf der Antwort von @Scott Chamberlain entwickelt. Kann jemand ein Leistungs- oder Parallelitätsproblem damit finden? Wenn dies funktioniert, würden viele Codezeilen und Fehler eingespart.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.Caching;

namespace CachePoc
{
    class Program
    {
        static object everoneUseThisLockObject4CacheXYZ = new object();
        const string CacheXYZ = "CacheXYZ";
        static object everoneUseThisLockObject4CacheABC = new object();
        const string CacheABC = "CacheABC";

        static void Main(string[] args)
        {
            string xyzData = MemoryCacheHelper.GetCachedData<string>(CacheXYZ, everoneUseThisLockObject4CacheXYZ, 20, SomeHeavyAndExpensiveXYZCalculation);
            string abcData = MemoryCacheHelper.GetCachedData<string>(CacheABC, everoneUseThisLockObject4CacheXYZ, 20, SomeHeavyAndExpensiveXYZCalculation);
        }

        private static string SomeHeavyAndExpensiveXYZCalculation() {return "Expensive";}
        private static string SomeHeavyAndExpensiveABCCalculation() {return "Expensive";}

        public static class MemoryCacheHelper
        {
            public static T GetCachedData<T>(string cacheKey, object cacheLock, int cacheTimePolicyMinutes, Func<T> GetData)
                where T : class
            {
                //Returns null if the string does not exist, prevents a race condition where the cache invalidates between the contains check and the retreival.
                T cachedData = MemoryCache.Default.Get(cacheKey, null) as T;

                if (cachedData != null)
                {
                    return cachedData;
                }

                lock (cacheLock)
                {
                    //Check to see if anyone wrote to the cache while we where waiting our turn to write the new value.
                    cachedData = MemoryCache.Default.Get(cacheKey, null) as T;

                    if (cachedData != null)
                    {
                        return cachedData;
                    }

                    //The value still did not exist so we now write it in to the cache.
                    CacheItemPolicy cip = new CacheItemPolicy()
                    {
                        AbsoluteExpiration = new DateTimeOffset(DateTime.Now.AddMinutes(cacheTimePolicyMinutes))
                    };
                    cachedData = GetData();
                    MemoryCache.Default.Set(cacheKey, cachedData, cip);
                    return cachedData;
                }
            }
        }
    }
}

Dies ist meine 2. Iteration des Codes. Da MemoryCacheThread-sicher ist, müssen Sie beim ersten Lesen nicht sperren. Sie können nur lesen. Wenn der Cache null zurückgibt, führen Sie die Sperrprüfung durch, um festzustellen, ob Sie die Zeichenfolge erstellen müssen. Dies vereinfacht den Code erheblich.

const string CacheKey = "CacheKey";
static readonly object cacheLock = new object();
private static string GetCachedData()
{

    //Returns null if the string does not exist, prevents a race condition where the cache invalidates between the contains check and the retreival.
    var cachedString = MemoryCache.Default.Get(CacheKey, null) as string;

    if (cachedString != null)
    {
        return cachedString;
    }

    lock (cacheLock)
    {
        //Check to see if anyone wrote to the cache while we where waiting our turn to write the new value.
        cachedString = MemoryCache.Default.Get(CacheKey, null) as string;

        if (cachedString != null)
        {
            return cachedString;
        }

        //The value still did not exist so we now write it in to the cache.
        var expensiveString = SomeHeavyAndExpensiveCalculation();
        CacheItemPolicy cip = new CacheItemPolicy()
                              {
                                  AbsoluteExpiration = new DateTimeOffset(DateTime.Now.AddMinutes(20))
                              };
        MemoryCache.Default.Set(CacheKey, expensiveString, cip);
        return expensiveString;
    }
}

BEARBEITEN : Der folgende Code ist nicht erforderlich, aber ich wollte ihn belassen, um die ursprüngliche Methode zu zeigen. Dies kann für zukünftige Besucher nützlich sein, die eine andere Sammlung verwenden, die threadsichere Lesevorgänge, aber nicht threadsichere Schreibvorgänge enthält (fast alle Klassen unter dem System.CollectionsNamespace sind so).

Hier ist, wie ich es tun würde ReaderWriterLockSlim, um den Zugriff zu schützen. Sie müssen eine Art " Double Checked Locking " durchführen, um zu sehen, ob jemand anderes das zwischengespeicherte Element erstellt hat, während wir darauf warten, das Schloss zu öffnen.

const string CacheKey = "CacheKey";
static readonly ReaderWriterLockSlim cacheLock = new ReaderWriterLockSlim();
static string GetCachedData()
{
    //First we do a read lock to see if it already exists, this allows multiple readers at the same time.
    cacheLock.EnterReadLock();
    try
    {
        //Returns null if the string does not exist, prevents a race condition where the cache invalidates between the contains check and the retreival.
        var cachedString = MemoryCache.Default.Get(CacheKey, null) as string;

        if (cachedString != null)
        {
            return cachedString;
        }
    }
    finally
    {
        cacheLock.ExitReadLock();
    }

    //Only one UpgradeableReadLock can exist at one time, but it can co-exist with many ReadLocks
    cacheLock.EnterUpgradeableReadLock();
    try
    {
        //We need to check again to see if the string was created while we where waiting to enter the EnterUpgradeableReadLock
        var cachedString = MemoryCache.Default.Get(CacheKey, null) as string;

        if (cachedString != null)
        {
            return cachedString;
        }

        //The entry still does not exist so we need to create it and enter the write lock
        var expensiveString = SomeHeavyAndExpensiveCalculation();
        cacheLock.EnterWriteLock(); //This will block till all the Readers flush.
        try
        {
            CacheItemPolicy cip = new CacheItemPolicy()
            {
                AbsoluteExpiration = new DateTimeOffset(DateTime.Now.AddMinutes(20))
            };
            MemoryCache.Default.Set(CacheKey, expensiveString, cip);
            return expensiveString;
        }
        finally 
        {
            cacheLock.ExitWriteLock();
        }
    }
    finally
    {
        cacheLock.ExitUpgradeableReadLock();
    }
}

Es gibt eine Open-Source-Bibliothek [Haftungsausschluss: den ich geschrieben habe]: LazyCache, dass IMO Ihre Anforderungen mit zwei Codezeilen abdeckt:

IAppCache cache = new CachingService();
var cachedResults = cache.GetOrAdd("CacheKey", 
  () => SomeHeavyAndExpensiveCalculation());

Standardmäßig ist eine Sperre integriert, sodass die zwischenspeicherbare Methode nur einmal pro Cache-Fehler ausgeführt wird. Außerdem wird ein Lambda verwendet, sodass Sie "get or add" auf einmal ausführen können. Der Standardwert beträgt 20 Minuten.

Es gibt sogar ein NuGet-Paket ;)

Ich habe dieses Problem gelöst, indem ich die AddOrGetExisting- Methode im MemoryCache und die Lazy-Initialisierung verwendet habe .

Im Wesentlichen sieht mein Code ungefähr so ​​aus:

static string GetCachedData(string key, DateTimeOffset offset)
{
    Lazy<String> lazyObject = new Lazy<String>(() => SomeHeavyAndExpensiveCalculationThatReturnsAString());
    var returnedLazyObject = MemoryCache.Default.AddOrGetExisting(key, lazyObject, offset); 
    if (returnedLazyObject == null)
       return lazyObject.Value;
    return ((Lazy<String>) returnedLazyObject).Value;
}

Im schlimmsten Fall erstellen Sie dasselbe LazyObjekt zweimal. Das ist aber ziemlich trivial. Die Verwendung von AddOrGetExistinggarantiert, dass Sie immer nur eine Instanz des LazyObjekts erhalten, sodass Sie die teure Initialisierungsmethode garantiert nur einmal aufrufen.

Ich gehe davon aus, dass dieser Code Probleme mit der Parallelität hat:

Eigentlich ist es durchaus in Ordnung, wenn auch mit einer möglichen Verbesserung.

Im Allgemeinen kann das Muster, bei dem mehrere Threads bei der ersten Verwendung einen gemeinsamen Wert festlegen, um den erhaltenen und festgelegten Wert nicht zu sperren, Folgendes sein:

1. Katastrophal - anderer Code setzt voraus, dass nur eine Instanz vorhanden ist.
2. Katastrophal - Der Code, der die Instanz erhält, kann nicht nur eine (oder möglicherweise eine bestimmte kleine Anzahl) gleichzeitige Operationen tolerieren.
3. Katastrophal - Die Speichermethode ist nicht threadsicher (z. B. wenn zwei Threads zu einem Wörterbuch hinzugefügt werden und Sie alle möglichen bösen Fehler erhalten können).
4. Suboptimal - Die Gesamtleistung ist schlechter als wenn das Sperren sichergestellt hätte, dass nur ein Thread die Arbeit zum Erhalten des Werts erledigt hat.
5. Optimal - Die Kosten für redundante Arbeiten mit mehreren Threads sind geringer als die Kosten für deren Verhinderung, zumal dies nur in relativ kurzer Zeit möglich ist.

In MemoryCacheAnbetracht dessen, dass Einträge dann möglicherweise entfernt werden:

1. Wenn es katastrophal ist, mehr als eine Instanz zu haben, MemoryCacheist dies der falsche Ansatz.
2. Wenn Sie die gleichzeitige Erstellung verhindern müssen, sollten Sie dies zum Zeitpunkt der Erstellung tun.
3. MemoryCache ist in Bezug auf den Zugriff auf dieses Objekt threadsicher, sodass dies hier kein Problem darstellt.

Beide Möglichkeiten müssen natürlich in Betracht gezogen werden, obwohl das einzige Mal, wenn zwei Instanzen derselben Zeichenfolge vorhanden sind, ein Problem sein kann, wenn Sie ganz bestimmte Optimierungen vornehmen, die hier nicht zutreffen *.

Wir haben also die Möglichkeit:

1. Es ist billiger, die Kosten für doppelte Anrufe zu vermeiden SomeHeavyAndExpensiveCalculation().
2. Es ist billiger, die Kosten für doppelte Anrufe nicht zu vermeiden SomeHeavyAndExpensiveCalculation().

Und das herauszufinden kann schwierig sein (in der Tat die Art von Dingen, bei denen es sich lohnt, ein Profil zu erstellen, anstatt davon auszugehen, dass Sie es herausfinden können). Es ist jedoch erwägenswert, dass die offensichtlichsten Methoden zum Sperren beim Einfügen alle Ergänzungen zum Cache verhindern, einschließlich solcher, die nichts miteinander zu tun haben.

Das heißt, wenn wir 50 Threads hatten, die versuchten, 50 verschiedene Werte festzulegen, müssen wir alle 50 Threads aufeinander warten lassen, obwohl sie nicht einmal dieselbe Berechnung durchführen würden.

Als solches sind Sie mit dem Code, den Sie haben, wahrscheinlich besser dran als mit Code, der die Rennbedingung vermeidet, und wenn die Rennbedingung ein Problem darstellt, müssen Sie dies wahrscheinlich entweder woanders behandeln oder benötigen eine andere Caching-Strategie als eine, die alte Einträge ausschließt †.

Das einzige, was ich ändern würde, wäre, den Anruf Set()durch einen zu ersetzen AddOrGetExisting(). Aus dem oben Gesagten sollte klar sein, dass dies wahrscheinlich nicht erforderlich ist, aber es würde ermöglichen, das neu erhaltene Objekt zu sammeln, was die Gesamtspeicherauslastung verringert und ein höheres Verhältnis von Sammlungen mit niedriger zu hoher Generation ermöglicht.

Ja, Sie könnten die doppelte Sperre verwenden, um Parallelität zu verhindern, aber entweder ist die Parallelität eigentlich kein Problem, oder Sie speichern die Werte falsch, oder die doppelte Sperre im Geschäft wäre nicht der beste Weg, dies zu lösen .

* Wenn Sie wissen, dass jeweils nur eine Zeichenfolge vorhanden ist, können Sie Gleichheitsvergleiche optimieren. Dies ist ungefähr das einzige Mal, dass zwei Kopien einer Zeichenfolge falsch und nicht nur suboptimal sein können, aber Sie möchten dies tun sehr unterschiedliche Arten des Cachings, damit dies Sinn macht. ZB die Sortierung XmlReaderintern.

† Sehr wahrscheinlich entweder eine, die auf unbestimmte Zeit gespeichert wird, oder eine, die schwache Referenzen verwendet, sodass Einträge nur dann ausgeschlossen werden, wenn keine Verwendungen vorhanden sind.

Um die globale Sperre zu vermeiden, können Sie SingletonCache verwenden, um eine Sperre pro Schlüssel zu implementieren, ohne die Speichernutzung zu explodieren (die Sperrobjekte werden entfernt, wenn nicht mehr darauf verwiesen wird, und das Erfassen / Freigeben ist threadsicher und garantiert, dass nur 1 Instanz jemals über Vergleich verwendet wird und tauschen).

Die Verwendung sieht folgendermaßen aus:

SingletonCache<string, object> keyLocks = new SingletonCache<string, object>();

const string CacheKey = "CacheKey";
static string GetCachedData()
{
    string expensiveString =null;
    if (MemoryCache.Default.Contains(CacheKey))
    {
        return MemoryCache.Default[CacheKey] as string;
    }

    // double checked lock
    using (var lifetime = keyLocks.Acquire(url))
    {
        lock (lifetime.Value)
        {
           if (MemoryCache.Default.Contains(CacheKey))
           {
              return MemoryCache.Default[CacheKey] as string;
           }

           cacheItemPolicy cip = new CacheItemPolicy()
           {
              AbsoluteExpiration = new DateTimeOffset(DateTime.Now.AddMinutes(20))
           };
           expensiveString = SomeHeavyAndExpensiveCalculation();
           MemoryCache.Default.Set(CacheKey, expensiveString, cip);
           return expensiveString;
        }
    }      
}

Code ist hier auf GitHub: https://github.com/bitfaster/BitFaster.Caching

Install-Package BitFaster.Caching

Es gibt auch eine LRU-Implementierung, die leichter als MemoryCache ist und mehrere Vorteile bietet - schnellere gleichzeitige Lese- und Schreibvorgänge, begrenzte Größe, kein Hintergrund-Thread, interne Leistungsindikatoren usw. (Haftungsausschluss, ich habe ihn geschrieben).

Konsolenbeispiel für MemoryCache , "Speichern / Abrufen einfacher Klassenobjekte"

Ausgabe nach dem Starten und Drücken Any keyaußer Esc:

Speichern im Cache!
Aus dem Cache!
Some1
Some2

    class Some
    {
        public String text { get; set; }

        public Some(String text)
        {
            this.text = text;
        }

        public override string ToString()
        {
            return text;
        }
    }

    public static MemoryCache cache = new MemoryCache("cache");

    public static string cache_name = "mycache";

    static void Main(string[] args)
    {

        Some some1 = new Some("some1");
        Some some2 = new Some("some2");

        List<Some> list = new List<Some>();
        list.Add(some1);
        list.Add(some2);

        do {

            if (cache.Contains(cache_name))
            {
                Console.WriteLine("Getting from cache!");
                List<Some> list_c = cache.Get(cache_name) as List<Some>;
                foreach (Some s in list_c) Console.WriteLine(s);
            }
            else
            {
                Console.WriteLine("Saving to cache!");
                cache.Set(cache_name, list, DateTime.Now.AddMinutes(10));                   
            }

        } while (Console.ReadKey(true).Key != ConsoleKey.Escape);

    }

public interface ILazyCacheProvider : IAppCache
{
    /// <summary>
    /// Get data loaded - after allways throw cached result (even when data is older then needed) but very fast!
    /// </summary>
    /// <param name="key"></param>
    /// <param name="getData"></param>
    /// <param name="slidingExpiration"></param>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    T GetOrAddPermanent<T>(string key, Func<T> getData, TimeSpan slidingExpiration);
}

/// <summary>
/// Initialize LazyCache in runtime
/// </summary>
public class LazzyCacheProvider: CachingService, ILazyCacheProvider
{
    private readonly Logger _logger = LogManager.GetLogger("MemCashe");
    private readonly Hashtable _hash = new Hashtable();
    private readonly List<string>  _reloader = new List<string>();
    private readonly ConcurrentDictionary<string, DateTime> _lastLoad = new ConcurrentDictionary<string, DateTime>();  


    T ILazyCacheProvider.GetOrAddPermanent<T>(string dataKey, Func<T> getData, TimeSpan slidingExpiration)
    {
        var currentPrincipal = Thread.CurrentPrincipal;
        if (!ObjectCache.Contains(dataKey) && !_hash.Contains(dataKey))
        {
            _hash[dataKey] = null;
            _logger.Debug($"{dataKey} - first start");
            _lastLoad[dataKey] = DateTime.Now;
            _hash[dataKey] = ((object)GetOrAdd(dataKey, getData, slidingExpiration)).CloneObject();
            _lastLoad[dataKey] = DateTime.Now;
           _logger.Debug($"{dataKey} - first");
        }
        else
        {
            if ((!ObjectCache.Contains(dataKey) || _lastLoad[dataKey].AddMinutes(slidingExpiration.Minutes) < DateTime.Now) && _hash[dataKey] != null)
                Task.Run(() =>
                {
                    if (_reloader.Contains(dataKey)) return;
                    lock (_reloader)
                    {
                        if (ObjectCache.Contains(dataKey))
                        {
                            if(_lastLoad[dataKey].AddMinutes(slidingExpiration.Minutes) > DateTime.Now)
                                return;
                            _lastLoad[dataKey] = DateTime.Now;
                            Remove(dataKey);
                        }
                        _reloader.Add(dataKey);
                        Thread.CurrentPrincipal = currentPrincipal;
                        _logger.Debug($"{dataKey} - reload start");
                        _hash[dataKey] = ((object)GetOrAdd(dataKey, getData, slidingExpiration)).CloneObject();
                        _logger.Debug($"{dataKey} - reload");
                        _reloader.Remove(dataKey);
                    }
                });
        }
        if (_hash[dataKey] != null) return (T) (_hash[dataKey]);

        _logger.Debug($"{dataKey} - dummy start");
        var data = GetOrAdd(dataKey, getData, slidingExpiration);
        _logger.Debug($"{dataKey} - dummy");
        return (T)((object)data).CloneObject();
    }
}

Es ist jedoch etwas spät ... Vollständige Implementierung:

    [HttpGet]
    public async Task<HttpResponseMessage> GetPageFromUriOrBody(RequestQuery requestQuery)
    {
        log(nameof(GetPageFromUriOrBody), nameof(requestQuery));
        var responseResult = await _requestQueryCache.GetOrCreate(
            nameof(GetPageFromUriOrBody)
            , requestQuery
            , (x) => getPageContent(x).Result);
        return Request.CreateResponse(System.Net.HttpStatusCode.Accepted, responseResult);
    }
    static MemoryCacheWithPolicy<RequestQuery, string> _requestQueryCache = new MemoryCacheWithPolicy<RequestQuery, string>();

Hier ist die getPageContentUnterschrift:

async Task<string> getPageContent(RequestQuery requestQuery);

Und hier ist die MemoryCacheWithPolicyImplementierung:

public class MemoryCacheWithPolicy<TParameter, TResult>
{
    static ILogger _nlogger = new AppLogger().Logger;
    private MemoryCache _cache = new MemoryCache(new MemoryCacheOptions() 
    {
        //Size limit amount: this is actually a memory size limit value!
        SizeLimit = 1024 
    });

    /// <summary>
    /// Gets or creates a new memory cache record for a main data
    /// along with parameter data that is assocciated with main main.
    /// </summary>
    /// <param name="key">Main data cache memory key.</param>
    /// <param name="param">Parameter model that assocciated to main model (request result).</param>
    /// <param name="createCacheData">A delegate to create a new main data to cache.</param>
    /// <returns></returns>
    public async Task<TResult> GetOrCreate(object key, TParameter param, Func<TParameter, TResult> createCacheData)
    {
        // this key is used for param cache memory.
        var paramKey = key + nameof(param);

        if (!_cache.TryGetValue(key, out TResult cacheEntry))
        {
            // key is not in the cache, create data through the delegate.
            cacheEntry = createCacheData(param);
            createMemoryCache(key, cacheEntry, paramKey, param);

            _nlogger.Warn(" cache is created.");
        }
        else
        {
            // data is chached so far..., check if param model is same (or changed)?
            if(!_cache.TryGetValue(paramKey, out TParameter cacheParam))
            {
                //exception: this case should not happened!
            }

            if (!cacheParam.Equals(param))
            {
                // request param is changed, create data through the delegate.
                cacheEntry = createCacheData(param);
                createMemoryCache(key, cacheEntry, paramKey, param);
                _nlogger.Warn(" cache is re-created (param model has been changed).");
            }
            else
            {
                _nlogger.Trace(" cache is used.");
            }

        }
        return await Task.FromResult<TResult>(cacheEntry);
    }
    MemoryCacheEntryOptions createMemoryCacheEntryOptions(TimeSpan slidingOffset, TimeSpan relativeOffset)
    {
        // Cache data within [slidingOffset] seconds, 
        // request new result after [relativeOffset] seconds.
        return new MemoryCacheEntryOptions()

            // Size amount: this is actually an entry count per 
            // key limit value! not an actual memory size value!
            .SetSize(1)

            // Priority on removing when reaching size limit (memory pressure)
            .SetPriority(CacheItemPriority.High)

            // Keep in cache for this amount of time, reset it if accessed.
            .SetSlidingExpiration(slidingOffset)

            // Remove from cache after this time, regardless of sliding expiration
            .SetAbsoluteExpiration(relativeOffset);
        //
    }
    void createMemoryCache(object key, TResult cacheEntry, object paramKey, TParameter param)
    {
        // Cache data within 2 seconds, 
        // request new result after 5 seconds.
        var cacheEntryOptions = createMemoryCacheEntryOptions(
            TimeSpan.FromSeconds(2)
            , TimeSpan.FromSeconds(5));

        // Save data in cache.
        _cache.Set(key, cacheEntry, cacheEntryOptions);

        // Save param in cache.
        _cache.Set(paramKey, param, cacheEntryOptions);
    }
    void checkCacheEntry<T>(object key, string name)
    {
        _cache.TryGetValue(key, out T value);
        _nlogger.Fatal("Key: {0}, Name: {1}, Value: {2}", key, name, value);
    }
}

nloggerist nur ein nLogObjekt, um das MemoryCacheWithPolicyVerhalten zu verfolgen . Ich erstelle den Speichercache neu, wenn das Anforderungsobjekt ( RequestQuery requestQuery) durch den Delegaten ( Func<TParameter, TResult> createCacheData) geändert wird, oder erstelle es neu, wenn die gleitende oder absolute Zeit ihr Limit erreicht hat. Beachten Sie, dass auch alles asynchron ist;)

Es ist schwierig zu entscheiden, welches besser ist; lock oder ReaderWriterLockSlim. Sie benötigen reale Statistiken über Lese- und Schreibzahlen und -verhältnisse usw.

Aber wenn Sie glauben, dass die Verwendung von "Schloss" der richtige Weg ist. Dann ist hier eine andere Lösung für unterschiedliche Bedürfnisse. Ich füge auch die Allan Xu-Lösung in den Code ein. Weil beide für unterschiedliche Bedürfnisse benötigt werden können.

Hier sind die Anforderungen, die mich zu dieser Lösung führen:

1. Sie möchten oder können die Funktion 'GetData' aus irgendeinem Grund nicht bereitstellen. Möglicherweise befindet sich die Funktion 'GetData' in einer anderen Klasse mit einem schweren Konstruktor, und Sie möchten erst dann eine Instanz erstellen, wenn sichergestellt ist, dass sie nicht mehr verfügbar ist.
2. Sie müssen von verschiedenen Speicherorten / Ebenen der Anwendung auf dieselben zwischengespeicherten Daten zugreifen. Und diese verschiedenen Standorte haben keinen Zugriff auf dasselbe Schließfachobjekt.
3. Sie haben keinen konstanten Cache-Schlüssel. Beispielsweise; Einige Daten müssen mit dem sessionId-Cache-Schlüssel zwischengespeichert werden.

Code:

using System;
using System.Runtime.Caching;
using System.Collections.Concurrent;
using System.Collections.Generic;

namespace CachePoc
{
    class Program
    {
        static object everoneUseThisLockObject4CacheXYZ = new object();
        const string CacheXYZ = "CacheXYZ";
        static object everoneUseThisLockObject4CacheABC = new object();
        const string CacheABC = "CacheABC";

        static void Main(string[] args)
        {
            //Allan Xu's usage
            string xyzData = MemoryCacheHelper.GetCachedDataOrAdd<string>(CacheXYZ, everoneUseThisLockObject4CacheXYZ, 20, SomeHeavyAndExpensiveXYZCalculation);
            string abcData = MemoryCacheHelper.GetCachedDataOrAdd<string>(CacheABC, everoneUseThisLockObject4CacheXYZ, 20, SomeHeavyAndExpensiveXYZCalculation);

            //My usage
            string sessionId = System.Web.HttpContext.Current.Session["CurrentUser.SessionId"].ToString();
            string yvz = MemoryCacheHelper.GetCachedData<string>(sessionId);
            if (string.IsNullOrWhiteSpace(yvz))
            {
                object locker = MemoryCacheHelper.GetLocker(sessionId);
                lock (locker)
                {
                    yvz = MemoryCacheHelper.GetCachedData<string>(sessionId);
                    if (string.IsNullOrWhiteSpace(yvz))
                    {
                        DatabaseRepositoryWithHeavyConstructorOverHead dbRepo = new DatabaseRepositoryWithHeavyConstructorOverHead();
                        yvz = dbRepo.GetDataExpensiveDataForSession(sessionId);
                        MemoryCacheHelper.AddDataToCache(sessionId, yvz, 5);
                    }
                }
            }
        }


        private static string SomeHeavyAndExpensiveXYZCalculation() { return "Expensive"; }
        private static string SomeHeavyAndExpensiveABCCalculation() { return "Expensive"; }

        public static class MemoryCacheHelper
        {
            //Allan Xu's solution
            public static T GetCachedDataOrAdd<T>(string cacheKey, object cacheLock, int minutesToExpire, Func<T> GetData) where T : class
            {
                //Returns null if the string does not exist, prevents a race condition where the cache invalidates between the contains check and the retreival.
                T cachedData = MemoryCache.Default.Get(cacheKey, null) as T;

                if (cachedData != null)
                    return cachedData;

                lock (cacheLock)
                {
                    //Check to see if anyone wrote to the cache while we where waiting our turn to write the new value.
                    cachedData = MemoryCache.Default.Get(cacheKey, null) as T;

                    if (cachedData != null)
                        return cachedData;

                    cachedData = GetData();
                    MemoryCache.Default.Set(cacheKey, cachedData, DateTime.Now.AddMinutes(minutesToExpire));
                    return cachedData;
                }
            }

            #region "My Solution"

            readonly static ConcurrentDictionary<string, object> Lockers = new ConcurrentDictionary<string, object>();
            public static object GetLocker(string cacheKey)
            {
                CleanupLockers();

                return Lockers.GetOrAdd(cacheKey, item => (cacheKey, new object()));
            }

            public static T GetCachedData<T>(string cacheKey) where T : class
            {
                CleanupLockers();

                T cachedData = MemoryCache.Default.Get(cacheKey) as T;
                return cachedData;
            }

            public static void AddDataToCache(string cacheKey, object value, int cacheTimePolicyMinutes)
            {
                CleanupLockers();

                MemoryCache.Default.Add(cacheKey, value, DateTimeOffset.Now.AddMinutes(cacheTimePolicyMinutes));
            }

            static DateTimeOffset lastCleanUpTime = DateTimeOffset.MinValue;
            static void CleanupLockers()
            {
                if (DateTimeOffset.Now.Subtract(lastCleanUpTime).TotalMinutes > 1)
                {
                    lock (Lockers)//maybe a better locker is needed?
                    {
                        try//bypass exceptions
                        {
                            List<string> lockersToRemove = new List<string>();
                            foreach (var locker in Lockers)
                            {
                                if (!MemoryCache.Default.Contains(locker.Key))
                                    lockersToRemove.Add(locker.Key);
                            }

                            object dummy;
                            foreach (string lockerKey in lockersToRemove)
                                Lockers.TryRemove(lockerKey, out dummy);

                            lastCleanUpTime = DateTimeOffset.Now;
                        }
                        catch (Exception)
                        { }
                    }
                }

            }
            #endregion
        }
    }

    class DatabaseRepositoryWithHeavyConstructorOverHead
    {
        internal string GetDataExpensiveDataForSession(string sessionId)
        {
            return "Expensive data from database";
        }
    }

}