Comment traiter avec les coûteuses opérations de renforcement à l'aide de MemoryCache?

Pour le conditionnel ajouter exigence, j'ai toujours utiliser ConcurrentDictionary, qui a une surcharge GetOrAdd méthode qui accepte un délégué à feu si l'objet doit être construit.

ConcurrentDictionary<string, object> _cache = new
  ConcurrenctDictionary<string, object>();

public void GetOrAdd(string key)
{
  return _cache.GetOrAdd(key, (k) => {
    //here 'k' is actually the same as 'key'
    return buildDataUsingGoodAmountOfResources();
  });
}

En réalité, j'ai presque toujours utiliser static simultanées dictionnaires. J'ai utilisé "normal" dictionnaires protégé par un ReaderWriterLockSlim exemple, mais dès que je suis passé à .Net 4 (il est uniquement disponible à partir de ce partir) j'ai commencé la conversion de l'un de ceux que j'ai croisé.

ConcurrentDictionary's de performance est admirable pour dire le moins 🙂

Mise à jour Naïf de mise en œuvre de l'expiration de la sémantique fondée sur l'âge uniquement. Doivent également veiller à ce que les éléments individuels sont créés uniquement pour une fois - comme par @usr suggestion. Mise à jour - comme @usr a suggéré simplement à l'aide d'un Lazy<T> serait beaucoup plus simple - vous pouvez juste avant la création de délégué pour que lors de l'ajout à la concurrente de dictionnaire. Je be changé le code, comme le fait mon dictionnaire de serrures n'aurait pas marché de toute façon. Mais faut vraiment que j'y ai pensé moi-même (minuit passé ici, dans le royaume-UNI et si je suis battu. Toute la sympathie? Sans évidemment pas. Étant développeur, j'ai assez de caféine qui coule dans mes veines à réveiller les morts).

Je ne le recommande la mise en œuvre de la IRegisteredObject interface avec cela, cependant, puis l'enregistrer avec le HostingEnvironment.RegisterObject méthode - faire, qui constituerait un moyen le plus propre pour arrêter le poller fil lorsque le pool d'applications s'éteint/recycle.

public class ConcurrentCache : IDisposable
{
private readonly ConcurrentDictionary<string, Tuple<DateTime?, Lazy<object>>> _cache = 
new ConcurrentDictionary<string, Tuple<DateTime?, Lazy<object>>>();
private readonly Thread ExpireThread = new Thread(ExpireMonitor);
public ConcurrentCache(){
ExpireThread.Start();
}
public void Dispose()
{
//yeah, nasty, but this is a 'naive' implementation :)
ExpireThread.Abort();
}
public void ExpireMonitor()
{
while(true)
{
Thread.Sleep(1000);
DateTime expireTime = DateTime.Now;
var toExpire = _cache.Where(kvp => kvp.First != null &&
kvp.Item1.Value < expireTime).Select(kvp => kvp.Key).ToArray();
Tuple<string, Lazy<object>> removed;
object removedLock;
foreach(var key in toExpire)
{
_cache.TryRemove(key, out removed);
}
}
}
public object CacheOrAdd(string key, Func<string, object> factory, 
TimeSpan? expiry)
{
return _cache.GetOrAdd(key, (k) => { 
//get or create a new object instance to use 
//as the lock for the user code
//here 'k' is actually the same as 'key' 
return Tuple.Create(
expiry.HasValue ? DateTime.Now + expiry.Value : (DateTime?)null,
new Lazy<object>(() => factory(k)));
}).Item2.Value; 
}
}

Prenant la tête de réponse en C# 7, voici mon application qui permet le stockage de tout type de source de T à tout type de retour TResult.

///<summary>
///Creates a GetOrRefreshCache function with encapsulated MemoryCache.
///</summary>
///<typeparam name="T">The type of inbound objects to cache.</typeparam>
///<typeparam name="TResult">How the objects will be serialized to cache and returned.</typeparam>
///<param name="cacheName">The name of the cache.</param>
///<param name="valueFactory">The factory for storing values.</param>
///<param name="keyFactory">An optional factory to choose cache keys.</param>
///<returns>A function to get or refresh from cache.</returns>
public static Func<T, TResult> GetOrRefreshCacheFactory<T, TResult>(string cacheName, Func<T, TResult> valueFactory, Func<T, string> keyFactory = null) {
var getKey = keyFactory ?? (obj => obj.GetHashCode().ToString());
var cache = new MemoryCache(cacheName);
//Thread-safe lazy cache
TResult getOrRefreshCache(T obj) {
var key = getKey(obj);
var newValue = new Lazy<TResult>(() => valueFactory(obj));
var value = (Lazy<TResult>) cache.AddOrGetExisting(key, newValue, ObjectCache.InfiniteAbsoluteExpiration);
return (value ?? newValue).Value;
}
return getOrRefreshCache;
}

D'utilisation

///<summary>
///Get a JSON object from cache or serialize it if it doesn't exist yet.
///</summary>
private static readonly Func<object, string> GetJson =
GetOrRefreshCacheFactory<object, string>("json-cache", JsonConvert.SerializeObject);
var json = GetJson(new { foo = "bar", yes = true });

Ici est la solution la plus simple que MemoryCache méthode d'extension.

 public static class MemoryCacheExtensions
{
public static T LazyAddOrGetExitingItem<T>(this MemoryCache memoryCache, string key, Func<T> getItemFunc, DateTimeOffset absoluteExpiration)
{
var item = new Lazy<T>(
() => getItemFunc(),
LazyThreadSafetyMode.PublicationOnly //Do not cache lazy exceptions
);
var cachedValue = memoryCache.AddOrGetExisting(key, item, absoluteExpiration) as Lazy<T>;
return (cachedValue != null) ? cachedValue.Value : item.Value;
}
}

Et de test pour elle comme une description de l'utilisation.

[TestMethod]
[TestCategory("MemoryCacheExtensionsTests"), TestCategory("UnitTests")]
public void MemoryCacheExtensions_LazyAddOrGetExitingItem_Test()
{
const int expectedValue = 42;
const int cacheRecordLifetimeInSeconds = 42;
var key = "lazyMemoryCacheKey";
var absoluteExpiration = DateTimeOffset.Now.AddSeconds(cacheRecordLifetimeInSeconds);
var lazyMemoryCache = MemoryCache.Default;
#region Cache warm up
var actualValue = lazyMemoryCache.LazyAddOrGetExitingItem(key, () => expectedValue, absoluteExpiration);
Assert.AreEqual(expectedValue, actualValue);
#endregion
#region Get value from cache
actualValue = lazyMemoryCache.LazyAddOrGetExitingItem(key, () => expectedValue, absoluteExpiration);
Assert.AreEqual(expectedValue, actualValue);
#endregion
}