/// <summary>
/// 加入当前对象到缓存中
/// </summary>
/// <param name="key">对象的键值</param>
/// <param name="value">缓存的对象</param>
/// <param name="expire">到期时间,单位:秒</param>
public static bool AddObject <T>(string key, T value, int expire = 0, IRedisClient redis = null, bool isClose = true)
{
try
{
if (redis == null)
{
redis = GetClient();
}
bool addResult = false;
if (expire > 0)
{
addResult = redis.Add <T>(key, value, DateTime.Now.AddSeconds(expire));
}
else
{
addResult = redis.Add <T>(key, value);
}
if (isClose)
{
Close(redis);
}
return(addResult);
}
catch (Exception ex)
{
logger.Error("AddObject:" + key + value, ex);
return(false);
}
}
public void Upsert(IEnumerable <StockDetail> stockDetails)
{
_redisClient.RemoveAll(stockDetails.Select(x => x.Id));
foreach (var stockDetail in stockDetails)
{
_redisClient.Add(stockDetail.Id, stockDetail);
}
}
protected bool AddSingleDataByKey <TData>(string cacheKey, TData entity, DateTime expiredDate) where TData : BaseModel
{
string methotName = MethodBase.GetCurrentMethod().GetMethodName();
try
{
client = GetRedisClient();
var data = GetCachedData <TData>(cacheKey).ToList();
if (data.Any())
{
data.Add(entity);
client.Remove(cacheKey);
client.Add(cacheKey, data, expiredDate);
return(true);
}
return(false);
}
catch (RedisException ex)
{
throw new KnownException(ErrorTypeEnum.CacheConnectExeption, methotName, ex);;
}
catch (Exception ex)
{
throw new KnownException(ErrorTypeEnum.CahceGeneralException, methotName, ex);
}
}
//public static RedisClient rc = new RedisClient(RedisServerIP, RedisServerPort);
public bool AddCache <T>(string key, T value)
{
using (IRedisClient redis = prcm.GetClient())
{
return(redis.Add(key, value));
}
}
/// <summary>
/// key集合中添加value值
/// </summary>
public void Add <T>(string key, T value)
{
using (IRedisClient Core = CreateRedisClient())
{
Core.Add <T>(key, value);
}
}
/// <summary>
/// 添加缓存项
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="expiration"></param>
/// <returns></returns>
public bool AddCache <T>(string key, T value, DateTime expireTime)
{
using (IRedisClient redisClient = RedisProvider.prcm.GetClient())
{
return(redisClient.Add(key, value, expireTime));
}
}
public void Add(string key, object data, int cacheTime = 60)
{
if (data != null && _connection.IsConnected)
{
_redisClient.Add <object>(key, data, DateTime.Now.AddMinutes(cacheTime));
}
}
public void Add(string key, object o, DateTimeOffset expiration, string dependsOnKey = null)
{
lock (MyRedisClient)
{
MyRedisClient.Add(key, o, expiration.DateTime);
}
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="t"></param>
/// <param name="timeout"></param>
/// <returns></returns>
public bool Add <T>(string key, T t, int timeout)
{
using (_redis = GetClient())
{
lock (AccessLock)
{
if (timeout > 0)
{
return(_redis.Add(ConvertKey(key), t, new TimeSpan(0, 0, 0, timeout)));
}
else
{
return(_redis.Add <T>(ConvertKey(key), t));
}
}
}
}
public static void Test1()
{
var keys = redis.GetAllKeys();
foreach (var key in keys)
{
Trace.WriteLine(string.Format("Key:{0}", key));
}
var value = redis.Get <string>("name");
redis.Add("expiresKey", "125", new TimeSpan(0, 0, 2));
var data = new ComplexData
{
Names = Enumerable.Range(10, 50).Select(c => c.ToString()).ToList(),
Nums = Enumerable.Range(100, 200).ToList(),
fNums = Enumerable.Range(500, 700).Select(c => float.Parse(c.ToString())).ToList(),
dNums = Enumerable.Range(500, 700).Select(c => double.Parse(c.ToString())).ToList()
};
var min = DateTime.MinValue;
var max = DateTime.MaxValue;
redis.Add("ComplexData", data);
Task.Factory.StartNew(() =>
{
Thread.Sleep(5000);
if (redis.ContainsKey("expiresKey"))
{
var vl = redis.Get <string>("expiresKey");
Trace.WriteLine(vl);
}
else
{
Trace.WriteLine("no expiresKey Key in redis");
}
});
var allKeys = redis.GetAllKeys();
}
/// <summary>
/// 添加
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public static async Task Add(string key, string value)
{
try
{
await Task.FromResult(redisClient.Add(key, value));
}
catch (Exception e)
{
throw new Exception("添加数据异常，错误为 ：" + e.Message);
}
}
private void AddItem(string key, string value)
{
if (!_client.Add(key, value))
{
Console.WriteLine(value);
}
else
{
Console.WriteLine("写入" + value);
}
}
/// <summary>
/// 仅在缓存为空时在指定的缓存密钥中添加一个新项到缓存中。
/// </summary>
/// <typeparam name="T">添加的值的数据类型。</typeparam>
/// <param name="key">键。</param>
/// <param name="value">值。</param>
/// <returns></returns>
public bool Add <T>(string key, T value, int index = 0)
{
bool result;
using (IRedisClient client = base.pooledRedisClientManager.GetClient())
{
client.Db = index;
result = client.Add <T>(key, value);
}
return(result);
}
public bool Add <T>(string key, T val, TimeSpan expiresIn)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
return(FClient.Add(GetKey(key), new Entry <T> {
Data = val, ExpiresIn = expiresIn
}, expiresIn));
}
// GET: Movies
public async Task <IActionResult> Index()
{
var movies = _redis.GetById <IEnumerable <Movie> >("all_movies");
if (movies == null)
{
movies = await _context.Movie.ToListAsync();
_redis.Add("all_movies", movies);
}
return(View(movies));
}
public void AddValueToRedis <T>(string key, T t, TimeSpan?timeSpan)
{
try
{
using (IRedisClient client = RedisManager.GetRedisWriteClient())
{
if (timeSpan.HasValue)
{
client.Add <T>(key, t, timeSpan.Value);
}
else
{
client.Add <T>(key, t);
}
}
}
catch (Exception ex)
{
LogHelper.WriteLog <T>(this.GetType(), "AddValueToRedis 键：" + key + "", "鲍晨", t, ex);
}
}
public TUser CreateOrUpdate(TUser user, string userId = null)
{
var baseKey = RedisKey.Build(Keys.AspNetUsers);
//insert
if (string.IsNullOrEmpty(userId))
{
user.Id = db.IncrementValue(baseKey).ToString();
var uniqueId = string.Format("{0}:{1}", user.UserName, user.Id);
db.Add <TUser>(RedisKey.Build(Keys.AspNetUsers, id: uniqueId), user);
}
else
{
//update
user.Id = userId;
var NewUser = (TUser)Activator.CreateInstance(typeof(TUser));
NewUser.Id = user.Id;
NewUser.Email = user.Email;
NewUser.NormalizedUserName = user.NormalizedUserName;
NewUser.PasswordHash = user.PasswordHash;
NewUser.SecurityStamp = user.SecurityStamp;
NewUser.UserName = user.UserName;
//logins
for (int i = 0; i < user.Logins.Count; i++)
{
UserLoginInfo info = new UserLoginInfo(user.Logins[i].LoginProvider, user.Logins[i].ProviderKey, user.Logins[i].ProviderDisplayName);
NewUser.Logins.Add(info);
}
//roles
for (int i = 0; i < user.Roles.Count; i++)
{
NewUser.Roles.Add((user.Roles[i]));
}
//claim
for (int i = 0; i < user.Claims.Count; i++)
{
NewUser.Claims.Add((user.Claims[i]));
}
var uniqueId = string.Format("{0}:{1}", NewUser.UserName, NewUser.Id);
db.Set <TUser>(RedisKey.Build(Keys.AspNetUsers, id: uniqueId), NewUser);
}
//Add UserLogin Key-Value
foreach (var login in user.Logins)
{
db.Set(RedisKey.Build(Keys.UserLoginInfo, entity: login), user.Id);
}
return(user);
}
/// <summary>
/// 添加缓存，并设置过期时间
/// </summary>
/// <param name="key">关键字</param>
/// <param name="value">值</param>
/// <param name="expiredTime">过期时间</param>
/// 创建者：单琪彬
/// 创建日期：7/15/2014 10:19 AM
/// 修改者：
/// 修改时间：
/// ----------------------------------------------------------------------------------------
/// <exception cref="System.NotImplementedException"></exception>
public void Add(string key, object value, System.DateTime expiredTime)
{
using (IRedisClient Redis = RedisManager.GetClient())
{
if (Redis.ContainsKey(key))
{
Redis.Set <byte[]>(key, new ObjectSerializer().Serialize(value), expiredTime);
}
else
{
Redis.Add <byte[]>(key, new ObjectSerializer().Serialize(value), expiredTime);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public static void Add(string key, object value)
{
using (IRedisClient rdc = _prcm.GetClient())
{
if (!rdc.ContainsKey(key))
{
rdc.Add(key, value, DateTime.Now.AddMinutes(30));
}
else
{
rdc.Set(key, value);
}
}
}
public TUser CreateOrUpdate(TUser user, string userId = null)
{
var baseKey = RedisKey.Build(Keys.AspNetUsers);
if (string.IsNullOrEmpty(userId))
{
user.Id = db.IncrementValue(baseKey).ToString();
}
else
{
user.Id = userId;
}
var uniqueId = string.Format("{0}:{1}", user.UserName, user.Id);
db.Add <TUser>(RedisKey.Build(Keys.AspNetUsers, id: uniqueId), user);
//Add UserLogin Key-Value
foreach (var login in user.Logins)
{
db.Add(RedisKey.Build(Keys.UserLoginInfo, entity: login), user.Id);
}
return(user);
}
public bool AddCache <T>(string key, T value, DateTime exp)
{
try
{
using (IRedisClient redis = prcm.GetClient())
{
return(redis.Add(key, value));
}
}
catch (System.Exception ex)
{
ExceptionHelper.AddException(ex);
return(false);
}
}
public void Add(string key, object o, DateTimeOffset expiration, string dependsOnKey = null)
{
// Don't store the dependsOnKey because we store it as a list later!
if (Equals(o, ""))
{
return;
}
var expireTime = expiration.Subtract(DateTimeOffset.Now);
var primaryAdded = _client.Add(key, o, expireTime);
if (dependsOnKey != null && primaryAdded)
{
_client.AddItemToList(dependsOnKey, key);
}
}
/// <summary>
/// 向redis中添加一条数据
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="key">键</param>
/// <param name="t">对象</param>
/// <param name="expireTime">过期时间</param>
public void AddValueToRedis <T>(string key, T t, DateTime?expireTime)
{
try
{
using (IRedisClient client = RedisManager.GetRedisWriteClient())
{
client.Add <T>(key, t);
if (expireTime.HasValue)
{
client.ExpireEntryAt(key, expireTime.Value);
}
}
}
catch (Exception ex)
{
LogHelper.WriteLog <T>(this.GetType(), "AddValueToRedis;键：" + key + "", "鲍晨", t, ex);
}
}
private void ConnectToSentinel(string conx)
{
try
{
txbOutput.Text = "Start Sentinel : " + DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fff") + Environment.NewLine;
var pooledCon = localRedisManager;
//txbOutput.Text += "Sentinel Master = " + client. + Environment.NewLine;
txbOutput.Text += "Start Sentinel Done : " + DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fff") + Environment.NewLine;
Dictionary <string, string> stats = (pooledCon as PooledRedisClientManager).GetStats();
//txbOutput.Text += "Pooled Connections stats : " + + Environment.NewLine;
using (IRedisClient client = pooledCon.GetClient())
{
txbOutput.Text += "Use Main/Write Connection : " + DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fff") + Environment.NewLine;
txbOutput.Text += "Start Write : " + DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fff") + Environment.NewLine;
client.Set <string>("Food", textBox1.Text, DateTime.UtcNow.AddSeconds(21600));
client.Add <string>("Food_Add", textBox1.Text, DateTime.UtcNow.AddSeconds(21600));
txbOutput.Text += "Setting Food=" + textBox1.Text + Environment.NewLine;
}
using (IRedisClient client = pooledCon.GetReadOnlyClient())
{
txbOutput.Text += "Use Read Only Connection : " + DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fff") + Environment.NewLine;
txbOutput.Text += "Getting Food" + Environment.NewLine;
txbOutput.Text += client.Get <string>("Food") + Environment.NewLine;
}
txbOutput.Text += "End Write : " + DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fff") + Environment.NewLine;
}
catch (Exception ex)
{
throw ex;
}
}
public void AddToRedis <T>(string key, IEnumerable <T> value)
{
redis.Add(key, value.ToList());
}
private IRedisClient redisClient = new RedisClient("127.0.0.1", 6379, null);//redis服务IP和端口
public void AddCache(string key, object value)
{
redisClient.Add(key, value);
}
public static bool Set <T>(string key, T value)
{
return(client.Add(key, value));
}
