/// <summary> /// Initializes a new instance of the <see cref="T:EasyCaching.HybridCache.HybridCachingProvider"/> class. /// </summary> /// <param name="optionsAccs">Options accs.</param> /// <param name="factory">Providers factory</param> /// <param name="bus">Bus.</param> /// <param name="loggerFactory">Logger factory.</param> public HybridCachingProvider( IOptions <HybridCachingOptions> optionsAccs , IEasyCachingProviderFactory factory , IEasyCachingBus bus = null , ILoggerFactory loggerFactory = null ) { ArgumentCheck.NotNull(factory, nameof(factory)); this._options = optionsAccs.Value; ArgumentCheck.NotNullOrWhiteSpace(_options.TopicName, nameof(_options.TopicName)); this._logger = loggerFactory?.CreateLogger <HybridCachingProvider>(); // Here use the order to distinguish traditional provider var local = factory.GetCachingProvider(_options.LocalCacheProviderName); if (local.IsDistributedCache) { throw new NotFoundCachingProviderException("Can not found any local caching providers."); } else { this._localCache = local; } // Here use the order to distinguish traditional provider var distributed = factory.GetCachingProvider(_options.DistributedCacheProviderName); if (!distributed.IsDistributedCache) { throw new NotFoundCachingProviderException("Can not found any distributed caching providers."); } else { this._distributedCache = distributed; } this._bus = bus ?? NullEasyCachingBus.Instance; this._bus.Subscribe(_options.TopicName, OnMessage); this._cacheId = Guid.NewGuid().ToString("N"); // policy retryAsyncPolicy = Policy.Handle <Exception>() .WaitAndRetryAsync(this._options.BusRetryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt - 1))); retryPolicy = Policy.Handle <Exception>() .WaitAndRetry(this._options.BusRetryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt - 1))); fallbackPolicy = Policy.Handle <Exception>().Fallback(() => { }); fallbackAsyncPolicy = Policy.Handle <Exception>().FallbackAsync(ct => { return(Task.CompletedTask); }); _busSyncWrap = Policy.Wrap(fallbackPolicy, retryPolicy); _busAsyncWrap = Policy.WrapAsync(fallbackAsyncPolicy, retryAsyncPolicy); }
public void NotNull_Should_Not_Throw_ArgumentNullException_When_Argument_Is_Not_Null(object obj) { var ex = Record.Exception(() => ArgumentCheck.NotNull(obj, "name")); Assert.Null(ex); }
public void NotNull_Should_Throw_ArgumentNullException_When_Argument_Is_Null() { Assert.Throws <ArgumentNullException>(() => ArgumentCheck.NotNull(null, "name")); }
/// <summary> /// Uses the easy caching response caching. /// </summary> /// <returns>The easy caching response caching.</returns> /// <param name="app">App.</param> public static IApplicationBuilder UseEasyCachingResponseCaching(this IApplicationBuilder app) { ArgumentCheck.NotNull(app, nameof(app)); return(app.UseMiddleware <EasyCachingResponseCachingMiddleware>()); }