public CacheOptions(
CacheExpirationType expirationType = CacheExpirationType.Sliding,
int timeoutMinutes = 14
)
{
ExpirationType = expirationType;
TimeoutMinutes = timeoutMinutes;
}
public static IFileCacheCleaner GetCleaner(CacheExpirationType expirationType, IFileSystem fileSystem)
{
switch (expirationType)
{
case CacheExpirationType.LeastRecentlyUsed:
default:
return new LRUFileCacheCleaner(fileSystem);
}
}
public static IFileCacheCleaner GetCleaner(CacheExpirationType expirationType, IFileSystem fileSystem)
{
switch (expirationType)
{
case CacheExpirationType.LeastRecentlyUsed:
default:
return(new LRUFileCacheCleaner(fileSystem));
}
}
public Scenario(IDistributedCache distributedCache, CacheExpirationType cacheExpirationType, HttpClient httpClient, DeliveryOptions deliveryOptions, Dictionary <string, int> requestCounter)
{
_requestCounter = requestCounter;
_cacheManager = new DistributedCacheManager(distributedCache, Options.Create(new DeliveryCacheOptions {
DefaultExpirationType = cacheExpirationType
}));
var baseClient = DeliveryClientBuilder.WithOptions(_ => deliveryOptions).WithDeliveryHttpClient(new DeliveryHttpClient(httpClient)).Build();
CachingClient = new DeliveryClientCache(_cacheManager, baseClient);
}
/// <summary>
/// Add cache item
/// </summary>
/// <param name="key">Cache item key</param>
/// <param name="expirationType"><see cref="CacheExpirationType"/> instance</param>
/// <param name="expiration">Expiratation <see cref="TimeSpan"/></param>
/// <param name="keepValueOnRetrieveFail">Specifies if value should be retained if cache retrieval fails</param>
/// <param name="retrieveFunction">Function used to retrieve cache value</param>
public void AddItem(string key,
CacheExpirationType expirationType,
TimeSpan expiration,
bool keepValueOnRetrieveFail,
Func <object> retrieveFunction)
{
InitCacheItem(key, new CacheStore
{
CacheExpirationType = expirationType,
Expiration = expiration,
KeepValueOnRetrieveFail = keepValueOnRetrieveFail,
RetrieveFunction = retrieveFunction,
CacheValue = new Lazy <object>(() => retrieveFunction())
});
}
/// <summary>
/// Добавляет объект в глобальный кэш приложений с заданными параметрами кэширования.
/// Если объект по такому имени уже существует, то он будет переписан новым значением.
/// </summary>
/// <param name="key">Имя добавляемого объекта в кэше</param>
/// <param name="value">Значение добавляемого объекта в кэше</param>
/// <param name="expirationType">Тип хранения объекта в кэше</param>
/// <param name="expirationTime">Время хранения объекта в кэше</param>
public static void InsertExpirationData(string key, object value, CacheExpirationType expirationType, TimeSpan expirationTime)
{
if (DataCache.IsCacheEnable)
{
if (expirationType == CacheExpirationType.AbsoluteExpiration)
{
HttpRuntime.Cache.Insert(key, value, null, DateTime.UtcNow.Add(expirationTime), Cache.NoSlidingExpiration);
}
else if (expirationType == CacheExpirationType.SlidingExpiration)
{
HttpRuntime.Cache.Insert(key, value, null, Cache.NoAbsoluteExpiration, expirationTime);
}
else
{
HttpRuntime.Cache.Insert(key, value);
}
}
}
public static void Insert(string key, object value, TimeSpan cacheDuration, CacheExpirationType ExType, System.Web.Caching.CacheItemPriority priority, System.Web.Caching.CacheItemRemovedCallback callback)
{
if (!EnableCaching)
{
context.Trace.Warn("Caching is disabled.");
}
else
{
context = System.Web.HttpContext.Current;
switch (ExType)
{
case CacheExpirationType.Absolute:
context.Cache.Insert(key, value, null, DateTime.Now.Add(cacheDuration), System.Web.Caching.Cache.NoSlidingExpiration, priority, callback);
break;
case CacheExpirationType.Sliding:
context.Cache.Insert(key, value, null, System.Web.Caching.Cache.NoAbsoluteExpiration, cacheDuration, priority, callback);
break;
}
context.Trace.Write(key + " cached for a duration of " + cacheDuration + ".");
}
}
public async Task GetItemTypedAsync_InvalidatedByLinkedItemDependency(CacheExpirationType cacheExpirationType)
{
const string codename = "codename";
var url = $"items/{codename}";
const string modularCodename = "modular_codename";
var modularContent = new[] { (modularCodename, CreateItem(modularCodename)) };
public async Task GetItemTypedAsync_InvalidatedByItemKey(CacheTypeEnum cacheType, CacheExpirationType cacheExpirationType)
{
const string codename = "codename";
var url = $"items/{codename}";
var item = CreateItemResponse(CreateItem(codename, "original"));
var updatedItem = CreateItemResponse(CreateItem(codename, "updated"));
var scenarioBuilder = new ScenarioBuilder(cacheType, cacheExpirationType);
var scenario = scenarioBuilder.WithResponse(url, item).Build();
var firstResponse = await scenario.CachingClient.GetItemAsync <TestItem>(codename);
scenario = scenarioBuilder.WithResponse(url, updatedItem).Build();
scenario.InvalidateDependency(CacheHelpers.GetItemKey <TestItem>(codename, Enumerable.Empty <IQueryParameter>()));
var secondResponse = await scenario.CachingClient.GetItemAsync <TestItem>(codename);
firstResponse.Should().NotBeNull();
secondResponse.Should().NotBeNull();
firstResponse.Should().NotBeEquivalentTo(secondResponse);
scenario.GetRequestCount(url).Should().Be(2);
}
public async Task GetItemTypedAsync_ResponseIsCached(CacheTypeEnum cacheType, CacheExpirationType cacheExpirationType)
{
const string codename = "codename";
var url = $"items/{codename}";
var item = CreateItemResponse(CreateItem(codename, "original"));
var updatedItem = CreateItemResponse(CreateItem(codename, "updated"));
var scenarioBuilder = new ScenarioBuilder(cacheType, cacheExpirationType);
var scenario = scenarioBuilder.WithResponse(url, item).Build();
var firstResponse = await scenario.CachingClient.GetItemAsync <TestItem>(codename);
scenario = scenarioBuilder.WithResponse(url, updatedItem).Build();
var secondResponse = await scenario.CachingClient.GetItemAsync <TestItem>(codename);
firstResponse.Should().NotBeNull();
firstResponse.Should().BeEquivalentTo(secondResponse);
scenario.GetRequestCount(url).Should().Be(1);
}
public static void Insert(string key, object value, CacheExpirationType ExType, System.Web.Caching.CacheItemPriority priority, System.Web.Caching.CacheItemRemovedCallback callback)
{
Insert(key, value, GetCacheDuration(key), ExType, priority, callback);
}
/// <summary>
/// Статический конструктор инициализирует начальные значения свойств класса
/// </summary>
static DataCache()
{
DataCache.IsCacheEnable = true;
DataCache.ExpirationType = CacheExpirationType.SlidingExpiration;
DataCache.ExpirationTime = TimeSpan.FromMinutes(20);
}
