/// <summary> /// Obtain an <see cref="INamedCache"/> interface that provides a view /// of resources shared among members of a cluster. /// </summary> /// <remarks> /// The view is identified by name within this ICacheService. /// Typically, repeated calls to this method with the same view name /// will result in the same view reference being returned. /// </remarks> /// <param name="name"> /// The name, within this ICacheService, that uniquely identifies a /// view; <c>null</c> is legal, and may imply a default name. /// </param> /// <returns> /// An <b>INamedCache</b> interface which can be used to access the /// resources of the specified view. /// </returns> /// <exception cref="InvalidOperationException"> /// If the service is not running. /// </exception> public virtual INamedCache EnsureCache(string name) { if (StringUtils.IsNullOrEmpty(name)) { name = "Default"; } ScopedReferenceStore storeCache = StoreRemoteNamedCache; RemoteNamedCache cache = storeCache.GetCache(name) as RemoteNamedCache; if (cache == null || !cache.IsActive) { lock (storeCache) { cache = storeCache.GetCache(name) as RemoteNamedCache; if (cache == null || !cache.IsActive) { cache = CreateRemoteNamedCache(name); storeCache.PutCache(cache); } } } return(cache); }
/// <summary> /// Obtain an <see cref="INamedCache"/> interface that provides a view /// of resources shared among members of a cluster. /// </summary> /// <remarks> /// The view is identified by name within this ICacheService. /// Typically, repeated calls to this method with the same view name /// will result in the same view reference being returned. /// </remarks> /// <param name="name"> /// The name, within this ICacheService, that uniquely identifies a /// view; <c>null</c> is legal, and may imply a default name. /// </param> /// <returns> /// An <b>INamedCache</b> interface which can be used to access the /// resources of the specified view. /// </returns> /// <exception cref="InvalidOperationException"> /// If the service is not running. /// </exception> public INamedCache EnsureCache(string name) { if (string.IsNullOrEmpty(name)) { name = "Default"; } ScopedReferenceStore storeCache = StoreSafeNamedCache; SafeNamedCache cacheSafe = (SafeNamedCache)storeCache.GetCache(name); if (cacheSafe == null) { lock (storeCache) { INamedCache cache = RunningCacheService.EnsureCache(name); cacheSafe = new SafeNamedCache { SafeCacheService = this, CacheName = name, NamedCache = cache, Principal = Thread.CurrentPrincipal }; storeCache.PutCache(cacheSafe); } } return(cacheSafe); }
/// <summary> /// Removes <see cref="SafeNamedCache"/> from the /// <see cref="ScopedReferenceStore"/>. /// </summary> /// <param name="cacheSafe"> /// <b>SafeNamedCache</b> to be removed. /// </param> protected virtual void RemoveCacheReference(SafeNamedCache cacheSafe) { cacheSafe.IsReleased = true; ScopedReferenceStore storeCache = StoreSafeNamedCache; lock (storeCache) { storeCache.ReleaseCache(cacheSafe); } }
/// <summary> /// Cleanup used resources. /// </summary> protected override void Cleanup() { base.Cleanup(); ScopedReferenceStore storeCache = StoreSafeNamedCache; lock (storeCache) { storeCache.Clear(); } }
/// <summary> /// Releases all the caches fetched from the store and then clears the store. /// </summary> public virtual void ReleaseCaches() { ScopedReferenceStore storeCache = StoreRemoteNamedCache; lock (storeCache) { for (IEnumerator iter = storeCache.GetAllCaches().GetEnumerator(); iter.MoveNext();) { RemoteNamedCache cache = (RemoteNamedCache)iter.Current; ReleaseRemoteNamedCache(cache as RemoteNamedCache); } storeCache.Clear(); } }
/// <summary> /// Release local resources associated with the specified instance of /// the cache. /// </summary> /// <remarks> /// <p> /// This invalidates a reference obtained by using the /// <see cref="ICacheService.EnsureCache"/> method.</p> /// <p> /// Releasing a reference to a cache makes the cache reference no /// longer usable, but does not affect the cache itself. In other /// words, all other references to the cache will still be valid, and /// the cache data is not affected by releasing the reference.</p> /// <p> /// The reference that is released using this method can no longer be /// used; any attempt to use the reference will result in an /// exception.</p> /// </remarks> /// <param name="cache"> /// The cache object to be released. /// </param> public virtual void ReleaseCache(INamedCache cache) { if (!(cache is RemoteNamedCache)) { throw new ArgumentException("illegal cache: " + cache); } ScopedReferenceStore storeCache = StoreRemoteNamedCache; lock (storeCache) { storeCache.ReleaseCache(cache); } ReleaseRemoteNamedCache(cache as RemoteNamedCache); }