/// <summary>
/// Invokes the refresh action on a thread pool thread
/// </summary>
/// <param name="removedCacheItem">Cache item being removed. Must never be null.</param>
/// <param name="removalReason">The reason the item was removed.</param>
/// <param name="instrumentationProvider">The instrumentation provider.</param>
public static void InvokeRefreshAction(CacheItem removedCacheItem, CacheItemRemovedReason removalReason, CachingInstrumentationProvider instrumentationProvider)
{
if (removedCacheItem.RefreshAction == null)
{
return;
}
try
{
RefreshActionData refreshActionData =
new RefreshActionData(removedCacheItem.RefreshAction, removedCacheItem.Key, removedCacheItem.Value, removalReason, instrumentationProvider);
refreshActionData.InvokeOnThreadPoolThread();
}
catch (Exception e)
{
instrumentationProvider.FireCacheFailed(Resources.FailureToSpawnUserSpecifiedRefreshAction, e);
}
}
private void RemoveItemFromCache(CacheItem itemToRemove)
{
lock (itemToRemove)
{
if (itemToRemove.WillBeExpired)
{
try
{
cacheOperations.RemoveItemFromCache(itemToRemove.Key, CacheItemRemovedReason.Expired);
}
catch (Exception e)
{
CachingServiceInternalFailureEvent.Fire(SR.FailureToRemoveCacheItemInBackground, e);
}
catch
{
CachingServiceInternalFailureEvent.Fire(SR.FailureToRemoveCacheItemInBackground, new Exception(SR.UnknownFailureReason));
}
}
}
}
/// <summary>
/// Invokes the refresh action on a thread pool thread
/// </summary>
/// <param name="removedCacheItem">Cache item being removed. Must never be null.</param>
/// <param name="removalReason">The reason the item was removed.</param>
public static void InvokeRefreshAction(CacheItem removedCacheItem, CacheItemRemovedReason removalReason)
{
if (removedCacheItem.RefreshAction == null)
{
return;
}
try
{
RefreshActionData refreshActionData =
new RefreshActionData(removedCacheItem.RefreshAction, removedCacheItem.Key, removedCacheItem.Value, removalReason);
refreshActionData.InvokeOnThreadPoolThread();
}
catch (Exception e)
{
CachingServiceInternalFailureEvent.Fire(SR.FailureToSpawnUserSpecifiedRefreshAction, e);
}
catch
{
CachingServiceInternalFailureEvent.Fire(SR.FailureToSpawnUserSpecifiedRefreshAction, new Exception(SR.UnknownFailureReason));
}
}
private bool RemoveItemFromCache(CacheItem itemToRemove)
{
lock (itemToRemove)
{
if (itemToRemove.EligibleForScavenging)
{
try
{
cacheOperations.RemoveItemFromCache(itemToRemove.Key, CacheItemRemovedReason.Scavenged);
return true;
}
catch (Exception e)
{
CachingServiceInternalFailureEvent.Fire(SR.FailureToRemoveCacheItemInBackground, e);
}
catch
{
CachingServiceInternalFailureEvent.Fire(SR.FailureToRemoveCacheItemInBackground, new Exception(SR.UnknownFailureReason));
}
}
}
return false;
}
private bool RemoveItemFromCache(CacheItem itemToRemove)
{
bool expired = false;
lock (itemToRemove)
{
if (itemToRemove.WillBeExpired)
{
try
{
expired = true;
cacheOperations.RemoveItemFromCache(itemToRemove.Key, CacheItemRemovedReason.Expired);
}
catch (Exception e)
{
instrumentationProvider.FireCacheFailed(Resources.FailureToRemoveCacheItemInBackground, e);
}
}
}
return expired;
}
private static bool IsObjectInCache(CacheItem cacheItemBeforeLock)
{
return cacheItemBeforeLock == null || Object.ReferenceEquals(cacheItemBeforeLock.Value, addInProgressFlag);
}
/// <summary>
/// Add a new keyed object to the cache.
/// </summary>
/// <param name="key">The key of the object.</param>
/// <param name="value">The object to add.</param>
/// <param name="scavengingPriority">One of the <see cref="CacheItemPriority"/> values.</param>
/// <param name="refreshAction">An <see cref="ICacheItemRefreshAction"/> object.</param>
/// <param name="expirations">An array of <see cref="ICacheItemExpiration"/> objects.</param>
public void Add(string key, object value, CacheItemPriority scavengingPriority, ICacheItemRefreshAction refreshAction, params ICacheItemExpiration[] expirations)
{
ValidateKey(key);
CacheItem cacheItemBeforeLock = null;
bool lockWasSuccessful = false;
do
{
lock (inMemoryCache.SyncRoot)
{
if (inMemoryCache.Contains(key) == false)
{
cacheItemBeforeLock = new CacheItem(key, addInProgressFlag, CacheItemPriority.NotRemovable, null);
inMemoryCache[key] = cacheItemBeforeLock;
}
else
{
cacheItemBeforeLock = (CacheItem)inMemoryCache[key];
}
lockWasSuccessful = Monitor.TryEnter(cacheItemBeforeLock);
}
if (lockWasSuccessful == false)
{
Thread.Sleep(0);
}
} while (lockWasSuccessful == false);
try
{
cacheItemBeforeLock.TouchedByUserAction(true);
CacheItem newCacheItem = new CacheItem(key, value, scavengingPriority, refreshAction, expirations);
try
{
backingStore.Add(newCacheItem);
cacheItemBeforeLock.Replace(value, refreshAction, scavengingPriority, expirations);
inMemoryCache[key] = cacheItemBeforeLock;
}
catch
{
backingStore.Remove(key);
inMemoryCache.Remove(key);
throw;
}
instrumentationProvider.FireCacheUpdated(1, inMemoryCache.Count);
}
finally
{
Monitor.Exit(cacheItemBeforeLock);
}
}
public void Add(string key, object value, CacheItemPriority scavengingPriority, ICacheItemRefreshAction refreshAction, params ICacheItemExpiration[] expirations)
{
ValidateKey(key);
EnsureCacheInitialized();
CacheItem cacheItemBeforeLock = null;
bool lockWasSuccessful = false;
do
{
lock (inMemoryCache.SyncRoot)
{
if (inMemoryCache.Contains(key) == false)
{
cacheItemBeforeLock = new CacheItem(key, addInProgressFlag, CacheItemPriority.NotRemovable, null);
inMemoryCache[key] = cacheItemBeforeLock;
}
else
{
cacheItemBeforeLock = (CacheItem)inMemoryCache[key];
}
lockWasSuccessful = Monitor.TryEnter(cacheItemBeforeLock);
}
if (lockWasSuccessful == false)
{
Thread.Sleep(0);
}
} while (lockWasSuccessful == false);
try
{
cacheItemBeforeLock.TouchedByUserAction(true);
CacheItem newCacheItem = new CacheItem(key, value, scavengingPriority, refreshAction, expirations);
try
{
backingStore.Add(newCacheItem);
cacheItemBeforeLock.Replace(value, refreshAction, scavengingPriority, expirations);
inMemoryCache[key] = cacheItemBeforeLock;
}
catch
{
backingStore.Remove(key);
inMemoryCache.Remove(key);
throw;
}
if (scavengingPolicy.IsScavengingNeeded(inMemoryCache.Count))
{
cacheScavenger.StartScavenging();
}
CachingServiceItemTurnoverEvent.FireAddItems(1);
CachingServiceItemTurnoverEvent.SetItemsTotal(inMemoryCache.Count);
}
finally
{
Monitor.Exit(cacheItemBeforeLock);
}
}
private bool IsObjectInCache(CacheItem cacheItemBeforeLock)
{
return(cacheItemBeforeLock == null || Object.ReferenceEquals(cacheItemBeforeLock.Value, addInProgressFlag));
}
protected override Hashtable LoadDataFromStore()
{
Hashtable cacheItems = new Hashtable();
String searchString = String.Concat("*", _dataExtension);
String[] cacheFiles = Directory.GetFiles(_filePath, searchString, SearchOption.TopDirectoryOnly);
foreach(String cacheFile in cacheFiles)
{
String infoName = String.Concat(Path.GetFileNameWithoutExtension(cacheFile), _infoExtension);
String infoPath = Path.Combine(_filePath, infoName);
String[] infoData = File.ReadAllLines(infoPath);
String itemKey = infoData[0];
DateTime lastAccessed = DateTime.Parse(infoData[1]);
TimeSpan slidingDuration;
SlidingTime slidingTime = null;
if(TimeSpan.TryParse(infoData[2], out slidingDuration))
slidingTime = new SlidingTime(slidingDuration);
Byte[] itemBytes = File.ReadAllBytes(cacheFile);
Object itemValue = SerializationUtility.ToObject(itemBytes);
CacheItem item;
if(slidingTime != null)
item = new CacheItem(lastAccessed, itemKey, itemValue, CacheItemPriority.Normal, null, slidingTime);
else
item = new CacheItem(lastAccessed, itemKey, itemValue, CacheItemPriority.Normal, null);
cacheItems.Add(itemKey, item);
}
return cacheItems;
}
protected override void AddNewItem(int storageKey, CacheItem newItem)
{
CurrentStorageKey = storageKey;
string[] infoData = new string[3];
infoData[0] = newItem.Key;
infoData[1] = newItem.LastAccessedTime.ToString();
var expirations = newItem.GetExpirations();
if(expirations.Length > 0)
{
var slidingDuration = (SlidingTime)expirations.GetValue(0);
infoData[2] = slidingDuration.ItemSlidingExpiration.ToString();
}
var infoFile = Path.Combine(_filePath, string.Concat(storageKey.ToString(), _infoExtension));
try
{
if(File.Exists(infoFile))
File.Delete(infoFile);
File.WriteAllLines(infoFile, infoData);
}
catch
{
throw new FileNotFoundException("Cannot create cache info file", infoFile);
}
var itemBytes = SerializationUtility.ToBytes(newItem.Value);
var dataFile = Path.Combine(_filePath, string.Concat(storageKey.ToString(), _dataExtension));
try
{
if(File.Exists(dataFile))
File.Delete(dataFile);
File.WriteAllBytes(dataFile, itemBytes);
}
catch
{
throw new FileNotFoundException("Cannot create cache data file", dataFile);
}
}
private void InitializeExpirations(CacheItem cacheItem)
{
foreach (ICacheItemExpiration expiration in cacheItem.Expirations)
{
expiration.Initialize(cacheItem);
}
}
private bool RemoveItemFromCache(CacheItem itemToRemove)
{
lock (itemToRemove)
{
if (itemToRemove.EligibleForScavenging)
{
try
{
cacheOperations.RemoveItemFromCache(itemToRemove.Key, CacheItemRemovedReason.Scavenged);
return true;
}
catch (Exception e)
{
instrumentationProvider.FireCacheFailed(Resources.FailureToRemoveCacheItemInBackground, e);
}
}
}
return false;
}
public void Initialize(Microsoft.Practices.EnterpriseLibrary.Caching.CacheItem owningCacheItem)
{
item = owningCacheItem;
}
public void Initialize(Microsoft.Practices.EnterpriseLibrary.Caching.CacheItem owningCacheItem)
{
owningCacheItem.TouchedByUserAction(false);
}
public void Add(string key, object value, CacheItemPriority scavengingPriority, ICacheItemRefreshAction refreshAction, params ICacheItemExpiration[] expirations)
{
ValidateKey(key);
EnsureCacheInitialized();
CacheItem cacheItemBeforeLock = null;
bool lockWasSuccessful = false;
do
{
lock (inMemoryCache.SyncRoot)
{
if (inMemoryCache.Contains(key) == false)
{
cacheItemBeforeLock = new CacheItem(key, addInProgressFlag, CacheItemPriority.NotRemovable, null);
inMemoryCache[key] = cacheItemBeforeLock;
}
else
{
cacheItemBeforeLock = (CacheItem)inMemoryCache[key];
}
lockWasSuccessful = Monitor.TryEnter(cacheItemBeforeLock);
}
if (lockWasSuccessful == false)
{
Thread.Sleep(0);
}
} while (lockWasSuccessful == false);
try
{
cacheItemBeforeLock.TouchedByUserAction(true);
CacheItem newCacheItem = new CacheItem(key, value, scavengingPriority, refreshAction, expirations);
try
{
backingStore.Add(newCacheItem);
cacheItemBeforeLock.Replace(value, refreshAction, scavengingPriority, expirations);
inMemoryCache[key] = cacheItemBeforeLock;
}
catch
{
backingStore.Remove(key);
inMemoryCache.Remove(key);
throw;
}
if (scavengingPolicy.IsScavengingNeeded(inMemoryCache.Count))
{
cacheScavenger.StartScavenging();
}
CachingServiceItemTurnoverEvent.FireAddItems(1);
CachingServiceItemTurnoverEvent.SetItemsTotal(inMemoryCache.Count);
}
finally
{
Monitor.Exit(cacheItemBeforeLock);
}
}
