Ejemplo n.º 1
0
 public void AddCaching(Type caching, ICachingOptions cachingOptions)
 {
     UraganoSettings.CachingOptions = cachingOptions;
     ServiceCollection.AddSingleton(typeof(ICaching), caching);
     ServiceCollection.AddSingleton(typeof(ICachingKeyGenerator), cachingOptions.KeyGenerator);
     RegisterSingletonService <CachingDefaultInterceptor>();
 }
Ejemplo n.º 2
0
        /// <summary>
        /// Caches an object
        /// </summary>
        /// <param name="key">A unique key to cache the object under</param>
        /// <param name="obj">The object to cache</param>
        /// <param name="cachingOptions">Options on how to cache</param>
        public static void Add(string key, object obj, ICachingOptions cachingOptions)
        {
            if (string.IsNullOrEmpty(key))
            {
                throw new ArgumentNullException("key");
            }

            if (obj == null)
            {
                throw new ArgumentNullException("obj");
            }

            if (cachingOptions == null)
            {
                throw new ArgumentNullException("cachingOptions");
            }

            CacheItemPolicy cacheItemPolicy = new CacheItemPolicy
            {
                Priority           = CacheItemPriority.Default,
                AbsoluteExpiration = DateTime.Now.AddMilliseconds(cachingOptions.Expiration.TotalMilliseconds)
            };

            if (cachingOptions.OnRemoved != null)
            {
                cacheItemPolicy.RemovedCallback += x => cachingOptions.OnRemoved(x.RemovedReason);
            }

            CacheLock.EnterWriteLock();

            Cache.Set(key, obj, cacheItemPolicy);

            CacheLock.ExitWriteLock();
        }
Ejemplo n.º 3
0
        public MemoryCache(IMemoryCache cache, ICachingOptions cachingOptions)
        {
            this.Cache          = cache;
            this.CachingOptions = cachingOptions;

            _keys = new List <string>();
        }
Ejemplo n.º 4
0
        public void Execute(CallbackArgs args)
        {
            IPublish <Message> response     = args.Publish;
            ISubscription      subscription = args.Peer.GetSubscription(response.Key);

            if (subscription == null)
            {
                return;
            }

            ICachingOptions cachingOptions = subscription.CachingOptions;

            if (cachingOptions == null || !cachingOptions.EnableCaching)
            {
                return;
            }

            if (!cachingOptions.HasCacheKey)
            {
                return;
            }

            string callbackKey = string.Format("callback#{0}#{1}", args.Peer.Node.Contact.NodeId, response.Key);

            string cacheKey = callbackKey;

            if (string.Equals(cachingOptions.Key, response.Key))
            {
                string extraKey = cachingOptions.GetCacheKey(response.Message);

                if (!string.IsNullOrEmpty(extraKey))
                {
                    cacheKey = string.Format("{0}#{1}", callbackKey, extraKey);
                }
            }

            CacheManager.Add(cacheKey, args.Publish.Message, cachingOptions);

            // Request response scheme
            if (string.Equals(subscription.Key, cachingOptions.Key))
            {
                return;
            }

            IPublish <Message> request =
                CacheManager.Get <IPublish <Message> >(string.Format("publish#{0}#{1}", args.Peer.Node.Contact.NodeId,
                                                                     cachingOptions.Key));

            if (request != null && string.Equals(request.Key, cachingOptions.Key))
            {
                string extraKey = cachingOptions.GetCacheKey(request.Message);
                if (!string.IsNullOrEmpty(extraKey))
                {
                    cacheKey = string.Format("{0}#{1}", callbackKey, extraKey);
                    CacheManager.Add(cacheKey, args.Publish.Message, cachingOptions);
                }
            }
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Retrieves an item from the cache and adds it if is not there
        /// </summary>
        /// <param name="key"></param>
        /// <param name="selector"></param>
        /// <param name="cachingOptions"></param>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        /// <exception cref="ArgumentNullException"></exception>
        public static T GetOrAdd <T>(string key, Func <T> selector, ICachingOptions cachingOptions) where T : class
        {
            if (string.IsNullOrEmpty(key))
            {
                throw new ArgumentNullException("key");
            }

            if (selector == null)
            {
                throw new ArgumentNullException("selector");
            }

            if (cachingOptions == null)
            {
                throw new ArgumentNullException("cachingOptions");
            }

            T value = Get <T>(key);

            if (value != null)
            {
                return(value);
            }

            CacheItemPolicy cacheItemPolicy = new CacheItemPolicy
            {
                Priority           = CacheItemPriority.Default,
                AbsoluteExpiration = DateTime.Now.AddMilliseconds(cachingOptions.Expiration.TotalMilliseconds)
            };

            if (cachingOptions.OnRemoved != null)
            {
                cacheItemPolicy.RemovedCallback += x => cachingOptions.OnRemoved(x.RemovedReason);
            }

            try
            {
                CacheLock.EnterWriteLock();

                value = Cache[key] as T;

                if (value != null)
                {
                    return(value);
                }

                value = selector();

                Cache.Set(key, value, cacheItemPolicy);

                return(value);
            }
            finally
            {
                CacheLock.ExitWriteLock();
            }
        }
Ejemplo n.º 6
0
 public void AddCaching <TCaching>(ICachingOptions cachingOptions) where TCaching : ICaching
 {
     AddCaching(typeof(TCaching), cachingOptions);
 }
Ejemplo n.º 7
0
 public void AddCaching(Type caching, ICachingOptions cachingOptions)
 {
     AddCaching(caching, typeof(CachingKeyGenerator), cachingOptions);
 }
Ejemplo n.º 8
0
 public void AddCaching <TCaching, TKeyGenerator>(ICachingOptions cachingOptions) where TCaching : class, ICaching where TKeyGenerator : class, ICachingKeyGenerator
 {
     AddCaching(typeof(TCaching), typeof(TKeyGenerator), cachingOptions);
 }