/// <summary> /// Asynchronously executes the plan /// </summary> public virtual async Task <CachedValue <T> > ExecuteAsync() { CachedValue <T> cachedValue = null; try { cachedValue = Cache.Get <T>(Key, Region); CacheValidationResult validationResult = await ValidateCachedValueAsync(cachedValue); if (validationResult != CacheValidationResult.Valid && (validationResult == CacheValidationResult.Invalid || cachedValue == null)) { cachedValue = await RetrieveCachedValueAsync(previousCachedValue : cachedValue); } return(cachedValue); } catch (FluentCache.FluentCacheException cacheException) { if (!ExceptionHandler.TryHandleCachingFailure(cacheException)) { throw; } else { return(null); } } }
/// <summary> /// Asynchronously executes the plan /// </summary> public virtual async Task <CachedValue <T> > ExecuteAsync() { CachedValue <T> cachedValue = cachedValue = Cache.Get <T>(Key, Region); CacheValidationResult validationResult = await ValidateCachedValueAsync(cachedValue); if (validationResult != CacheValidationResult.Valid && (validationResult == CacheValidationResult.Invalid || cachedValue == null)) { cachedValue = await RetrieveCachedValueAsync(previousCachedValue : cachedValue); } return(cachedValue); }
/// <summary> /// Executes the plan /// </summary> public virtual CachedValue <T> Execute() { CachedValue <T> cachedValue = Cache.Get <T>(Key, Region); CacheValidationResult validationResult = ValidateCachedValue(cachedValue); if (validationResult != CacheValidationResult.Valid && (validationResult == CacheValidationResult.Invalid || cachedValue == null)) { cachedValue = RetrieveCachedValue(previousCachedValue: cachedValue); } return(cachedValue); }
/// <summary> /// Validates the cached value /// </summary> protected virtual CacheValidationResult ValidateCachedValue(CachedValue <T> existingCachedValue) { if (existingCachedValue == null) { return(CacheValidationResult.Unknown); } CacheValidationResult result = _cacheStrategy.Validate(existingCachedValue); if (result == CacheValidationResult.Valid) { Cache.MarkAsValidated(Key, Region); } return(result); }
/// <summary> /// Asynchronously executes the plan /// </summary> public override async Task <CachedValue <T> > ExecuteAsync() { //If the circuit is broken then we won't even try to retrieve the value from the cache if (_circuitBreaker.IsBroken) { return(null); } CachedValue <T> cachedValue = null; try { //Get the value from the cache cachedValue = Cache.Get <T>(Key, Region); //validate the value CacheValidationResult validationResult = await ValidateCachedValueAsync(cachedValue); //if the value is invalid or non-existing then retrieve the value from the cache if (validationResult != CacheValidationResult.Valid && (validationResult == CacheValidationResult.Invalid || cachedValue == null)) { cachedValue = await RetrieveCachedValueAsync(previousCachedValue : cachedValue); } //We successfully retrieved the value from the cache, so reset the circuit _circuitBreaker.Reset(); return(cachedValue); } catch (FluentCache.FluentCacheException cacheException) { //attempt to handle the caching failure if (ExceptionHandler.TryHandleCachingFailure(cacheException)) { //try to break the circuit _circuitBreaker.TryBreak(cacheException); return(null); } else { throw; } } }
/// <summary> /// Asynchronously validates the cached value /// </summary> protected virtual async Task <CacheValidationResult> ValidateCachedValueAsync(CachedValue <T> existingCachedValue) { if (_cacheStrategyAsync == null) { throw new InvalidOperationException("Specified cache strategy must be an instance of ICacheStrategyAsync<T>"); } if (existingCachedValue == null) { return(CacheValidationResult.Unknown); } CacheValidationResult result = await _cacheStrategyAsync.ValidateAsync(existingCachedValue); if (result == CacheValidationResult.Valid) { Cache.MarkAsValidated(Key, Region); } return(result); }