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;
}
