Exemplo n.º 1
0
        protected T GetOrCreateWithLock <T>(
            string key,
            Func <T> get,
            Func <T> factory,
            CacheOptions <T> options
            )
        {
            var result = get();

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

            var lockObj = GetLock(key);

            lock (lockObj)
            {
                result = get();
                if (result != null)
                {
                    return(result);
                }

                result = factory();
            }
            RemoveLock(key);

            return(result);
        }
Exemplo n.º 2
0
        public virtual Task <HashSet <string> > GetSetAsync(
            string key,
            Func <IEnumerable <string> > factory = null
            )
        {
            var result =
                GetOrCreateWithLock(
                    key,
                    () => IMemoryCacheService.Get <HashSet <string> >(key),
                    () =>
            {
                var items =
                    factory != null
                                                                ? factory()
                                                                : new string[] { };

                var _result = items.ToHashSet();

                var entryOptions = new CacheOptions <HashSet <string> >(expirationType: CacheExpirationType.NotRemoveable);

                IMemoryCacheService.Set(key, _result, entryOptions);

                return(_result);
            },
                    null
                    );

            return(Task.FromResult(result));
        }
Exemplo n.º 3
0
        public virtual Task <T> GetAsync <T>(
            string key,
            Func <T> factory         = null,
            CacheOptions <T> options = null
            )
        {
            var result =
                GetOrCreateWithLock(
                    key,
                    () => IMemoryCacheService.Get <T>(key),
                    () =>
            {
                if (factory == null)
                {
                    return(default(T));
                }

                var _result = factory();
                IMemoryCacheService.Set(key, _result, options);
                return(_result);
            },
                    options
                    );

            return(Task.FromResult(result));
        }
Exemplo n.º 4
0
 public virtual Task SetAsync <T>(
     string key,
     T obj,
     CacheOptions <T> options = null
     )
 {
     IMemoryCacheService.Set(key, obj, options);
     return(Task.CompletedTask);
 }
Exemplo n.º 5
0
        public MemoryCacheEntryOptions Create <T>(CacheOptions <T> options = null)
        {
            var timeoutMinutes =
                options?.TimeoutMinutes
                ?? _DefaultTimeoutMinutes;

            var timeoutMinutesSpan = TimeSpan.FromMinutes(timeoutMinutes);

            if (options == null)
            {
                return
                    new MemoryCacheEntryOptions
                    {
                        SlidingExpiration = timeoutMinutesSpan
                    }
            }
            ;

            var result = new MemoryCacheEntryOptions();

            if (options.ExpirationType == CacheExpirationType.NotRemoveable)
            {
                result.Priority = CacheItemPriority.NeverRemove;
            }
            else
            {
                if (options.ExpirationType == CacheExpirationType.Sliding)
                {
                    result.SlidingExpiration = timeoutMinutesSpan;
                }

                if (options.ExpirationType == CacheExpirationType.Absolute)
                {
                    result.AbsoluteExpirationRelativeToNow = timeoutMinutesSpan;
                }
            }

            result.RegisterPostEvictionCallback((key, value, reason, state) =>
            {
                options.DidRemove?.Invoke(options);

                if (value is IDisposable disposable)
                {
                    disposable.Dispose();
                }
            });

            return(result);
        }

        #endregion
    }
Exemplo n.º 6
0
        public Task SetAsync <T>(
            string key,
            T obj,
            CacheOptions <T> cacheOptions = null
            )
        {
            return
                (Task.Run(() =>
            {
                using (var client = GetClient())
                {
                    client.Set(key, obj.ToJsonWithTypeInformation());

                    if (cacheOptions?.ExpirationType == CacheExpirationType.Absolute)
                    {
                        var absoluteExpire = ITimeService.Now.AddMinutes(cacheOptions.TimeoutMinutes);
                        client.ExpireEntryAt(key, absoluteExpire);
                    }

                    return Task.CompletedTask;
                }
            }));
        }