Пример #1
0
        /// <summary>
        /// 清除过期缓存
        /// </summary>
        public virtual void DisposeCache()
        {
            KeyValuePair <string, CacheContainer>[] containerList = ToArray();
            var entityKeyDict = new Dictionary <string, bool>();

            foreach (var containerPair in containerList)
            {
                var itemSetList = containerPair.Value.Collection.ToList <CacheItemSet>();
                foreach (var itemPair in itemSetList)
                {
                    CacheItemSet itemSet = itemPair.Value;
                    if (itemSet.ItemType == CacheType.Entity)
                    {
                        //所有对象都过期才删除
                        if (entityKeyDict.ContainsKey(containerPair.Key))
                        {
                            entityKeyDict[containerPair.Key] = entityKeyDict[containerPair.Key] &&
                                                               (!itemSet.HasChanged && itemSet.IsPeriod &&
                                                                !itemSet.HasItemChanged);
                        }
                        else
                        {
                            entityKeyDict[containerPair.Key] = (!itemSet.HasChanged && itemSet.IsPeriod &&
                                                                !itemSet.HasItemChanged);
                        }
                        continue;
                    }
                    if (itemSet.HasChanged || !itemSet.IsPeriod)
                    {
                        //clear sub item is expired.
                        itemSet.RemoveExpired(itemPair.Key);
                        continue;
                    }
                    if (!itemSet.TryProcessExpired(itemPair.Key))
                    {
                        continue;
                    }
                    TraceLog.ReleaseWrite("Cache item:{0} key:{1} expired has been removed.", containerPair.Key, itemPair.Key);
                    object temp;
                    if (containerPair.Value.Collection.TryRemove(itemPair.Key, out temp))
                    {
                        itemSet.ResetStatus();
                        itemSet.Dispose();
                    }
                }
                if (containerPair.Value.Collection.Count == 0)
                {
                    containerPair.Value.ResetStatus();
                }
            }
            //处理共享缓存
            foreach (var pair in entityKeyDict)
            {
                //排除不过期的
                if (!pair.Value)
                {
                    continue;
                }

                CacheContainer container;
                if (TryRemove(pair.Key, out container, t => true))
                {
                    var itemSetList = container.Collection.ToList <CacheItemSet>();
                    TraceLog.ReleaseWrite("Cache shard entity:{0} expired has been removed, count:{1}.", pair.Key, itemSetList.Count());
                    foreach (var itemPair in itemSetList)
                    {
                        CacheItemSet itemSet = itemPair.Value;
                        object       temp;
                        if (container.Collection.TryRemove(itemPair.Key, out temp))
                        {
                            itemSet.ResetStatus();
                            itemSet.Dispose();
                        }
                    }
                    container.ResetStatus();
                    container.Dispose();
                }
            }
        }
Пример #2
0
        public TVPHelper ProcessTrackingData(string siteName, string siteLang, string htmlCacheKey,
                                             string htmlCacheResult, Guid itemId, string itemLang)
        {
            if (TVP != null)
            {
                CacheSite cacheSite = new CacheSite
                {
                    SiteName = siteName,
                    SiteLang = siteLang
                };

                var cacheSiteExists = !CacheSiteSet.Add(cacheSite);

                if (cacheSiteExists)
                {
                    cacheSite = CacheSiteSet.First(x => Equals(x, cacheSite));
                }
                else
                {
                    TVP.Tables[CacheSite_TVP].Rows
                    .Add(cacheSite.Id, cacheSite.SiteName, cacheSite.SiteLang);
                }

                CacheHtml cacheHtml = new CacheHtml
                {
                    CacheSiteId      = cacheSite.Id,
                    HtmlCacheKey     = htmlCacheKey,
                    HtmlCacheResult  = htmlCacheResult,
                    HtmlCacheKeyHash = SHA512(htmlCacheKey)
                };

                var cacheHtmlExists = !CacheHtmlSet.Add(cacheHtml);

                if (cacheHtmlExists)
                {
                    cacheHtml = CacheHtmlSet.First(x => x.Equals(cacheHtml));
                }
                else
                {
                    TVP.Tables[CacheHtml_TVP].Rows.Add(cacheHtml.Id, cacheSite.Id,
                                                       cacheHtml.HtmlCacheKey,
                                                       cacheHtml.HtmlCacheResult, cacheHtml.HtmlCacheKeyHash);
                }

                CacheItem cacheItem = new CacheItem
                {
                    ItemId   = itemId,
                    ItemLang = itemLang
                };

                var cacheItemExists = !CacheItemSet.Add(cacheItem);

                if (cacheItemExists)
                {
                    cacheItem = CacheItemSet.First(x => x.Equals(cacheItem));
                }
                else
                {
                    TVP.Tables[CacheItem_TVP].Rows.Add(cacheItem.Id, cacheItem.ItemId,
                                                       cacheItem.ItemLang, false);
                }

                CacheHtmlCacheItem cacheHtmlCacheItem = new CacheHtmlCacheItem
                {
                    CacheHtmlId = cacheHtml.Id,
                    CacheItemId = cacheItem.Id
                };

                var cacheHtmlCacheItemExists = !CacheHtmlCacheItemSet.Add(cacheHtmlCacheItem);

                if (!cacheHtmlCacheItemExists)
                {
                    TVP.Tables[CacheHtml_CacheItem_TVP].Rows.Add(cacheHtmlCacheItem.Id,
                                                                 cacheHtmlCacheItem.CacheHtmlId, cacheHtmlCacheItem.CacheItemId);
                }

                return(this);
            }
            return(null);
        }