/// <summary>Determines if we can expire cache.</summary>
        /// <returns>true if it succeeds, false if it fails.</returns>
        public static bool ExpireCache()
        {
            try
            {
                if (SharedLock.TryAcquireLock(ref SharedLock.ExpireCacheLock))
                {
                    // Change the next schedule, so other threads will not try to expire the cache
                    Configuration.ExpireCacheNextScheduled = DateTime.Now.Add(Configuration.ExpireCacheDelay);

                    // EXPIRE delegate cache
                    {
                        var expireDateDelegate = DateTime.Now.Subtract(Configuration.SlidingExpirationDelegate);
                        var keyToRemoves       = new List <string>();

                        foreach (var bucket in CacheDelegate.Buckets)
                        {
                            try
                            {
                                bucket.AcquireLock();

                                foreach (var keyvalue in bucket.InnerDictionary)
                                {
                                    if (keyvalue.Value.LastAccess < expireDateDelegate)
                                    {
                                        keyToRemoves.Add(keyvalue.Key);
                                    }
                                }

                                foreach (var key in keyToRemoves)
                                {
                                    bucket.InnerDictionary.Remove(key);
                                }
                            }
                            finally
                            {
                                bucket.ReleaseLock();
                            }
                        }
                    }


                    // EXPIRE item cache
                    {
                        var expireDateItem = DateTime.Now.Subtract(Configuration.SlidingExpirationItem);
                        var keyToRemoves   = new List <int>();

                        foreach (var bucket in CacheItem.Buckets)
                        {
                            try
                            {
                                bucket.AcquireLock();

                                foreach (var keyvalue in bucket.InnerDictionary)
                                {
                                    if (keyvalue.Value.LastAccess < expireDateItem)
                                    {
                                        keyvalue.Value.IsCached = false;
                                        keyToRemoves.Add(keyvalue.Key);
                                    }
                                }

                                foreach (var key in keyToRemoves)
                                {
                                    bucket.InnerDictionary.Remove(key);
                                }
                            }
                            finally
                            {
                                bucket.ReleaseLock();
                            }
                        }
                    }

                    return(true);
                }

                return(false);
            }
            finally
            {
                SharedLock.ReleaseLock(ref SharedLock.ExpireCacheLock);
            }
        }