public CacheHelper(string name,
ICacheProviderFactory cpf,
IDistributedLockFactory factory,
IKeyFormatter formatter,
IValueSerializer serializer,
RecyclableMemoryStreamManager manager,
IOptionsMonitor <CacheOptions> options,
int defaultTTl)
{
if (cpf == null)
{
throw new ArgumentNullException(nameof(cpf));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
_factory = factory ?? throw new ArgumentNullException(nameof(factory));
_formatter = formatter;
_manager = manager;
_options = options.CurrentValue;
_defaultTTl = defaultTTl < 1 ? _options.DefaultTtl : defaultTTl;
_provider = cpf.Create($"{_options.KeyPrefix}/Cache/{_name = name}");
_serializer = _options.CompressValue ? new CompressionSerializer(serializer, manager) : serializer;
}
/// <summary>
/// 重置默认缓存组件
/// </summary>
public static void Reset()
{
lock (lockObj)
{
_factory = null;
}
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="factory">依赖解析器创建工厂</param>
public static void InitializeWith(ICacheProviderFactory factory)
{
Check.Argument.IsNotNull(factory, "factory");
cacheProvier = factory.CreateInstance();
CacheItems = new Dictionary <string, CacheItemStatus>();
}
public Int64CacheProxy(object any,
ICacheProviderFactory cpf,
IDistributedLockFactory factory,
IKeyFormatter formatter,
IValueSerializer serializer,
RecyclableMemoryStreamManager manager,
IOptionsMonitor <CacheOptions> options)
: base(any) =>
public DefaultStoreProviderFactory(IClientRequestRepository repository,
ICacheProviderFactory cacheProviderFactory,
ILoggerFactory loggerFactory,
IOptions <FXZOptions> options)
{
_reposity = repository;
_options = options?.Value;
_cacheProvider = cacheProviderFactory.CreateProvider(_options.CacheMode);
_loggerFactory = loggerFactory;
_logger = _loggerFactory.CreateLogger <DefaultStoreProviderFactory>();
}
public CreateProxyOptions(ICacheProviderFactory cacheProviderFactory,
IDistributedLockFactory distributedLockFactory,
IKeyFormatter keyFormatter,
IValueSerializer valueSerializer,
RecyclableMemoryStreamManager streamManager,
CacheOptions options)
{
CacheProviderFactory = cacheProviderFactory;
DistributedLockFactory = distributedLockFactory;
KeyFormatter = keyFormatter;
ValueSerializer = valueSerializer;
StreamManager = streamManager;
Options = options;
}
public void SetUp()
{
_mockLocalMemoryProvider = new Mock <ICacheProvider>();
_mockProviderSettingsConfig = new Mock <IProviderSettingsConfig>();
_mockCacheProviderInstanceFactory = new Mock <ICacheProviderInstanceFactory>();
_mockProviderSettingsConfig.Setup(e => e.GetProviders()).Returns(new[] { _providerSettings });
_mockRedisCacheProvider = new Mock <ICacheProvider>();
_mockRedisCacheProvider.Setup(e => e.Retrieve <string>(It.IsAny <string>())).Returns("isWorking");
_mockCacheProviderInstanceFactory.Setup(e => e.Create(CacheProvider.Redis, ServerSettings)).Returns(_mockRedisCacheProvider.Object);
_mockLocalMemoryProvider.Setup(e => e.Exists(ActiveCacheProviderKeyName)).Returns(true);
_mockLocalMemoryProvider.Setup(e => e.Retrieve <ICacheProvider>(ActiveCacheProviderKeyName)).Returns(_mockRedisCacheProvider.Object);
_cacheProviderFactory = new CacheProviderFactory(_mockLocalMemoryProvider.Object,
_mockProviderSettingsConfig.Object,
_mockCacheProviderInstanceFactory.Object);
}
static CacheManager()
{
ICacheProviderFactory fac = DI.DIBootstrapper.Container.Resolve <ICacheProviderFactory>();
CacheProvider = fac == null ? new MemoryCacheProvider() : fac.GetCacheProvider();
}
/// <summary>
/// 设置默认的缓存提供器工厂实例
/// </summary>
/// <param name="factory">缓存提供器工厂实例</param>
public void SetDefaultCacheProviderFactory(ICacheProviderFactory factory)
{
_factory = factory;
}
public DefaultCacheProvider(ICacheProviderFactory cacheProviderFactory)
{
_cacheProviderFactory = cacheProviderFactory;
}
private void WhenCreateCacheProvider()
{
_cacheProviderFactory = new DefaultCacheProviderFactory(_mockMemoryCache.Object, _mockLoggerFactory.Object);
}
internal CacheClient(ICacheProviderFactory cacheProviderFactory)
{
_cacheProviderFactory = cacheProviderFactory;
_cacheProvider = _cacheProviderFactory.Create();
}
protected CacheProviderTest(ICacheProviderFactory factory, bool supportMultipleKey)
{
_factory = factory;
_supportMultipleKey = supportMultipleKey;
}
public void SetUp()
{
_cacheProviderFactory = new CacheProviderFactory();
}
