Mise en cache dans une application de console

Le garder en tant que membre de l'instance de la classe conteneur. En web app, vous ne pouvez pas le faire depuis la page de la classe de l'objet est recréé à chaque requête.

Cependant .NET 4.0 a également MemoryCache classe pour ce but.

Ici est très simple cache classe j'utilise une console qui a les nettoyer et facile de mise en œuvre.

L'Utilisation:

return Cache.Get("MyCacheKey", 30, () => { return new Model.Guide().ChannelListings.BuildChannelList(); });

La Classe:

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Timers;
namespace MyAppNamespace
{
public static class Cache
{
private static Timer cleanupTimer = new Timer() { AutoReset = true, Enabled = true, Interval = 60000 };
private static readonly Dictionary<string, CacheItem> internalCache = new Dictionary<string, CacheItem>();
static Cache()
{
cleanupTimer.Elapsed += Clean;
cleanupTimer.Start();
}
private static void Clean(object sender, ElapsedEventArgs e)
{
internalCache.Keys.ToList().ForEach(x => { try { if (internalCache[x].ExpireTime <= e.SignalTime) { Remove(x); } } catch (Exception) { /*swallow it*/ } });
}
public static T Get<T>(string key, int expiresMinutes, Func<T> refreshFunction)
{
if (internalCache.ContainsKey(key) && internalCache[key].ExpireTime > DateTime.Now)
{
return (T)internalCache[key].Item;
}
var result = refreshFunction();
Set(key, result, expiresMinutes);
return result;
}
public static void Set(string key, object item, int expiresMinutes)
{
Remove(key);
internalCache.Add(key, new CacheItem(item, expiresMinutes));
}
public static void Remove(string key)
{
if (internalCache.ContainsKey(key))
{
internalCache.Remove(key);
}
}
private struct CacheItem
{
public CacheItem(object item, int expiresMinutes)
: this()
{
Item = item;
ExpireTime = DateTime.Now.AddMinutes(expiresMinutes);
}
public object Item { get; private set; }
public DateTime ExpireTime { get; private set; }
}
}
}

Il y a de nombreuses façons de mettre en œuvre des caches, en fonction de ce qu'est exactement vous êtes en train de faire. Habituellement, vous serez à l'aide d'un dictionnaire pour contenir les valeurs en cache. Voici mon simple mise en œuvre d'un cache, qui met en mémoire cache les valeurs pour un temps limité:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CySoft.Collections
{
public class Cache<TKey,TValue>
{
private readonly Dictionary<TKey, CacheItem> _cache = new Dictionary<TKey, CacheItem>();
private TimeSpan _maxCachingTime;
///<summary>
///Creates a cache which holds the cached values for an infinite time.
///</summary>
public Cache()
: this(TimeSpan.MaxValue)
{
}
///<summary>
///Creates a cache which holds the cached values for a limited time only.
///</summary>
///<param name="maxCachingTime">Maximum time for which the a value is to be hold in the cache.</param>
public Cache(TimeSpan maxCachingTime)
{
_maxCachingTime = maxCachingTime;
}
///<summary>
///Tries to get a value from the cache. If the cache contains the value and the maximum caching time is
///not exceeded (if any is defined), then the cached value is returned, else a new value is created.
///</summary>
///<param name="key">Key of the value to get.</param>
///<param name="createValue">Function creating a new value.</param>
///<returns>A cached or a new value.</returns>
public TValue Get(TKey key, Func<TValue> createValue)
{
CacheItem cacheItem;
if (_cache.TryGetValue(key, out cacheItem) && (DateTime.Now - cacheItem.CacheTime) <= _maxCachingTime) {
return cacheItem.Item;
}
TValue value = createValue();
_cache[key] = new CacheItem(value);
return value;
}
private struct CacheItem
{
public CacheItem(TValue item)
: this()
{
Item = item;
CacheTime = DateTime.Now;
}
public TValue Item { get; private set; }
public DateTime CacheTime { get; private set; }
}
}
}

Vous pouvez passer d'une expression lambda à la méthode Get, qui récupère les valeurs à partir d'une base par exemple.

Vous pourriez être en mesure de simplement utiliser un simple Dictionnaire. La chose qui rend le Cache de si spécial dans l'environnement web, c'est qu'il persiste et est définie de telle manière que de nombreux utilisateurs peuvent y accéder. Dans une application console, vous n'avez pas ces problèmes. Si vos besoins sont assez simples, le dictionnaire ou de structures similaires, peut être utilisé pour rapidement valeurs de recherche vous sortez d'une base de données.