protected void LoadDifferentKeyTypes(IRedisClient redis)
{
int A = 'A';
int Z = 'Z';
var letters = (Z - A + 1).Times(i => ((char)(i + A)).ToString());
var numbers = new[] { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
redis.RemoveEntry("list:letters", "list:numbers"); //don't add duplicates to existing list
letters.Each(x => redis.AddItemToList("list:letters", x));
numbers.Each(x => redis.AddItemToList("list:numbers", x));
letters.Each(x => redis.AddItemToSet("set:letters", x));
numbers.Each(x => redis.AddItemToSet("set:numbers", x));
var pos = 0;
letters.Each(x => redis.AddItemToSortedSet("zset:letters", x, pos++));
pos = 0;
numbers.Each(x => redis.AddItemToSortedSet("zset:numbers", x, pos++));
pos = 0;
letters.Each(x => redis.SetEntryInHash("hash:letters", x, (pos++).ToString()));
pos = 0;
numbers.Each(x => redis.SetEntryInHash("hash:numbers", x, (pos++).ToString()));
}
/// <summary>
/// 添加key/value
/// </summary>
public void Add(string key, string value)
{
using (IRedisClient Core = CreateRedisClient())
{
Core.AddItemToList(key, value);
}
}
public static void AddItemToList(string key, string val)
{
using (IRedisClient con = RedisManage.ClientManager.GetClient())
{
con.AddItemToList(key, val);
}
}
/// <summary>
/// 向list类型数据添加成员，向列表底部(右侧)添加
/// </summary>
/// <param name="item"></param>
/// <param name="list"></param>
public static void AddItemToListRight(string list, string item)
{
using (IRedisClient redis = PooleClient.GetClient())
{
redis.AddItemToList(list, item);
}
}
/// <summary>
/// 添加指定的值到有序列表中
/// </summary>
/// <param name="listId"></param>
/// <param name="value"></param>
public void AddItemToList(string listId, string value)
{
using (IRedisClient client = redisPool.GetClient())
{
client.AddItemToList(listId, value);
}
}
public void AddList(string listId, object value, DateTime expiredTime)
{
using (IRedisClient Redis = RedisManager.GetClient())
{
if (Redis.ContainsKey(listId))
{
Redis.AddItemToList(listId, value.Serialize());
Redis.ExpireEntryAt(listId, expiredTime);
}
else
{
Redis.AddItemToList(listId, value.Serialize());
Redis.ExpireEntryAt(listId, expiredTime);
}
}
}
public Task AddObjectTypeAsync(string ObjectType)
{
using (IRedisClient redis = clientsManager.GetClient())
{
redis.AddItemToList(NCORE_OBJECTS, ObjectType);
}
return(Task.CompletedTask);
}
/// <summary>
/// 向list类型数据添加成员，向列表底部(右侧)添加
/// </summary>
/// <param name="item"></param>
/// <param name="setId"></param>
public static void AddItemToListRight(string setId, string item)
{
using (IRedisClient redis = PooleClient.GetClient())
{
redis.RemoveItemFromList(setId, item);
redis.AddItemToList(setId, item);
}
}
/// <summary>
/// 添加key/value ,并设置过期时间
/// </summary>
public void Add(string key, string value, DateTime dt)
{
using (IRedisClient Core = CreateRedisClient())
{
Core.AddItemToList(key, value);
Core.ExpireEntryAt(key, dt);
}
}
/// <summary>
/// 新增一个集合
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="t"></param>
public static void List_AddJson <T>(string key, T t)
{
using (IRedisClient redis = prcm.GetClient())
{
string value = ServiceStack.Text.JsonSerializer.SerializeToString <T>(t);
redis.AddItemToList(key, value);
}
}
public Task AddTopicAsync(string Topic)
{
using (IRedisClient redis = clientsManager.GetClient())
{
redis.AddItemToList(NCORE_TOPICS, Topic);
}
return(Task.CompletedTask);
}
/// <summary>
/// 添加key/value。并添加过期时间
/// </summary>
public void Add(string key, string value, TimeSpan sp)
{
using (IRedisClient Core = CreateRedisClient())
{
Core.AddItemToList(key, value);
Core.ExpireEntryIn(key, sp);
}
}
/// <summary>
/// 列表追加
/// </summary>
/// <param name="listId">列表Id</param>
/// <param name="value"></param>
public static bool AddItemToList(string listId, string value)
{
using (IRedisClient redis = RedisManager.GetClient())
{
redis.AddItemToList(listId, value);
redis.Dispose();
}
return(true);
}
///// <summary>
/////使某个字段增加
///// </summary>
///// <param name="key"></param>
///// <param name="field"></param>
///// <returns></returns>
//public static void SetHashIncr(string key, string field, long incre)
//{
// redisCli.IncrementValueInHash(key, field, incre);
//}
/// <summary>
/// 向list类型数据添加成员，向列表底部(右侧)添加
/// </summary>
/// <param name="Item"></param>
/// <param name="list"></param>
public void AddItemToListRight(string list, string item)
{
try
{
_redisCli.AddItemToList(list, item);
}
catch
{
}
}
public void CheckItemInList(string listId, int count)
{
lock (Redis)
{
for (int i = Redis.GetListCount(listId) - 1; i < count; i++)
{
Redis.AddItemToList(listId, "");
}
}
}
private IEnumerable<string> PushToQueues(IRedisClient client, long nextMsgId)
{
var key = Topic + "." + QUEUES;
var queues = client.GetAllItemsFromSet(key).ToList();
foreach (var queue in queues)
{
//First add to the queue itself
client.AddItemToList(queue, nextMsgId.ToString());
}
return queues;
}
public override void RPush <T>(string listId, T value, DateTime?expireTime)
{
using (IRedisClient redis = GetRedisClient())
{
var strValue = JsonConvert.SerializeObject(value, JsonSetting);
redis.AddItemToList(listId, strValue);
if (expireTime != null && expireTime.Value > DateTime.Now)
{
redis.ExpireEntryAt(listId, expireTime.Value);
}
}
}
public void UpdateHistoryMessage(string name, string message)
{
if (!string.IsNullOrWhiteSpace(message) && !string.IsNullOrWhiteSpace(name))
{
string date = DateTime.Now.ToString();
HistoryMessage history = new HistoryMessage()
{
Name = name,
Message = message,
MsgTime = date
};
string result = JsonConvert.SerializeObject(history, Formatting.Indented);
client.AddItemToList("HistoryMessage", result);
}
}
public static bool AddItemToList(string listid, string value)
{
try
{
using (IRedisClient client = GetClient())
{
client.AddItemToList(listid, value);
}
return true;
}
catch (Exception)
{
return false;
}
}
public void PutArtifact(ArtifactInfo info, System.IO.Stream stream)
{
var jss = new JsonSerializer <ArtifactObject>();
long ctr = client.IncrementValue(fileNameCounterKey);
string fileName = filePrefix + "/" + ctr + ".artifact";
client.AddItemToList(artifactListKey, jss.Serialize(info));
using (var fs = File.Create(fileName))
{
stream.CopyTo(fs);
}
}
protected void LoadDifferentKeyTypes(IRedisClient redis)
{
int A = 'A';
int Z = 'Z';
var letters = (Z - A + 1).Times(i => ((char)(i + A)).ToString());
var numbers = new[] { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
redis.RemoveEntry("list:letters", "list:numbers"); //don't add duplicates to existing list
letters.Each(x => redis.AddItemToList("list:letters", x));
numbers.Each(x => redis.AddItemToList("list:numbers", x));
letters.Each(x => redis.AddItemToSet("set:letters", x));
numbers.Each(x => redis.AddItemToSet("set:numbers", x));
var pos = 0;
letters.Each(x => redis.AddItemToSortedSet("zset:letters", x, pos++));
pos = 0;
numbers.Each(x => redis.AddItemToSortedSet("zset:numbers", x, pos++));
pos = 0;
letters.Each(x => redis.SetEntryInHash("hash:letters", x, (pos++).ToString()));
pos = 0;
numbers.Each(x => redis.SetEntryInHash("hash:numbers", x, (pos++).ToString()));
}
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);
}
}
private static void UseClient(IRedisClient client, int clientNo)
{
var host = "";
try
{
host = client.Host;
Debug.WriteLine(string.Format("Client '{0}' is using '{1}'", clientNo, client.Host));
var differentDbs = new[] { 1, 0, 2 };
foreach (var db in differentDbs)
{
client.Db = db;
var testClientKey = "test:" + host + ":" + clientNo;
client.SetValue(testClientKey, testData);
var result = client.GetValue(testClientKey) ?? "";
LogResult(db, testClientKey, result);
var testClientSetKey = "test+set:" + host + ":" + clientNo;
client.AddItemToSet(testClientSetKey, testData);
var resultSet = client.GetAllItemsFromSet(testClientSetKey);
LogResult(db, testClientKey, resultSet.ToList().FirstOrDefault());
var testClientListKey = "test+list:" + host + ":" + clientNo;
client.AddItemToList(testClientListKey, testData);
var resultList = client.GetAllItemsFromList(testClientListKey);
LogResult(db, testClientKey, resultList.FirstOrDefault());
}
}
catch (NullReferenceException ex)
{
Debug.WriteLine("NullReferenceException StackTrace: \n" + ex.StackTrace);
Assert.Fail("NullReferenceException");
}
catch (Exception ex)
{
Debug.WriteLine(string.Format("\t[ERROR@{0}]: {1} => {2}",
host, ex.GetType().Name, ex));
Assert.Fail("Exception");
}
}
private void addMessageToRedis(string chatRoomName, string username, string messageDate, string message)
{
lock (redisManagerPool)
{
using (IRedisClient redisClient = redisManagerPool.GetClient())
{
MessageModel messageModel = new MessageModel()
{
Username = username,
MessageDate = messageDate,
Message = message
};
string jsonMessageModel = JsonConvert.SerializeObject(messageModel);
redisClient.AddItemToList(chatRoomName, jsonMessageModel);
}
}
}
protected void LoadDifferentKeyTypes(IRedisClient client)
{
var items = new List <string> {
"one", "two", "three", "four"
};
var map = new Dictionary <string, string> {
{ "A", "one" },
{ "B", "two" },
{ "C", "three" },
{ "D", "four" },
};
items.ForEach(x => client.Set("urn:testkeytypes:string:" + x, x));
items.ForEach(x => client.AddItemToList("urn:testkeytypes:list", x));
items.ForEach(x => client.AddItemToSet("urn:testkeytypes:set", x));
var i = 0;
items.ForEach(x => client.AddItemToSortedSet("urn:testkeytypes:zset", x, i++));
client.SetRangeInHash("urn:testkeytypes:hash", map);
}
private static void UseClient(IRedisClient client, int clientNo)
{
var host = "";
try
{
host = client.Host;
Debug.WriteLine(String.Format("Client '{0}' is using '{1}'", clientNo, client.Host));
var differentDbs = new[] { 1, 0, 2 };
foreach (var db in differentDbs)
{
client.Db = db;
var testClientKey = "test:" + host + ":" + clientNo;
client.SetEntry(testClientKey, testData);
var result = client.GetValue(testClientKey) ?? "";
LogResult(db, testClientKey, result);
var testClientSetKey = "test+set:" + host + ":" + clientNo;
client.AddItemToSet(testClientSetKey, testData);
var resultSet = client.GetAllItemsFromSet(testClientSetKey);
LogResult(db, testClientKey, resultSet.ToList().FirstOrDefault());
var testClientListKey = "test+list:" + host + ":" + clientNo;
client.AddItemToList(testClientListKey, testData);
var resultList = client.GetAllItemsFromList(testClientListKey);
LogResult(db, testClientKey, resultList.FirstOrDefault());
}
}
catch (NullReferenceException ex)
{
Debug.WriteLine("NullReferenceException StackTrace: \n" + ex.StackTrace);
}
catch (Exception ex)
{
Debug.WriteLine(String.Format("\t[ERROR@{0}]: {1} => {2}",
host, ex.GetType().Name, ex.Message));
}
}
/// <summary>
/// 添加到RedisList
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public void AddToList(string key, string value)
{
RedisClient.AddItemToList(key, value);
}
static void Main(string[] args)
{
try
{
//获取Redis操作接口
IRedisClient Redis = RedisManager.GetClient();
//Hash表操作
HashOperator operators = new HashOperator();
//移除某个缓存数据
bool isTrue = Redis.Remove("additemtolist");
//将字符串列表添加到redis
List <string> storeMembers = new List <string>()
{
"韩梅梅", "李雷", "露西"
};
storeMembers.ForEach(x => Redis.AddItemToList("additemtolist", x));
//得到指定的key所对应的value集合
Console.WriteLine("得到指定的key所对应的value集合：");
var members = Redis.GetAllItemsFromList("additemtolist");
members.ForEach(s => Console.WriteLine("additemtolist :" + s));
Console.WriteLine("");
// 获取指定索引位置数据
Console.WriteLine("获取指定索引位置数据：");
var item = Redis.GetItemFromList("additemtolist", 2);
Console.WriteLine(item);
Console.WriteLine("");
//将数据存入Hash表中
Console.WriteLine("Hash表数据存储:");
UserInfo userInfos = new UserInfo()
{
UserName = "******", Age = 45
};
var ser = new ObjectSerializer(); //位于namespace ServiceStack.Redis.Support;
bool results = operators.Set <byte[]>("userInfosHash", "userInfos", ser.Serialize(userInfos));
byte[] infos = operators.Get <byte[]>("userInfosHash", "userInfos");
userInfos = ser.Deserialize(infos) as UserInfo;
Console.WriteLine("name=" + userInfos.UserName + " age=" + userInfos.Age);
Console.WriteLine("");
//object序列化方式存储
Console.WriteLine("object序列化方式存储:");
UserInfo uInfo = new UserInfo()
{
UserName = "******", Age = 12
};
bool result = Redis.Set <byte[]>("uInfo", ser.Serialize(uInfo));
UserInfo userinfo2 = ser.Deserialize(Redis.Get <byte[]>("uInfo")) as UserInfo;
Console.WriteLine("name=" + userinfo2.UserName + " age=" + userinfo2.Age);
Console.WriteLine("");
//存储值类型数据
Console.WriteLine("存储值类型数据:");
Redis.Set <int>("my_age", 12);//或Redis.Set("my_age", 12);
int age = Redis.Get <int>("my_age");
Console.WriteLine("age=" + age);
Console.WriteLine("");
//序列化列表数据
Console.WriteLine("列表数据:");
List <UserInfo> userinfoList = new List <UserInfo> {
new UserInfo {
UserName = "******", Age = 1, Id = 1
},
new UserInfo {
UserName = "******", Age = 3, Id = 2
},
};
Redis.Set <byte[]>("userinfolist_serialize", ser.Serialize(userinfoList));
List <UserInfo> userList = ser.Deserialize(Redis.Get <byte[]>("userinfolist_serialize")) as List <UserInfo>;
userList.ForEach(i =>
{
Console.WriteLine("name=" + i.UserName + " age=" + i.Age);
});
//释放内存
Redis.Dispose();
operators.Dispose();
Console.ReadKey();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message.ToString());
Console.WriteLine("Please open the redis-server.exe ");
Console.ReadKey();
}
}
/// <summary>
/// 在尾部追加一条字符串数据
/// </summary>
/// <param name="value">缓存的字符串数据</param>
public void Add(string value)
{
redis.AddItemToList(Key, value);
}
