/// <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);
            }
        }
Ejemplo n.º 2
0
        /// <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);
            }
        }
Ejemplo n.º 3
0
        public void TotalCacheExpiriesCounterIncremented()
        {
            enabledProvider.FireCacheExpired(30L);

            Assert.AreEqual(30L, totalCacheExpiriesCounter.RawValue);
        }