public void CacheExpirationWithPerformanceCountersEnabledDoesUpdateCounters()
{
ICachingInstrumentationProvider provider
= new CachingInstrumentationProvider(instanceName, true, false, formatter);
provider.FireCacheExpired(10);
Assert.AreEqual(10L, cacheExpiriesCounter.RawValue);
}
/// <summary>
/// Get the object from the cache for the key.
/// </summary>
/// <param name="key">
/// The key whose value to get.
/// </param>
/// <returns>
/// The value associated with the specified key.
/// </returns>
public object GetData(string key)
{
ValidateKey(key);
CacheItem cacheItemBeforeLock = null;
bool lockWasSuccessful = false;
do
{
lock (inMemoryCache.SyncRoot)
{
cacheItemBeforeLock = (CacheItem)inMemoryCache[key];
if (IsObjectInCache(cacheItemBeforeLock))
{
instrumentationProvider.FireCacheAccessed(key, false);
return(null);
}
lockWasSuccessful = Monitor.TryEnter(cacheItemBeforeLock);
}
if (lockWasSuccessful == false)
{
Thread.Sleep(0);
}
} while (lockWasSuccessful == false);
try
{
if (cacheItemBeforeLock.HasExpired())
{
cacheItemBeforeLock.TouchedByUserAction(true);
backingStore.Remove(key); // Does exception safety matter here? We're removing it due to expiration or scavenging...
inMemoryCache.Remove(key);
RefreshActionInvoker.InvokeRefreshAction(cacheItemBeforeLock, CacheItemRemovedReason.Expired, instrumentationProvider);
instrumentationProvider.FireCacheAccessed(key, false);
instrumentationProvider.FireCacheUpdated(1, inMemoryCache.Count);
instrumentationProvider.FireCacheExpired(1);
return(null);
}
backingStore.UpdateLastAccessedTime(cacheItemBeforeLock.Key, DateTime.Now); // Does exception safety matter here?
cacheItemBeforeLock.TouchedByUserAction(false);
instrumentationProvider.FireCacheAccessed(key, true);
return(cacheItemBeforeLock.Value);
}
finally
{
Monitor.Exit(cacheItemBeforeLock);
}
}
public void MultipleCacheExpirationsWithPerformanceCountersEnabledDoesUpdateCounters()
{
ICachingInstrumentationProvider provider
= new CachingInstrumentationProvider(instanceName, true, false, formatter);
for (int i = 1; i <= 10; i++)
{
provider.FireCacheExpired(10);
}
Assert.AreEqual(100L, cacheExpiriesCounter.RawValue);
}
/// <summary>
/// Perform the cacheItemExpirations.
/// </summary>
public void DoExpirations()
{
Hashtable liveCacheRepresentation = cacheOperations.CurrentCacheState;
MarkAsExpired(liveCacheRepresentation);
PrepareForSweep();
int expiredItemsCount = SweepExpiredItemsFromCache(liveCacheRepresentation);
if (expiredItemsCount > 0)
{
instrumentationProvider.FireCacheExpired(expiredItemsCount);
}
}
public void MultipleCacheExpirationsWithPerformanceCountersEnabledDoesUpdateCounters()
{
ICachingInstrumentationProvider provider
= new CachingInstrumentationProvider(instanceName, true, false, formatter);
for (int i = 1; i <= 10; i++)
{
provider.FireCacheExpired(10);
}
Assert.AreEqual(100L, cacheExpiriesCounter.RawValue);
}
public void CacheExpirationWithPerformanceCountersEnabledDoesUpdateCounters()
{
ICachingInstrumentationProvider provider
= new CachingInstrumentationProvider(instanceName, true, false, formatter);
provider.FireCacheExpired(10);
Assert.AreEqual(10L, cacheExpiriesCounter.RawValue);
}