public void HandleEvent(Object eventObject, DateTime dispatchTime, long sequenceId)
        {
            if (!(eventObject is ClearAllCachesEvent))
            {
                return;
            }
            CommittedRootCache.Clear();
            IRootCache privilegedSecondLevelCache = SecondLevelCacheManager.SelectPrivilegedSecondLevelCache(false);

            if (privilegedSecondLevelCache != null && !Object.ReferenceEquals(privilegedSecondLevelCache, CommittedRootCache))
            {
                privilegedSecondLevelCache.Clear();
            }
            IRootCache nonPrivilegedSecondLevelCache = SecondLevelCacheManager.SelectNonPrivilegedSecondLevelCache(false);

            if (nonPrivilegedSecondLevelCache != null && !Object.ReferenceEquals(nonPrivilegedSecondLevelCache, CommittedRootCache) &&
                !Object.ReferenceEquals(nonPrivilegedSecondLevelCache, privilegedSecondLevelCache))
            {
                nonPrivilegedSecondLevelCache.Clear();
            }
            IList <IWritableCache> firstLevelCaches = FirstLevelCacheManager.SelectFirstLevelCaches();

            for (int a = firstLevelCaches.Count; a-- > 0;)
            {
                IWritableCache firstLevelCache = firstLevelCaches[a];
                firstLevelCache.Clear();
            }
        }
        protected CacheDependencyNode BuildCacheDependency()
        {
            IRootCache             privilegedSecondLevelCache    = SecondLevelCacheManager.SelectPrivilegedSecondLevelCache(true);
            IRootCache             nonPrivilegedSecondLevelCache = SecondLevelCacheManager.SelectNonPrivilegedSecondLevelCache(false);
            IList <IWritableCache> selectedFirstLevelCaches      = FirstLevelCacheManager.SelectFirstLevelCaches();

            IdentityHashMap <IRootCache, CacheDependencyNode> secondLevelCacheToNodeMap = new IdentityHashMap <IRootCache, CacheDependencyNode>();

            if (privilegedSecondLevelCache != null)
            {
                CacheDependencyNodeFactory.AddRootCache(privilegedSecondLevelCache.CurrentRootCache, secondLevelCacheToNodeMap);
            }
            if (nonPrivilegedSecondLevelCache != null)
            {
                CacheDependencyNodeFactory.AddRootCache(nonPrivilegedSecondLevelCache.CurrentRootCache, secondLevelCacheToNodeMap);
            }
            for (int a = selectedFirstLevelCaches.Count; a-- > 0;)
            {
                ChildCache childCache = (ChildCache)selectedFirstLevelCaches[a];

                IRootCache parent = ((IRootCache)childCache.Parent).CurrentRootCache;

                CacheDependencyNode node = CacheDependencyNodeFactory.AddRootCache(parent, secondLevelCacheToNodeMap);
                node.directChildCaches.Add(childCache);
            }
            return(CacheDependencyNodeFactory.BuildRootNode(secondLevelCacheToNodeMap));
        }