/// <inheritdoc />
        public object Get(string key, Func <object> factory, TimeSpan?timeout, bool isSliding = false, string[] dependentFiles = null)
        {
            // see notes in HttpRuntimeAppCache

            Lazy <object> result;

            using (var lck = new UpgradeableReadLock(_locker))
            {
                result = MemoryCache.Get(key) as Lazy <object>;
                if (result == null || SafeLazy.GetSafeLazyValue(result, true) == null) // get non-created as NonCreatedValue & exceptions as null
                {
                    result = SafeLazy.GetSafeLazy(factory);
                    var policy = GetPolicy(timeout, isSliding, dependentFiles);

                    lck.UpgradeToWriteLock();
                    //NOTE: This does an add or update
                    MemoryCache.Set(key, result, policy);
                }
            }

            //return result.Value;

            var value = result.Value; // will not throw (safe lazy)

            if (value is SafeLazy.ExceptionHolder eh)
            {
                eh.Exception.Throw();                                       // throw once!
            }
            return(value);
        }
        /// <inheritdoc />
        public virtual void ClearOfType <T>()
        {
            try
            {
                _locker.EnterWriteLock();
                var typeOfT     = typeof(T);
                var isInterface = typeOfT.IsInterface;
                foreach (var key in MemoryCache
                         .Where(x =>
                {
                    // x.Value is Lazy<object> and not null, its value may be null
                    // remove null values as well, does not hurt
                    // get non-created as NonCreatedValue & exceptions as null
                    var value = SafeLazy.GetSafeLazyValue((Lazy <object>)x.Value, true);

                    // if T is an interface remove anything that implements that interface
                    // otherwise remove exact types (not inherited types)
                    return(value == null || (isInterface ? (value is T) : (value.GetType() == typeOfT)));
                })
                         .Select(x => x.Key)
                         .ToArray()) // ToArray required to remove
                {
                    MemoryCache.Remove(key);
                }
            }
            finally
            {
                if (_locker.IsWriteLockHeld)
                {
                    _locker.ExitWriteLock();
                }
            }
        }
        /// <inheritdoc />
        public virtual void ClearOfType(string typeName)
        {
            var type = _typeFinder.GetTypeByName(typeName);

            if (type == null)
            {
                return;
            }
            var isInterface = type.IsInterface;

            try
            {
                EnterWriteLock();
                foreach (var entry in GetDictionaryEntries()
                         .Where(x =>
                {
                    // entry.Value is Lazy<object> and not null, its value may be null
                    // remove null values as well, does not hurt
                    // get non-created as NonCreatedValue & exceptions as null
                    var value = SafeLazy.GetSafeLazyValue((Lazy <object>)x.Value, true);

                    // if T is an interface remove anything that implements that interface
                    // otherwise remove exact types (not inherited types)
                    return(value == null || (isInterface ? (type.IsInstanceOfType(value)) : (value.GetType() == type)));
                })
                         .ToArray())
                {
                    RemoveEntry((string)entry.Key);
                }
            }
            finally
            {
                ExitWriteLock();
            }
        }
Beispiel #4
0
        /// <inheritdoc />
        public void ClearOfType(string typeName)
        {
            var type = _typeFinder.GetTypeByName(typeName);

            if (type == null)
            {
                return;
            }
            var isInterface = type.IsInterface;

            foreach (var kvp in _items
                     .Where(x =>
            {
                // entry.Value is Lazy<object> and not null, its value may be null
                // remove null values as well, does not hurt
                // get non-created as NonCreatedValue & exceptions as null
                var value = SafeLazy.GetSafeLazyValue(x.Value, true);

                // if T is an interface remove anything that implements that interface
                // otherwise remove exact types (not inherited types)
                return(value == null || (isInterface ? (type.IsInstanceOfType(value)) : (value.GetType() == type)));
            }))
            {
                _items.TryRemove(kvp.Key, out _);
            }
        }
Beispiel #5
0
 /// <inheritdoc />
 public IEnumerable <object> SearchByKey(string keyStartsWith)
 {
     return(_items
            .Where(kvp => kvp.Key.InvariantStartsWith(keyStartsWith))
            .Select(kvp => SafeLazy.GetSafeLazyValue(kvp.Value))
            .Where(x => x != null));
 }
        /// <inheritdoc />
        public virtual void ClearOfType <T>()
        {
            var typeOfT     = typeof(T);
            var isInterface = typeOfT.IsInterface;

            try
            {
                EnterWriteLock();
                foreach (var entry in GetDictionaryEntries()
                         .Where(x =>
                {
                    // entry.Value is Lazy<object> and not null, its value may be null
                    // remove null values as well, does not hurt
                    // compare on exact type, don't use "is"
                    // get non-created as NonCreatedValue & exceptions as null
                    var value = SafeLazy.GetSafeLazyValue((Lazy <object>)x.Value, true);

                    // if T is an interface remove anything that implements that interface
                    // otherwise remove exact types (not inherited types)
                    return(value == null || (isInterface ? (value is T) : (value.GetType() == typeOfT)));
                })
                         .ToArray())
                {
                    RemoveEntry((string)entry.Key);
                }
            }
            finally
            {
                ExitWriteLock();
            }
        }
Beispiel #7
0
        /// <inheritdoc />
        public void ClearOfType <T>(Func <string, T, bool> predicate)
        {
            var typeOfT     = typeof(T);
            var isInterface = typeOfT.IsInterface;

            foreach (var kvp in _items
                     .Where(x =>
            {
                // entry.Value is Lazy<object> and not null, its value may be null
                // remove null values as well, does not hurt
                // compare on exact type, don't use "is"
                // get non-created as NonCreatedValue & exceptions as null
                var value = SafeLazy.GetSafeLazyValue(x.Value, true);
                if (value == null)
                {
                    return(true);
                }

                // if T is an interface remove anything that implements that interface
                // otherwise remove exact types (not inherited types)
                return((isInterface ? (value is T) : (value.GetType() == typeOfT))
                       // run predicate on the 'public key' part only, ie without prefix
                       && predicate(x.Key, (T)value));
            }))
            {
                _items.TryRemove(kvp.Key, out _);
            }
        }
Beispiel #8
0
        /// <inheritdoc />
        public IEnumerable <object> SearchByRegex(string regex)
        {
            var compiled = new Regex(regex, RegexOptions.Compiled);

            return(_items
                   .Where(kvp => compiled.IsMatch(kvp.Key))
                   .Select(kvp => SafeLazy.GetSafeLazyValue(kvp.Value))
                   .Where(x => x != null));
        }
        /// <inheritdoc />
        public virtual object Get(string key)
        {
            key = GetCacheKey(key);
            Lazy <object> result;

            try
            {
                EnterReadLock();
                result = GetEntry(key) as Lazy <object>; // null if key not found
            }
            finally
            {
                ExitReadLock();
            }
            return(result == null ? null : SafeLazy.GetSafeLazyValue(result)); // return exceptions as null
        }
Beispiel #10
0
        /// <inheritdoc />
        public override object Get(string key, Func <object> factory)
        {
            //no place to cache so just return the callback result
            if (!TryGetContextItems(out var items))
            {
                return(factory());
            }

            key = GetCacheKey(key);

            Lazy <object> result;

            try
            {
                EnterWriteLock();
                result = items[key] as Lazy <object>; // null if key not found

                // cannot create value within the lock, so if result.IsValueCreated is false, just
                // do nothing here - means that if creation throws, a race condition could cause
                // more than one thread to reach the return statement below and throw - accepted.

                if (result == null || SafeLazy.GetSafeLazyValue(result, true) == null) // get non-created as NonCreatedValue & exceptions as null
                {
                    result     = SafeLazy.GetSafeLazy(factory);
                    items[key] = result;
                }
            }
            finally
            {
                ExitWriteLock();
            }

            // using GetSafeLazy and GetSafeLazyValue ensures that we don't cache
            // exceptions (but try again and again) and silently eat them - however at
            // some point we have to report them - so need to re-throw here

            // this does not throw anymore
            //return result.Value;

            var value = result.Value; // will not throw (safe lazy)

            if (value is SafeLazy.ExceptionHolder eh)
            {
                eh.Exception.Throw();                                       // throw once!
            }
            return(value);
        }
        /// <inheritdoc />
        public object Get(string key)
        {
            Lazy <object> result;

            try
            {
                _locker.EnterReadLock();
                result = MemoryCache.Get(key) as Lazy <object>; // null if key not found
            }
            finally
            {
                if (_locker.IsReadLockHeld)
                {
                    _locker.ExitReadLock();
                }
            }
            return(result == null ? null : SafeLazy.GetSafeLazyValue(result)); // return exceptions as null
        }
        /// <inheritdoc />
        public virtual IEnumerable <object> SearchByKey(string keyStartsWith)
        {
            var plen = CacheItemPrefix.Length + 1;
            IEnumerable <DictionaryEntry> entries;

            try
            {
                EnterReadLock();
                entries = GetDictionaryEntries()
                          .Where(x => ((string)x.Key).Substring(plen).InvariantStartsWith(keyStartsWith))
                          .ToArray(); // evaluate while locked
            }
            finally
            {
                ExitReadLock();
            }

            return(entries
                   .Select(x => SafeLazy.GetSafeLazyValue((Lazy <object>)x.Value)) // return exceptions as null
                   .Where(x => x != null));                                        // backward compat, don't store null values in the cache
        }
Beispiel #13
0
        /// <inheritdoc />
        public void ClearOfType <T>()
        {
            var typeOfT     = typeof(T);
            var isInterface = typeOfT.IsInterface;

            foreach (var kvp in _items
                     .Where(x =>
            {
                // entry.Value is Lazy<object> and not null, its value may be null
                // remove null values as well, does not hurt
                // compare on exact type, don't use "is"
                // get non-created as NonCreatedValue & exceptions as null
                var value = SafeLazy.GetSafeLazyValue(x.Value, true);

                // if T is an interface remove anything that implements that interface
                // otherwise remove exact types (not inherited types)
                return(value == null || (isInterface ? (value is T) : (value.GetType() == typeOfT)));
            }))
            {
                _items.TryRemove(kvp.Key, out _);
            }
        }
        /// <inheritdoc />
        public virtual IEnumerable <object> SearchByRegex(string regex)
        {
            const string prefix   = CacheItemPrefix + "-";
            var          compiled = new Regex(regex, RegexOptions.Compiled);
            var          plen     = prefix.Length;
            IEnumerable <DictionaryEntry> entries;

            try
            {
                EnterReadLock();
                entries = GetDictionaryEntries()
                          .Where(x => compiled.IsMatch(((string)x.Key).Substring(plen)))
                          .ToArray(); // evaluate while locked
            }
            finally
            {
                ExitReadLock();
            }
            return(entries
                   .Select(x => SafeLazy.GetSafeLazyValue((Lazy <object>)x.Value)) // return exceptions as null
                   .Where(x => x != null));                                        // backward compatible, don't store null values in the cache
        }
 /// <inheritdoc />
 public IEnumerable <object> SearchByKey(string keyStartsWith)
 {
     KeyValuePair <string, object>[] entries;
     try
     {
         _locker.EnterReadLock();
         entries = MemoryCache
                   .Where(x => x.Key.InvariantStartsWith(keyStartsWith))
                   .ToArray(); // evaluate while locked
     }
     finally
     {
         if (_locker.IsReadLockHeld)
         {
             _locker.ExitReadLock();
         }
     }
     return(entries
            .Select(x => SafeLazy.GetSafeLazyValue((Lazy <object>)x.Value)) // return exceptions as null
            .Where(x => x != null)                                          // backward compat, don't store null values in the cache
            .ToList());
 }
        /// <inheritdoc />
        public virtual void ClearOfType <T>(Func <string, T, bool> predicate)
        {
            var typeOfT     = typeof(T);
            var isInterface = typeOfT.IsInterface;
            var plen        = CacheItemPrefix.Length + 1;

            try
            {
                EnterWriteLock();
                foreach (var entry in GetDictionaryEntries()
                         .Where(x =>
                {
                    // entry.Value is Lazy<object> and not null, its value may be null
                    // remove null values as well, does not hurt
                    // compare on exact type, don't use "is"
                    // get non-created as NonCreatedValue & exceptions as null
                    var value = SafeLazy.GetSafeLazyValue((Lazy <object>)x.Value, true);
                    if (value == null)
                    {
                        return(true);
                    }

                    // if T is an interface remove anything that implements that interface
                    // otherwise remove exact types (not inherited types)
                    return((isInterface ? (value is T) : (value.GetType() == typeOfT))
                           // run predicate on the 'public key' part only, ie without prefix
                           && predicate(((string)x.Key).Substring(plen), (T)value));
                }))
                {
                    RemoveEntry((string)entry.Key);
                }
            }
            finally
            {
                ExitWriteLock();
            }
        }
        /// <inheritdoc />
        public IEnumerable <object> SearchByRegex(string regex)
        {
            var compiled = new Regex(regex, RegexOptions.Compiled);

            KeyValuePair <string, object>[] entries;
            try
            {
                _locker.EnterReadLock();
                entries = MemoryCache
                          .Where(x => compiled.IsMatch(x.Key))
                          .ToArray(); // evaluate while locked
            }
            finally
            {
                if (_locker.IsReadLockHeld)
                {
                    _locker.ExitReadLock();
                }
            }
            return(entries
                   .Select(x => SafeLazy.GetSafeLazyValue((Lazy <object>)x.Value)) // return exceptions as null
                   .Where(x => x != null)                                          // backward compat, don't store null values in the cache
                   .ToList());
        }
Beispiel #18
0
 /// <inheritdoc />
 public object Get(string cacheKey)
 {
     _items.TryGetValue(cacheKey, out var result);                      // else null
     return(result == null ? null : SafeLazy.GetSafeLazyValue(result)); // return exceptions as null
 }