/// <summary> /// Initializes a new instance of the <see cref="T:EasyCaching.HybridCache.HybridCachingProvider"/> class. /// </summary> /// <param name="name">Name.</param> /// <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( string name , HybridCachingOptions optionsAccs , IEasyCachingProviderFactory factory , IEasyCachingBus bus = null , ILoggerFactory loggerFactory = null ) { ArgumentCheck.NotNull(factory, nameof(factory)); this._name = name; this._options = optionsAccs; ArgumentCheck.NotNullOrWhiteSpace(_options.TopicName, nameof(_options.TopicName)); if (optionsAccs.EnableLogging) { this._logger = loggerFactory.CreateLogger <HybridCachingProvider>(); } // Here use the order to distinguish traditional provider this._localCache = factory.GetCachingProvider(_options.LocalCacheProviderName); // Here use the order to distinguish traditional provider this._distributedCache = factory.GetCachingProvider(_options.DistributedCacheProviderName); this._bus = bus ?? NullEasyCachingBus.Instance; this._bus.Subscribe(_options.TopicName, OnMessage); this._cacheId = Guid.NewGuid().ToString("N"); }
public HybridCachingTest() { _namespace = "hybrid"; var options = new HybridCachingOptions { EnableLogging = false, TopicName = "test_topic", LocalCacheProviderName = "m1", DistributedCacheProviderName = "myredis", BusRetryCount = 1, DefaultExpirationForTtlFailed = 60 }; IServiceCollection services = new ServiceCollection(); services.AddEasyCaching(option => { option.UseInMemory("m1"); option.UseInMemory("m2"); option.UseRedis(config => { config.DBConfig.Endpoints.Add(new Core.Configurations.ServerEndPoint("127.0.0.1", 6379)); config.DBConfig.Database = 5; }, "myredis"); option.UseHybrid(config => { config.EnableLogging = false; config.TopicName = "test_topic"; config.LocalCacheProviderName = "m1"; config.DistributedCacheProviderName = "myredis"; }); option.WithRedisBus(config => { config.Endpoints.Add(new Core.Configurations.ServerEndPoint("127.0.0.1", 6379)); config.Database = 6; }); }); IServiceProvider serviceProvider = services.BuildServiceProvider(); factory = serviceProvider.GetService <IEasyCachingProviderFactory>(); var bus = serviceProvider.GetService <IEasyCachingBus>(); hybridCaching_1 = serviceProvider.GetService <IHybridCachingProvider>(); fakeBus = A.Fake <IEasyCachingBus>(); fakeFactory = A.Fake <IEasyCachingProviderFactory>(); fakeDisProvider = A.Fake <FakeDistributedCachingProvider>(); var myOptions = Options.Create(options); FakeCreatProvider(); fakeHybrid = new HybridCachingProvider("h1", myOptions.Value, fakeFactory, fakeBus); }
/// <summary> /// Initializes a new instance of the <see cref="T:EasyCaching.HybridCache.HybridCachingProvider"/> class. /// </summary> /// <param name="optionsAccs">Options accs.</param> /// <param name="IEasyCachingProviderFactory">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"); }
/// <summary> /// Initializes a new instance of the <see cref="T:EasyCaching.HybridCache.HybridCachingProvider"/> class. /// </summary> /// <param name="optionsAccs">Options accs.</param> /// <param name="providers">Providers.</param> /// <param name="bus">Bus.</param> /// <param name="loggerFactory">Logger factory.</param> public HybridCachingProvider( IOptions <HybridCachingOptions> optionsAccs , IEnumerable <IEasyCachingProvider> providers , IEasyCachingBus bus = null , ILoggerFactory loggerFactory = null ) { ArgumentCheck.NotNullAndCountGTZero(providers, nameof(providers)); 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 = providers.OrderBy(x => x.Order).FirstOrDefault(x => !x.IsDistributedCache); if (local == null) { throw new NotFoundCachingProviderException("Can not found any local caching providers."); } else { this._localCache = local; } //Here use the order to distinguish traditional provider var distributed = providers.OrderBy(x => x.Order).FirstOrDefault(x => x.IsDistributedCache); if (distributed == null) { 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"); }
/// <summary> /// Initializes a new instance of the <see cref="T:EasyCaching.HybridCache.HybridCachingProvider"/> class. /// </summary> /// <param name="name">Name.</param> /// <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( string name , HybridCachingOptions optionsAccs , IEasyCachingProviderFactory factory , IEasyCachingBus bus = null , ILoggerFactory loggerFactory = null ) { ArgumentCheck.NotNull(factory, nameof(factory)); this._name = name; this._options = optionsAccs; 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); }