public static TResult GetCachedData <T, TResult>(ICacheSettings settings, Func <T, TResult> method, T arg1, params Object[] args) { return(CacheUtils.GetCachedData_Proxy( settings, method.Method.DeclaringType.GetFriendlyTypeName(), method.Method.Name, ((Object[] argv) => (method.Invoke(arg1))), arg1, args)); }
public ApprenticeshipOrchestrator(IMediator mediator, ILog logger, IFrameworkDetailsViewModelMapper frameworkDetailsViewModelMapper, IStandardDetailsViewModelMapper standardDetailsViewModelMapper, ICacheStorageService cacheStorageService, ICacheSettings cacheSettings) { _mediator = mediator; _logger = logger; _frameworkDetailsViewModelMapper = frameworkDetailsViewModelMapper; _standardDetailsViewModelMapper = standardDetailsViewModelMapper; _cacheService = cacheStorageService; _cacheSettings = cacheSettings; }
public ParticipationsSessionRepository( IParticipationRepository participationRepository, ICache cache, ICacheSettings settings, IReadTestRepository readTestRepository) { _participationRepository = participationRepository; _cache = cache; _settings = settings; _readTestRepository = readTestRepository; }
public MockTypedBuilderSettings( IMockFormatter formatter, ICacheSettings cacheSettings, IEnumerable<ITypedHandler> handlers, IEnumerable<ITypedResponseValidator> responseValidators) : base(formatter, cacheSettings, handlers, responseValidators) { _formatter = formatter; }
public TResult UpdateCachedData <T1, T2, TResult>(ICacheSettings settings, Func <T1, T2, TResult> method, TResult data, T1 arg1, T2 arg2, params Object[] args) { return(this.UpdateCachedData_Proxy( settings, method.Method.DeclaringType.GetFriendlyTypeName(), method.Method.Name, ((Object[] argv) => (method.Invoke(arg1, arg2))), data, arg1, arg2, args)); }
public TResult UpdateCachedData <T1, T2, T3, T4, T5, T6, T7, T8, TResult>(ICacheSettings settings, Func <T1, T2, T3, T4, T5, T6, T7, T8, TResult> method, TResult data, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, params Object[] args) { return(this.UpdateCachedData_Proxy( settings, method.Method.DeclaringType.GetFriendlyTypeName(), method.Method.Name, ((Object[] argv) => (method.Invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8))), data, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, args)); }
public HttpCacheConfigurationHandler(ICacheSettings settings, ICacheManager cacheManager, IEnumerable <IHttpCacheHandler> handlers) : base(settings, cacheManager) { if (handlers != null) { foreach (var handler in handlers) { Settings.HandlerRegister.WithHandler(handler); } } }
public BaseOperationManager(string transactionId = null) { DataOperation = SetDataOperation(); TransactionId = transactionId; Mapper = SetMapper(); CacheSettings = SetCacheSettings(); if (IsCacheActive()) { CacheManager = CacheSettings.CacheManager; } }
/// <summary> /// Initializes a new instance of the <see cref="CacheSection{TValue}"/> class. /// </summary> /// <param name="sectionName">Section name.</param> /// <param name="memoryCache">Provided memory cache.</param> /// <param name="configureCacheEntry">External configure function.</param> /// <param name="settings">Cache settings.</param> public CacheSection( [NotNull] string sectionName, [NotNull] IMemoryCache memoryCache, Action <ICacheEntryContext>?configureCacheEntry = null, ICacheSettings <TValue>?settings = null) { sectionName.AssertArgumentNotNull(nameof(sectionName)); _cacheSectionDescriptor = new CacheSectionDescriptor <TValue>(sectionName, settings ?? CacheSettings <TValue> .Default); _memoryCache = memoryCache.AssertArgumentNotNull(nameof(memoryCache)); _configureCacheEntry = configureCacheEntry; }
public BasketOrchestrator(IMediator mediator, ICookieManager cookieManager, IBasketViewModelMapper basketViewModelMapper, ICacheStorageService cacheService, ICacheSettings cacheSettings, IFatConfigurationSettings config) { _mediator = mediator; _cookieManager = cookieManager; _basketViewModelMapper = basketViewModelMapper; _cacheService = cacheService; _cacheSettings = cacheSettings; _config = config; }
public HttpBuilderSettings(ICacheSettings cacheSettings, IEnumerable <IHttpHandler> handlers, IEnumerable <IHttpResponseValidator> responseValidators) : this() { CacheSettings = cacheSettings; ResponseValidator = new ResponseValidatorCollection(responseValidators); if (handlers != null) { foreach (var handler in handlers) { HandlerRegister.WithHandler(handler); } } }
// Overload /// <exclude /> public static CachingSettings GetNamedCaching(string name) { ICacheSettings cacheSettings = Caching.Caches.FirstOrDefault(f => f.Name == name); bool enabled = Caching.Enabled; int size = CachingSettings.DefaultCacheSize; if ((enabled) && (cacheSettings != null)) { enabled = cacheSettings.Enabled && cacheSettings.Size != CachingSettings.NoCacheSize; size = cacheSettings.Size; } CachingSettings cachingSettings = new CachingSettings(enabled, size); return(cachingSettings); }
public TypedBuilderSettings( IFormatter formatter, ICacheSettings cacheSettings, IEnumerable <ITypedHandler> handlers, IEnumerable <ITypedResponseValidator> responseValidators) : this() { Formatter = formatter; ResponseValidator = new ResponseValidatorCollection(responseValidators); CacheSettings = cacheSettings; if (handlers != null) { foreach (var handler in handlers) { HandlerRegister.WithHandler(handler); } } }
public TrainingProviderOrchestrator( IMediator mediator, ISearchResultsViewModelMapper searchResultsViewModelMapper, ILog logger, ITrainingProviderDetailsViewModelMapper trainingProviderDetailsViewModelMapper, ITrainingProviderSearchFilterViewModelMapper trainingProviderSearchFilterViewModelMapper, ICacheStorageService cacheService, ICacheSettings cacheSettings, ITrainingProviderClosestLocationsViewModelMapper trainingProviderClosestLocationsViewModelMapper) { _mediator = mediator; _searchResultsViewModelMapper = searchResultsViewModelMapper; _logger = logger; _trainingProviderDetailsViewModelMapper = trainingProviderDetailsViewModelMapper; _trainingProviderSearchFilterViewModelMapper = trainingProviderSearchFilterViewModelMapper; _cacheService = cacheService; _cacheSettings = cacheSettings; _trainingProviderClosestLocationsViewModelMapper = trainingProviderClosestLocationsViewModelMapper; }
// NOTE: This section looks horrible - it is, but it's how .Net natively supports Function and Action classes - up to 16 generic parameters. // Maybe one day we won't need these. private static TResult GetCachedData_Proxy <TResult>(ICacheSettings settings, String methodType, String methodName, MethodDelegate <TResult> @delegate, params Object[] args) { // Default cache settings settings = settings ?? CacheUtils.UnderlyingProvider.DefaultSettings; #region Build CacheKey String cacheKey = settings.CacheKeyOverride; if (String.IsNullOrWhiteSpace(cacheKey)) { cacheKey = CacheUtils.UnderlyingProvider.BuildCacheKey(String.Format("{0}.{1}", methodType, methodName), args); } #endregion settings.CacheKeyOverride = cacheKey; return(CacheUtils.UnderlyingProvider.GetCachedData <TResult>(settings, @delegate, args)); }
public HaloSession(IProduct product, IHaloSharpTimer timer, ICacheSettings cacheSettings = null, IObjectCache cache = null) { Cache.MetadataCacheDuration = cacheSettings?.MetadataCacheDuration; Cache.ProfileCacheDuration = cacheSettings?.ProfileCacheDuration; Cache.StatsCacheDuration = cacheSettings?.StatsCacheDuration; Cache.ObjectCache = cache; if (product.RateLimit != null) { _rateGate = new RateGate(product.RateLimit, timer); } var handler = new HttpClientHandler { AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate }; _httpClient = new HttpClient(handler); _httpClient.DefaultRequestHeaders.Add(HeaderName, product.SubscriptionKey); }
public async Task <string> ReadText(string fileName) { var result = string.Empty; _cacheSettings = _cacheSettingsFactory.GetCacheSettings(CacheTypes.FileSystem, fileName); if (_cacheSettings.IsEnabled) { result = await _cacheManager.Get <string>(_cacheSettings.KeyPrefix); } if (result == null) { result = await _fileService.ReadText(fileName); if (_cacheSettings.IsEnabled) { await _cacheManager.Set(_cacheSettings.KeyPrefix, result.ToString()); } } return(result); }
public void DeleteCachedData <TResult>(ICacheSettings settings, MethodDelegate <TResult> @delegate, params Object[] args) { // TODO: Support Locking Here // Default cache settings if (settings == null) { settings = this.DefaultSettings; } #region Build CacheKey String cacheKey = settings.CacheKeyOverride; if (String.IsNullOrWhiteSpace(cacheKey)) { cacheKey = this.BuildCacheKey(@delegate, args); } #endregion this._cache.Remove(cacheKey); }
// NOTE: This section looks horrible - it is, but it's how .Net natively supports Function and Action classes - up to 16 generic parameters. // Maybe one day we won't need these. private void DeleteCachedData_Proxy <TResult>(ICacheSettings settings, String methodType, String methodName, MethodDelegate <TResult> @delegate, params Object[] args) { // Default cache settings if (settings == null) { settings = this.DefaultSettings; } #region Build CacheKey String cacheKey = settings.CacheKeyOverride; if (String.IsNullOrWhiteSpace(cacheKey)) { cacheKey = this.BuildCacheKey(String.Format("{0}.{1}", methodType, methodName), args); } #endregion settings.CacheKeyOverride = cacheKey; this.DeleteCachedData <TResult>(settings, @delegate, args); }
public static TResult GetCachedData <TResult>(this ICacheProvider cacheProvider, ICacheSettings settings, Func <TResult> method, params Object[] args) { return(cacheProvider.GetCachedData_Proxy( settings, method.Method.DeclaringType.GetFriendlyTypeName(), method.Method.Name, ((Object[] argv) => (method.Invoke())), args)); }
public void UpdateCacheSettingsParameter(ICacheSettings cacheType) { cacheType.Environment.ConfigSet.LastUpdate = DateTime.UtcNow; Repository.SaveChanges(); }
public TResult GetCachedData <TResult>(ICacheSettings settings, MethodDelegate <TResult> @delegate, params Object[] args) { // Default cache settings if (settings == null) { settings = this.DefaultSettings; } #region Build CacheKey String cacheKey = settings.CacheKeyOverride; Boolean inLock = false; if (String.IsNullOrWhiteSpace(cacheKey)) { cacheKey = this.BuildCacheKey(@delegate, args); } #endregion // Add tracking key immediately // No point only adding it on success, because if there's an error, we don't want to cache the error state, so the dependency SHOULD fail this.AddTracking(cacheKey); #region Non Locking Cache Retrieval // Load data from cache Object buffer = this._cache.Get(cacheKey); #if CACHENULLS if (buffer == TrackingCacheProvider.NULL_OBJECT) { return(default(TResult)); } #endif if (buffer is TResult) { return((TResult)buffer); } #endregion #region Locking Cache Retrieval if (buffer == null && ConfigurationManager.AppSettings["Dolkens.Framework.Caching.Lock"].ToBoolean(true)) { if (this._lockTable[cacheKey] == null) { // Only process a single thread for a particular cacheKey at a time lock (this._lockTable) { if (this._lockTable[cacheKey] == null) { this._lockTable[cacheKey] = this._lockTable[cacheKey] ?? new Object(); } } } inLock = Monitor.TryEnter(this._lockTable[cacheKey], settings.LockTimeout); buffer = this._cache.Get(cacheKey); if (buffer == TrackingCacheProvider.NULL_OBJECT) { if (inLock) { Monitor.Exit(this._lockTable[cacheKey]); } return(default(TResult)); } if (buffer is TResult) { if (inLock) { Monitor.Exit(this._lockTable[cacheKey]); } return((TResult)buffer); } } #endregion #region Retrieve Fresh Data if (buffer == null) { // Swap in a clean tracking list IEnumerable <String> trackingList = this.SwapTracking(null); try { buffer = @delegate(args); } catch (Exception ex) { // Release the lock if (inLock) { Monitor.Exit(this._lockTable[cacheKey]); } // Bubble exception throw ex; } finally { // Return tracking list to normal trackingList = this.SwapTracking(trackingList); } #region Cache Storage #if !CACHENULLS // Early exit for empty result // TODO: Consider adding option to cache NULL data here if (buffer == null) { return(buffer = null); } #endif #region Ensure we have a dependency and that we have a cachekey collection to add to settings.Dependencies = settings.Dependencies ?? this.DefaultDependency; settings.Dependencies.CacheKeys = settings.Dependencies.CacheKeys ?? new String[] { }; #endregion settings.Dependencies.CacheKeys = settings.Dependencies.CacheKeys.Union(trackingList).Distinct().ToArray(); CacheItem cacheItem = null; #if CACHENULLS if (buffer == null) { cacheItem = new CacheItem(cacheKey, TrackingCacheProvider.NULL_OBJECT, "CacheUtils"); } else #endif cacheItem = new CacheItem(cacheKey, buffer, "CacheUtils"); // Save Data To Cache this._cache.Add(cacheItem, settings.GetCacheItemPolicy()); #endregion } #endregion // Release the lock if (inLock) { Monitor.Exit(this._lockTable[cacheKey]); } return((TResult)buffer); }
public InMemoryCacheRepository(ICacheSettings cacheSettings) : base(cacheSettings) { }
protected virtual ITypedBuilderSettings GetSettings(IFormatter formatter, IList <ITypedHandler> handlers, ICacheSettings cacheSettings, IEnumerable <ITypedResponseValidator> validators) { var settings = new TypedBuilderSettings(formatter, cacheSettings, handlers, validators); return(settings); }
protected virtual IList <ITypedHandler> GetHandlers(ICacheSettings cacheSettings, IEnumerable <ITypedCacheHandler> handlers) { return(new ITypedHandler[] { new TypedCacheConfigurationHandler(cacheSettings, Cache.Current, handlers) }); }
public static TResult GetCachedData <T1, T2, T3, T4, T5, T6, TResult>(this ICacheProvider cacheProvider, ICacheSettings settings, Func <T1, T2, T3, T4, T5, T6, TResult> method, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, params Object[] args) { return(cacheProvider.GetCachedData_Proxy( settings, method.Method.DeclaringType.GetFriendlyTypeName(), method.Method.Name, ((Object[] argv) => (method.Invoke(arg1, arg2, arg3, arg4, arg5, arg6))), arg1, arg2, arg3, arg4, arg5, arg6, args)); }
public static void DeleteCachedData <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(this ICacheProvider cacheProvider, ICacheSettings settings, Func <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> method, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, params Object[] args) { cacheProvider.DeleteCachedData_Proxy( settings, method.Method.DeclaringType.GetFriendlyTypeName(), method.Method.Name, ((Object[] argv) => (method.Invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10))), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, args); }
public static void DeleteCachedData <T1, T2, T3, TResult>(this ICacheProvider cacheProvider, ICacheSettings settings, Func <T1, T2, T3, TResult> method, T1 arg1, T2 arg2, T3 arg3, params Object[] args) { cacheProvider.DeleteCachedData_Proxy( settings, method.Method.DeclaringType.GetFriendlyTypeName(), method.Method.Name, ((Object[] argv) => (method.Invoke(arg1, arg2, arg3))), arg1, arg2, arg3, args); }
// NOTE: This section looks horrible - it is, but it's how .Net natively supports Function and Action classes - up to 16 generic parameters. // Maybe one day we won't need these. private static void DeleteCachedData_Proxy <TResult>(this ICacheProvider cacheProvider, ICacheSettings settings, String methodType, String methodName, MethodDelegate <TResult> @delegate, params Object[] args) { // Default cache settings settings = settings ?? cacheProvider.DefaultSettings; #region Build CacheKey String cacheKey = settings.CacheKeyOverride; if (String.IsNullOrWhiteSpace(cacheKey)) { cacheKey = cacheProvider.BuildCacheKey(String.Format("{0}.{1}", methodType, methodName), args); } #endregion settings.CacheKeyOverride = cacheKey; cacheProvider.DeleteCachedData <TResult>(settings, @delegate, args); }
public ApplicationCache(ICacheSettings settings) { m_settings = settings; }
public void DeleteCachedData <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(ICacheSettings settings, Func <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> method, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16, params Object[] args) { this.DeleteCachedData_Proxy( settings, method.Method.DeclaringType.GetFriendlyTypeName(), method.Method.Name, ((Object[] argv) => (method.Invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16))), arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, args); }
public static TResult UpdateCachedData <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(this ICacheProvider cacheProvider, ICacheSettings settings, Func <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> method, TResult data, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16, params Object[] args) { return(cacheProvider.UpdateCachedData_Proxy( settings, method.Method.DeclaringType.GetFriendlyTypeName(), method.Method.Name, ((Object[] argv) => (method.Invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16))), data, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, args)); }