public CfgAppService(IMapper mapper
, IEfRepository <SysCfg> cfgRepository
, IHybridProviderFactory hybridProviderFactory)
{
_mapper = mapper;
_cfgRepository = cfgRepository;
_cache = hybridProviderFactory.GetHybridCachingProvider(EasyCachingConsts.HybridCaching);
}
public SSOAuthenticationMiddleware(RequestDelegate next
, IOptions <JWTConfig> jwtConfig
, IHybridProviderFactory hybridProviderFactory)
{
_next = next ?? throw new ArgumentNullException(nameof(next));
_cache = hybridProviderFactory.GetHybridCachingProvider(BaseEasyCachingConsts.HybridCaching) ?? throw new ArgumentNullException(nameof(_cache));
_jwtConfig = jwtConfig.Value;
}
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);
}
public MenuAppService(IMapper mapper,
IEfRepository <SysMenu> menuRepository,
IEfRepository <SysRelation> relationRepository,
IHybridProviderFactory hybridProviderFactory)
{
_mapper = mapper;
_menuRepository = menuRepository;
_relationRepository = relationRepository;
_cache = hybridProviderFactory.GetHybridCachingProvider(EasyCachingConsts.HybridCaching);
}
public DictAppService(IMapper mapper
, IEfRepository <SysDict> dictRepository
, IMaintManagerService maintManagerService
, IHybridProviderFactory hybridProviderFactory)
{
_mapper = mapper;
_dictRepository = dictRepository;
_maintManagerService = maintManagerService;
_cache = hybridProviderFactory.GetHybridCachingProvider(EasyCachingConsts.HybridCaching);
}
public CustomAuthenticationMiddleware(RequestDelegate next
, UserContext userContext
//, IDistributedCache cache
, IOptions <JWTConfig> jwtConfig
, IHybridProviderFactory hybridProviderFactory)
{
_next = next ?? throw new ArgumentNullException(nameof(next));
_currentUser = userContext ?? throw new ArgumentNullException(nameof(userContext));
//_cache = cache ?? throw new ArgumentNullException(nameof(cache));
_cache = hybridProviderFactory.GetHybridCachingProvider(BaseEasyCachingConsts.HybridCaching) ?? throw new ArgumentNullException(nameof(_cache));
_jwtConfig = jwtConfig.Value;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:EasyCaching.Interceptor.Castle.EasyCachingInterceptor"/> class.
/// </summary>
/// <param name="cacheProviderFactory">Cache provider factory.</param>
/// <param name="keyGenerator">Key generator.</param>
/// <param name="options">Options.</param>
/// <param name="logger">Logger.</param>
/// <param name="hybridCachingProvider">Hybrid caching provider.</param>
public EasyCachingInterceptor(
IEasyCachingProviderFactory cacheProviderFactory
, IEasyCachingKeyGenerator keyGenerator
, IOptions <EasyCachingInterceptorOptions> options
, ILogger <EasyCachingInterceptor> logger = null
, IHybridCachingProvider hybridCachingProvider = null)
{
_options = options;
_cacheProviderFactory = cacheProviderFactory;
_keyGenerator = keyGenerator;
_logger = logger;
_hybridCachingProvider = hybridCachingProvider;
}
public DeptAppService(IMapper mapper
, IHybridProviderFactory hybridProviderFactory
, IEasyCachingProviderFactory simpleProviderFactory
, IEfRepository <SysDept> deptRepository
, ISystemManagerService systemManagerService)
{
_mapper = mapper;
_cache = hybridProviderFactory.GetHybridCachingProvider(EasyCachingConsts.HybridCaching);
_locaCahce = simpleProviderFactory.GetCachingProvider(EasyCachingConsts.LocalCaching);
_redisCache = simpleProviderFactory.GetCachingProvider(EasyCachingConsts.RemoteCaching);
_deptRepository = deptRepository;
_systemManagerService = systemManagerService;
}
public RoleAppService(IMapper mapper,
IEfRepository <SysRole> roleRepository,
IEfRepository <SysUser> userRepository,
IEfRepository <SysRelation> relationRepository,
IUsrManagerService systemManagerService,
IHybridProviderFactory hybridProviderFactory)
{
_mapper = mapper;
_roleRepository = roleRepository;
_userRepository = userRepository;
_systemManagerService = systemManagerService;
_relationRepository = relationRepository;
_cache = hybridProviderFactory.GetHybridCachingProvider(EasyCachingConsts.HybridCaching);
}
public OcelotEasyCachingCache(
IOptions <OcelotEasyCachingOptions> optionsAccs,
IEasyCachingProviderFactory providerFactory,
IHybridProviderFactory hybridFactory = null)
{
_options = optionsAccs.Value;
if (!_options.EnableHybrid)
{
_provider = providerFactory.GetCachingProvider(_options.ProviderName);
}
else
{
_hybridProvider = hybridFactory.GetHybridCachingProvider(_options.HybridName);
}
}
public HybridCachingTest()
{
_namespace = "hybrid";
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>();
}
public HybridEasyCaching(IHybridCachingProvider hybridCachingProvider, IOptions <HybridEasyCachingOptions> options)
: base(options?.Value ?? throw new ArgumentNullException(nameof(options)))
{
_hybridCachingProvider = hybridCachingProvider;
}
public ValuesController(IHybridProviderFactory hybridFactory)
{
this._hybrid = hybridFactory.GetHybridCachingProvider("h1");
}
public CacheService(IHybridCachingProvider hybridCachingProvider)
{
_hybridCachingProvider = hybridCachingProvider;
}
public ValuesController(IHybridCachingProvider hybrid)
{
this._hybrid = hybrid;
}
public ValuesController(IHybridCachingProvider provider)
{
this._provider = provider;
}
public IChibaCacheManager(
IHybridCachingProvider hybridProvider)
{
HybridProvider = hybridProvider;
}
