public CachingService( IRepository <T> repository, IEasyCachingProvider provider) { _repository = repository; _provider = provider; }
/// <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 OrderController(ApplicationDbContext context, IHttpClientFactory clientFactory, IEasyCachingProviderFactory cachingProviderFactory) { this.context = context; this.clientFactory = clientFactory; this.cachingProviderFactory = cachingProviderFactory; cachingProvider = this.cachingProviderFactory.GetCachingProvider("redis-db"); }
public RedisCachingProviderWithFactoryTest() { IServiceCollection services = new ServiceCollection(); services.AddDefaultRedisCacheWithFactory(EasyCachingConstValue.DefaultRedisName, options => { options.DBConfig = new RedisDBOptions { AllowAdmin = true }; options.DBConfig.Endpoints.Add(new ServerEndPoint("127.0.0.1", 6379)); options.DBConfig.Database = 3; }); services.AddDefaultRedisCacheWithFactory(SECOND_PROVIDER_NAME, options => { options.DBConfig = new RedisDBOptions { AllowAdmin = true }; options.DBConfig.Endpoints.Add(new ServerEndPoint("127.0.0.1", 6379)); options.DBConfig.Database = 4; }); IServiceProvider serviceProvider = services.BuildServiceProvider(); var factory = serviceProvider.GetService <IEasyCachingProviderFactory>(); _provider = factory.GetCachingProvider(EasyCachingConstValue.DefaultRedisName); _secondProvider = factory.GetCachingProvider(SECOND_PROVIDER_NAME); _defaultTs = TimeSpan.FromSeconds(30); }
/// <summary> /// Initializes a new instance of the <see cref="T:EasyCaching.ResponseCaching.EasyCachingResponseCache"/> class. /// </summary> /// <param name="provider">Provider.</param> public EasyCachingResponseCache( IEasyCachingProvider provider) { ArgumentCheck.NotNull(provider, nameof(provider)); _provider = provider; }
public CacheService(IItemService itemService, IUserService userService, IEasyCachingProviderFactory cachingProviderFactory) { _itemService = itemService; _userService = userService; this.cachingProviderFactory = cachingProviderFactory; this.cachingProvider = this.cachingProviderFactory.GetCachingProvider("redisCache"); }
/// <summary> /// Initializes a new instance of the <see cref="T:EasyCaching.HybridCache.HybridCachingProvider"/> class. /// </summary> /// <param name="serviceAccessor">Service accessor.</param> public HybridCachingProvider(Func <string, IEasyCachingProvider> serviceAccessor) { _serviceAccessor = serviceAccessor; this._localCachingProvider = _serviceAccessor(HybridCachingKeyType.LocalKey); this._distributedCachingProvider = _serviceAccessor(HybridCachingKeyType.DistributedKey); }
public UnAuthorizeCommand(AppConfig appConfig, LiteDatabaseAsync liteDb, IEasyCachingProvider easyCachingProvider, AuthService authService) { _appConfig = appConfig; _easyCachingProvider = easyCachingProvider; _authService = authService; _liteDb = liteDb; }
/// <summary> /// Initializes a new instance of the <see cref="T:EasyCaching.ResponseCaching.EasyCachingResponseCache"/> class. /// </summary> /// <param name="name">Provider Name</param> /// <param name="providerFactory">Provider factory</param> public EasyCachingResponseCache(string name, IEasyCachingProviderFactory providerFactory) { ArgumentCheck.NotNull(providerFactory, nameof(providerFactory)); _provider = providerFactory.GetCachingProvider(name); }
public I18NController(ApplicationDbContext context, IEasyCachingProvider provider, IOptions <BaiduTranslateProfile> profile, ApplicationDBInitializer dBInitializer) { this._cachingprovider = provider; this._context = context; this._profile = profile; _dBInitializer = dBInitializer; }
public ProviderFactoryTests() { IServiceCollection services = new ServiceCollection(); services.AddEasyCaching(option => { option.UseRedis(config => { config.DBConfig = new RedisDBOptions { AllowAdmin = true }; config.DBConfig.Endpoints.Add(new ServerEndPoint("127.0.0.1", 6380)); config.DBConfig.Database = 12; }, "redis"); option.UseInMemory(config => { }, "inMemory"); }); IServiceProvider serviceProvider = services.BuildServiceProvider(); var factory = serviceProvider.GetService <IEasyCachingProviderFactory>(); _e1 = factory.GetCachingProvider("redis"); _e2 = factory.GetCachingProvider("inMemory"); }
public MenuAppService(IEfRepository <SysMenu> menuRepository, IEfRepository <SysRelation> relationRepository, IEasyCachingProviderFactory cacheFactory) { _menuRepository = menuRepository; _relationRepository = relationRepository; _cache = cacheFactory.GetCachingProvider(EasyCachingConsts.RemoteCaching); }
protected virtual IEasyCachingProvider CreateDecoratedProvider(IEasyCachingProvider fallbackProvider) => CreateFakeProvider(options => { options.ProviderFactory = CreateProvider; options.DecorateWithFallback( (_, __) => fallbackProvider, exception => exception is InvalidOperationException); });
public AliyunOSSService(OssClient client , IEasyCachingProvider provider , OSSOptions options) { this._client = client ?? throw new ArgumentNullException(nameof(OssClient)); this._cache = provider ?? throw new ArgumentNullException(nameof(IEasyCachingProvider)); this.Options = options ?? throw new ArgumentNullException(nameof(OSSOptions)); }
public CheckHisotryService(ILoggerFactory loggerFactory , IEasyCachingProviderFactory factory) { _logger = loggerFactory.CreateLogger <CheckHisotryService>(); _factory = factory; _memoryProvider = _factory.GetCachingProvider(EasyCachingConstValue.DefaultInMemoryName); _redisProvider = _factory.GetCachingProvider(EasyCachingConstValue.DefaultCSRedisName); }
public DeptAppService(IEasyCachingProviderFactory cacheFactory , IEfRepository <SysDept> deptRepository , UsrManager usrManager) { _cache = cacheFactory.GetCachingProvider(EasyCachingConsts.RemoteCaching); _deptRepository = deptRepository; _usrManager = usrManager; }
public OSSServiceFactory(IOptionsMonitor <OSSOptions> optionsMonitor , IEasyCachingProvider provider , ILoggerFactory logger) { this.optionsMonitor = optionsMonitor ?? throw new ArgumentNullException(); this._cacheProvider = provider ?? throw new ArgumentNullException(nameof(IEasyCachingProvider)); this.logger = logger ?? throw new ArgumentNullException(nameof(ILoggerFactory)); }
public static IEasyCachingProvider CreateDecoratedProviderWithBrokenCircuit( Func <IEasyCachingProvider> providerFactory, IEasyCachingProvider fallbackProvider) { var provider = CreateDecoratedProvider(providerFactory, fallbackProvider); provider.Get <string>("CacheKey"); return(provider); }
public DictAppService(IEfRepository <SysDict> dictRepository , MaintManager maintManager , IEasyCachingProviderFactory cacheFactory) { _dictRepository = dictRepository; _maintManager = maintManager; _cache = cacheFactory.GetCachingProvider(EasyCachingConsts.RemoteCaching); }
public NacosServerManager( INacosNamingClient client, IEasyCachingProviderFactory factory, IOptions <NacosAspNetCoreOptions> optionsAccs) { _client = client; _provider = factory.GetCachingProvider("nacos.aspnetcore"); }
public QCloudOSSService(CosXml client , IEasyCachingProvider provider , OSSOptions options) { this._client = client ?? throw new ArgumentNullException(nameof(CosXml)); this._cache = provider ?? throw new ArgumentNullException(nameof(IEasyCachingProvider)); this.Options = options ?? throw new ArgumentNullException(nameof(OSSOptions)); }
public RecipeDetailsRepository(IEasyCachingProviderFactory cachingProviderFactory, IMediator mediator, IRecipeDetailsMapper recipeDetailsMapper, IFilterFactory <RecipeDetails, RecipeSearchFilterCriteria> filterFactory) { _mediator = mediator; _recipeDetailsMapper = recipeDetailsMapper; _filterFactory = filterFactory; _cachingProvider = cachingProviderFactory.GetCachingProvider(RedisConstants.Name); }
public CachingService( IRepository <T> repository, IEasyCachingProvider provider, IOptions <CachingOption> options) { _repository = repository; _provider = provider; _cachingOption = options.Value; }
public void DeleteUser(Guid userId, IEasyCachingProvider _easyCaching) { try { _easyCaching.Remove(userId.ToString()); } catch { } }
public DistributedEasyCaching(IEasyCachingProviderFactory easyCachingProviderFactory, IOptions <DistributedEasyCachingOptions> options) : base(options?.Value ?? throw new ArgumentNullException(nameof(options))) { if (easyCachingProviderFactory == null) { throw new ArgumentNullException(nameof(easyCachingProviderFactory)); } _easyCachingProvider = easyCachingProviderFactory.GetCachingProvider(options.Value.ProviderName); }
public CheckDevices(ILogger <CheckDevices> logger, IServiceScopeFactory scopeFactor, IMqttServerEx serverEx , IOptions <AppSettings> options, IEasyCachingProviderFactory factory) { _mcsetting = options.Value.MqttClient; _logger = logger; _scopeFactor = scopeFactor; _factory = factory; _serverEx = serverEx; _device = _factory.GetCachingProvider("iotsharp"); }
public AccountService(IUserRepository userRepository, IEasyCachingProvider cachingProvider, IOptionsSnapshot <JwtOption> jwtOptionAccessor) { var option = jwtOptionAccessor.Get(JwtAuthenticationSchemeConstants.DefaultAuthenticationScheme); _userRepository = userRepository; _cachingProvider = cachingProvider; _jwtFactory = new JwtFactory(option); }
public AuthorizeCommand( LiteDatabaseAsync liteDb, IEasyCachingProvider easyCachingProvider, AuthService authService ) { _easyCachingProvider = easyCachingProvider; _authService = authService; _liteDb = liteDb; }
/// <summary> /// Using IMemoryCache as a cache service. /// </summary> public EFEasyCachingCoreProvider( IOptions <EFCoreSecondLevelCacheSettings> cacheSettings, IEasyCachingProviderFactory easyCachingProviderFactory, IReaderWriterLockProvider readerWriterLockProvider) { _cacheSettings = cacheSettings?.Value; _readerWriterLockProvider = readerWriterLockProvider; _easyCachingProviderFactory = easyCachingProviderFactory ?? throw new ArgumentNullException("Please register the `EasyCaching.Core`."); _easyCachingProvider = _easyCachingProviderFactory.GetCachingProvider(_cacheSettings.ProviderName); }
public Login(DatabaseContext databaseContext, TokenService tokenService, IEasyCachingProvider cachingProvider, FinApiService finApiService, CachingService cachingService) { _databaseContext = databaseContext; _tokenService = tokenService; _cachingProvider = cachingProvider; _finApiService = finApiService; _cachingService = cachingService; }