/// <summary>
/// Initializes a new instance of the <see cref="T:FH.Cache.Redis.DefaultRedisCachingProvider"/> class.
/// </summary>
/// <param name="name">Name.</param>
/// <param name="dbProviders">Db providers.</param>
/// <param name="serializer">Serializer.</param>
/// <param name="options">Options.</param>
/// <param name="loggerFactory">Logger factory.</param>
public DefaultRedisCachingProvider(
string name,
IEnumerable <IRedisDatabaseProvider> dbProviders,
ICachingSerializer serializer,
RedisOptions options,
ILoggerFactory loggerFactory = null)
{
ArgumentCheck.NotNullAndCountGTZero(dbProviders, nameof(dbProviders));
ArgumentCheck.NotNull(serializer, nameof(serializer));
this._dbProvider = dbProviders.Single(x => x.DBProviderName.Equals(name));
this._serializer = serializer;
this._options = options;
this._logger = loggerFactory?.CreateLogger <DefaultRedisCachingProvider>();
this._cache = _dbProvider.GetDatabase();
this._servers = _dbProvider.GetServerList();
this._cacheStats = new CacheStats();
this._name = name;
this.ProviderName = this._name;
this.ProviderStats = this._cacheStats;
this.ProviderType = _options.CachingProviderType;
this.ProviderOrder = _options.Order;
this.ProviderMaxRdSecond = _options.MaxRdSecond;
this.IsDistributedProvider = true;
}
public DefaultRedisCachingProvider(string name, IEnumerable <IRedisDatabaseProvider> dbProviders, ICachingSerializer serializer)
{
ProviderName = name;
_dbProvider = dbProviders.FirstOrDefault(x => x.DbProviderName.Equals(name));
_serializer = serializer;
_cache = _dbProvider.GetDatabase();
_servers = _dbProvider.GetServerList();
}
/// <summary>
/// Deserializes the byte array into an instance of T
/// </summary>
/// <param name="serializer">Serializer</param>
/// <param name="bytes">The data to deserialize</param>
/// <typeparam name="T">The type to instantiate</typeparam>
/// <returns>The deserialized object</returns>
public static T Deserialize <T>(this ICachingSerializer serializer, byte[] bytes)
{
if (serializer == null)
{
throw new ArgumentNullException(nameof(serializer));
}
return((T)serializer.Deserialize(typeof(T), bytes));
}
/// <summary>
/// Initializes a new instance of the <see cref="T:EasyCaching.Redis.DefaultRedisCachingProvider"/> class.
/// </summary>
/// <param name="dbProviders">Db providers.</param>
/// <param name="serializers">Serializers.</param>
/// <param name="cacheOptions">CacheOptions.</param>
/// <param name="loggerFactory">Logger factory.</param>
public DefaultRedisProvider(
IRedisDatabaseProvider dbProviders,
IEnumerable <ICachingSerializer> serializers,
CacheOptions cacheOptions,
ILoggerFactory loggerFactory = null)
{
ArgumentCheck.NotNull(dbProviders, nameof(dbProviders));
//this.ProviderName = nameof(DefaultRedisProvider);
this._dbProvider = dbProviders;
this._serializer = !string.IsNullOrWhiteSpace(cacheOptions.SerializerName)
? serializers.Single(x => x.Name.Equals(cacheOptions.SerializerName))
: serializers.Single(x => x.Name.Equals(CachingConstValue.DefaultSerializerName));
this._cacheOptions = cacheOptions;
this._logger = loggerFactory?.CreateLogger <DefaultRedisProvider>();
this._redisDb = _dbProvider.GetDatabase();
this._servers = _dbProvider.GetServerList();
this._cacheStats = new CacheStats();
}
internal RedisCache(IRedisCacheProvider redisCacheProvider, ICachingSerializer serializer, string name) : base(name)
{
_database = redisCacheProvider.GetDatabase();
_serializer = serializer;
}
public DefaultRedisFeatureProvider(string name, IEnumerable <IRedisDatabaseProvider> dbProviders, ICachingSerializer serializer)
{
ProviderName = name;
_dbProvider = dbProviders.FirstOrDefault(x => x.DbProviderName.Equals(name));
_serializer = serializer;
}
public CachingService(IDistributedCache cache, ICachingSerializer serializer)
{
_cache = cache;
_serializer = serializer;
}
