public IActionResult SetString([FromBody] CacheEntry entry)
{
var db = _redisDatabaseProvider.GetDatabase();
db.StringSet(entry.Key, entry.Value);
return(Ok());
}
/// <summary>
/// Initializes a new instance of the <see cref="T:EasyCaching.Redis.DefaultRedisCachingProvider"/> class.
/// </summary>
/// <param name="dbProvider">Db provider.</param>
/// <param name="serializer">Serializer.</param>
/// <param name="options">Options.</param>
/// <param name="loggerFactory">Logger factory.</param>
public DefaultRedisCachingProvider(
IRedisDatabaseProvider dbProvider,
IEasyCachingSerializer serializer,
IOptionsMonitor <RedisOptions> options,
ILoggerFactory loggerFactory = null)
{
ArgumentCheck.NotNull(dbProvider, nameof(dbProvider));
ArgumentCheck.NotNull(serializer, nameof(serializer));
this._dbProvider = dbProvider;
this._serializer = serializer;
this._options = options.CurrentValue;
this._logger = loggerFactory?.CreateLogger <DefaultRedisCachingProvider>();
this._cache = _dbProvider.GetDatabase();
this._servers = _dbProvider.GetServerList();
this._cacheStats = new CacheStats();
this._name = EasyCachingConstValue.DefaultRedisName;
this.ProviderName = this._name;
this.ProviderStats = this._cacheStats;
this.ProviderType = _options.CachingProviderType;
this.ProviderOrder = _options.Order;
this.ProviderMaxRdSecond = _options.MaxRdSecond;
this.IsDistributedProvider = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:EasyCaching.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,
IEasyCachingSerializer serializer,
IOptionsMonitor <RedisOptions> options,
ILoggerFactory loggerFactory = null)
{
ArgumentCheck.NotNullAndCountGTZero(dbProviders, nameof(dbProviders));
ArgumentCheck.NotNull(serializer, nameof(serializer));
this._dbProvider = dbProviders.FirstOrDefault(x => x.DBProviderName.Equals(name));
this._serializer = serializer;
this._options = options.CurrentValue;
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 ActionResult <List <Movie> > Get()
{
// Read all movie data from mongo
List <Movie> movies = _movies.Find(m => true).ToList();
// Add all movie data to redis
var db = _redisDatabaseProvider.GetDatabase();
foreach (Movie movie in movies)
{
db.StringSet(movie.Id.ToString(), 0, TimeSpan.FromMinutes(10));
}
// Return full list
return(movies);
}
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();
}
public RedisCacheProvider(IRedisDatabaseProvider dbProvider,
IOptions <RedisOptions> options)
{
_dbProvider = dbProvider;
_options = options.Value;
_cache = _dbProvider.GetDatabase();
_servers = _dbProvider.GetServerList();
}
public ActionResult <Rating> Get(string id)
{
var db = _redisDatabaseProvider.GetDatabase();
var value = db.StringGet("1");
return(new Models.Rating {
Key = id, Value = Double.Parse(value)
});
}
public CacheServiceBase(IRedisDatabaseProvider redisDatabaseProvider)
{
redisDatabaseProvider.ThrowIfNull(nameof(redisDatabaseProvider));
_redis = new Lazy <IRedisDatabase>(() =>
{
return(redisDatabaseProvider.GetDatabase());
});
}
public IActionResult IncrementEntry([FromBody] CacheEntry entry)
{
var db = _redisDatabaseProvider.GetDatabase();
var value = int.Parse(db.StringGet(entry.Key));
value = value + 1;
db.StringSet(entry.Key, value);
return(Ok());
}
/// <summary>
/// 初始化一个<see cref="DefaultRedisCacheProvider"/>类型的实例
/// </summary>
/// <param name="dbProvider">Redis 数据库提供程序</param>
/// <param name="serializer">缓存序列化器</param>
public DefaultRedisCacheProvider(IRedisDatabaseProvider dbProvider, ICacheSerializer serializer)
{
dbProvider.CheckNotNull(nameof(dbProvider));
serializer.CheckNotNull(nameof(serializer));
_dbProvider = dbProvider;
_serializer = serializer;
_database = _dbProvider.GetDatabase();
Client = new RedisClient(_dbProvider);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:EasyCaching.Redis.DefaultRedisCachingProvider"/> class.
/// </summary>
/// <param name="dbProvider">DB Provider.</param>
/// <param name="serializer">Serializer.</param>
public DefaultRedisCachingProvider(
IRedisDatabaseProvider dbProvider,
IEasyCachingSerializer serializer)
{
ArgumentCheck.NotNull(dbProvider, nameof(dbProvider));
ArgumentCheck.NotNull(serializer, nameof(serializer));
_dbProvider = dbProvider;
_serializer = serializer;
_cache = _dbProvider.GetDatabase();
}
public int GetStock(IRedisDatabaseProvider redisDatabaseProvider, int bookId)
{
// Get new score from redis and add to original score
var db = redisDatabaseProvider.GetDatabase();
var value = db.StringGet(bookId.ToString());
int currentStock = 0;
if (value != StackExchange.Redis.RedisValue.Null)
{
currentStock = (int)value;
}
return(currentStock);
}
/// <inheritdoc />
public IRedisDatabase GetDatabase(bool useCompression = false, int database = 0, object asyncState = null)
{
try
{
var db = _redisDatabaseProvider.GetDatabase(useCompression, database, asyncState);
return(new SilentRedisDatabase(db));
}
catch (Exception e)
{
Logger.LogErrorFormat(e, "Taking of the Redis database has been failed.");
return(new SilentRedisDatabase(null));
}
}
public RedisCacheProvider(
IRedisDatabaseProvider databaseProvider,
IOptions <RedisOptions> options,
IJsonSerializer serializer,
ILogger <RedisCacheProvider> logger
)
{
_serializer = serializer;
_cache = databaseProvider.GetDatabase();
_redisOptions = options.Value;
_servers = databaseProvider.GetServers();
_logger = logger;
_subscriber = databaseProvider.GetSubscriber();;
}
/// <summary>
/// 初始化一个<see cref="DefaultRedisCacheProvider"/>类型的实例
/// </summary>
/// <param name="dbProvider">Redis数据库提供程序</param>
/// <param name="serializer">缓存序列化器</param>
/// <param name="options">Redis选项</param>
/// <param name="log">日志</param>
public DefaultRedisCacheProvider(IRedisDatabaseProvider dbProvider, ICacheSerializer serializer,
IOptionsMonitor <RedisOptions> options, ILog log = null)
{
Check.NotNull(dbProvider, nameof(dbProvider));
Check.NotNull(serializer, nameof(serializer));
this._dbProvider = dbProvider;
this._serializer = serializer;
this._options = options.CurrentValue;
this._log = log ?? NullLog.Instance;
this._cache = _dbProvider.GetDatabase();
this._servers = _dbProvider.GetServerList();
this.CacheStatsInfo = new CacheStatsInfo();
}
/// <summary>
/// Initializes a new instance of the <see cref="T:EasyCaching.Redis.DefaultRedisCachingProvider"/> class.
/// </summary>
/// <param name="dbProvider">DB Provider.</param>
/// <param name="serializer">Serializer.</param>
public DefaultRedisCachingProvider(
IRedisDatabaseProvider dbProvider,
IEasyCachingSerializer serializer,
RedisOptions options)
{
ArgumentCheck.NotNull(dbProvider, nameof(dbProvider));
ArgumentCheck.NotNull(serializer, nameof(serializer));
this._dbProvider = dbProvider;
this._serializer = serializer;
this._options = options;
this._cache = _dbProvider.GetDatabase();
this._servers = _dbProvider.GetServerList();
}
/// <summary>
/// Initializes a new instance of the <see cref="T:EasyCaching.Redis.DefaultRedisCachingProvider"/> class.
/// </summary>
/// <param name="dbProvider">DB Provider.</param>
/// <param name="serializer">Serializer.</param>
public DefaultRedisCachingProvider(
IRedisDatabaseProvider dbProvider,
IEasyCachingSerializer serializer,
RedisOptions options,
ILoggerFactory loggerFactory = null)
{
ArgumentCheck.NotNull(dbProvider, nameof(dbProvider));
ArgumentCheck.NotNull(serializer, nameof(serializer));
this._dbProvider = dbProvider;
this._serializer = serializer;
this._options = options;
this._logger = loggerFactory?.CreateLogger <DefaultRedisCachingProvider>();
this._cache = _dbProvider.GetDatabase();
this._servers = _dbProvider.GetServerList();
}
/// <summary>
/// 初始化一个<see cref="DefaultRedisCacheProvider"/>类型的实例
/// </summary>
/// <param name="name">名称</param>
/// <param name="dbProviders">Redis数据库提供程序列表</param>
/// <param name="serializer">缓存序列化器</param>
/// <param name="options">Redis选项</param>
/// <param name="log">日志</param>
public DefaultRedisCacheProvider(string name, IEnumerable <IRedisDatabaseProvider> dbProviders, ICacheSerializer serializer,
IOptionsMonitor <RedisOptions> options, ILog log = null)
{
Check.NotNullOrEmpty(dbProviders, nameof(dbProviders));
Check.NotNull(serializer, nameof(serializer));
this._dbProvider = dbProviders.FirstOrDefault(x => x.DbProviderName.Equals(name));
this._serializer = serializer;
this._options = options.CurrentValue;
this._log = log ?? NullLog.Instance;
this._cache = _dbProvider.GetDatabase();
this._servers = _dbProvider.GetServerList();
this.CacheStatsInfo = new CacheStatsInfo();
this.Name = name;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:EasyCaching.Redis.DefaultRedisCachingProvider"/> class.
/// </summary>
/// <param name="name">Name.</param>
/// <param name="dbProviders">Db providers.</param>
/// <param name="serializers">Serializers.</param>
/// <param name="options">Options.</param>
/// <param name="loggerFactory">Logger factory.</param>
public DefaultRedisCachingProvider(
string name,
IEnumerable <IRedisDatabaseProvider> dbProviders,
IEnumerable <IEasyCachingSerializer> serializers,
RedisOptions options,
ILoggerFactory loggerFactory = null)
{
ArgumentCheck.NotNullAndCountGTZero(dbProviders, nameof(dbProviders));
ArgumentCheck.NotNullAndCountGTZero(serializers, nameof(serializers));
this._name = name;
this._dbProvider = dbProviders.Single(x => x.DBProviderName.Equals(name));
this._options = options;
if (options.EnableLogging)
{
this.Logger = loggerFactory.CreateLogger <DefaultRedisCachingProvider>();
}
this._cache = _dbProvider.GetDatabase();
this._servers = _dbProvider.GetServerList();
this._cacheStats = new CacheStats();
this._serializer = !string.IsNullOrWhiteSpace(options.SerializerName)
? serializers.Single(x => x.Name.Equals(options.SerializerName))
: serializers.FirstOrDefault(x => x.Name.Equals(_name)) ?? serializers.Single(x => x.Name.Equals(EasyCachingConstValue.DefaultSerializerName));
this.ProviderName = this._name;
this.ProviderType = CachingProviderType.Redis;
this.ProviderStats = this._cacheStats;
this.ProviderMaxRdSecond = _options.MaxRdSecond;
_info = new ProviderInfo
{
CacheStats = _cacheStats,
EnableLogging = options.EnableLogging,
LockMs = options.LockMs,
MaxRdSecond = options.MaxRdSecond,
ProviderName = ProviderName,
ProviderType = ProviderType,
SerializerName = options.SerializerName,
SleepMs = options.SleepMs,
Serializer = _serializer,
CacheNulls = options.CacheNulls
};
}
/// <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();
}
/// <summary>
/// 获取指定key的值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public T Get <T>(string key)
{
ArgumentCheck.NotNullOrWhiteSpace(key, nameof(key));
key = AddSysCustomKey(key);
var _db = _dbProvider.GetDatabase();
var rValue = _db.StringGet(key);
if (!rValue.HasValue)
{
return(default(T));
}
var result = Deserialize <T>(rValue);
return(result);
}
/// <summary>
/// Проверяет подключение к БД Redis, добавляет временный ключ и тут же удаляет его
/// </summary>
/// <returns>Результат диагностики</returns>
public Task <IEnumerable <DiagnosticInfo> > Diagnose()
{
try
{
var database = _provider.GetDatabase();
var temporaryKey = Guid.NewGuid()
.ToString();
var result = database.StringSet(temporaryKey, redisKey, isDiagnostic: true);
if (!result)
{
_logger.LogTrace("Diagnostic of redis provider has been failed, cannot set value to redis");
return(Task.FromResult(new[]
{
new DiagnosticInfo(redisKey, localhost, DiagnosticStatus.DbConnectionError, string.Empty,
"Cannot save value to redis database", true)
}.AsEnumerable()));
}
var deleteRes = database.KeyDelete(temporaryKey, isDiagnostic: true);
if (!deleteRes)
{
_logger.LogTrace("Diagnostic of redis provider has been failed, cannot delete value from redis");
return(Task.FromResult(new[]
{
new DiagnosticInfo(redisKey, localhost, DiagnosticStatus.DbConnectionError, string.Empty,
"Cannot delete value from redis database", true)
}.AsEnumerable()));
}
_logger.LogTrace("Redis provider has been diagnosed successfully");
return(Task.FromResult(new[] { new DiagnosticInfo(redisKey, localhost, isSkipResult: true) }.AsEnumerable()));
}
catch (Exception e)
{
_logger.LogTrace($"Diagnostic of redis provider has been failed with error: {e}");
return(Task.FromResult(new[]
{
new DiagnosticInfo(redisKey, localhost, DiagnosticStatus.DbConnectionError, string.Empty, e.ToString(), true)
}.AsEnumerable()));
}
}
public ICacheMap <TKey, TVal> GetMap <TKey, TVal>(string name)
{
return(new RedisCacheMap <TKey, TVal>(name, _databaseProvider.GetDatabase()));
}
/// <summary>
/// 初始化一个<see cref="RedisClient"/>类型的实例
/// </summary>
/// <param name="dbProvider">Redis 数据库提供程序</param>
public RedisClient(IRedisDatabaseProvider dbProvider)
{
dbProvider.CheckNotNull(nameof(dbProvider));
_dbProvider = dbProvider;
_database = _dbProvider.GetDatabase();
}
public CartController(IRedisDatabaseProvider redisDatabaseProvider)
{
this._redisDatabase = redisDatabaseProvider?.GetDatabase();
}
public ICache <TKey, TVal> GetCache <TKey, TVal>(CacheId <TKey, TVal> cacheId)
{
var database = _databaseProvider.GetDatabase();
return(new RedisCache <TKey, TVal>(database));
}