/// <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(); } }
/// <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 _); } }
/// <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(); } }
/// <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 _); } }
/// <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 }
/// <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 }
/// <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()); }
/// <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 }