private async void ExampleGet()
{
Task <string> getter = redis.Get(key);
string data = await getter;
Debug.Log(data);
}
protected void Page_Load(object sender, EventArgs e)
{
/**/
List <Student> list = new List <Student>();
Student stu1 = new Student {
Name = "dancer",
Age = 29,
Sex = 1
};
list.Add(stu1);
Student stu = new Student {
Name = "ann",
Age = 2,
Sex = 1
};
list.Add(stu);
Redis r = new Redis();
r.Set("stu_list", list);
object oo = r.Get("stu_list");
Response.Write(oo);
}
public void Can_AcquireLock_TimeOut()
{
Redis.IncrementValue("key"); //1
var acquiredLock = Redis.AcquireLock("testlock");
var waitFor = TimeSpan.FromMilliseconds(1000);
var now = DateTime.Now;
try
{
using (var client = new RedisClient(TestConfig.SingleHost))
{
using (client.AcquireLock("testlock", waitFor))
{
Redis.IncrementValue("key"); //2
}
}
}
catch (TimeoutException tex)
{
var val = Redis.Get <int>("key");
Assert.That(val, Is.EqualTo(1));
var timeTaken = DateTime.Now - now;
Assert.That(timeTaken.TotalMilliseconds > waitFor.TotalMilliseconds, Is.True);
Assert.That(timeTaken.TotalMilliseconds < waitFor.TotalMilliseconds + 1000, Is.True);
return;
}
Assert.Fail("should have Timed out");
}
private T BaseGetCacheT<T>(string key)
{
try
{
//object obj = cm.GetData(key);
//object obj = null;
if (cacheType == (int)CachedEnum.CachedTypes.Redis)
{
var obj1 = Redis.Get(key);
return Deserialize<T>(obj1);
}
else
{
return GetIISCache<T>(key);
}
//return default(T);
}
catch (Exception ex)
{
Logger.WriteLog(Logger.LogType.Trace, string.Format("BaseGetCacheT<T> key: {0} {1} {2}", key, Environment.NewLine, ex.ToString()));
return default(T);
}
}
private static void ImportPlayerStats(ApplicationArguments options)
{
Redis redis = GetClient(options);
string[] keys = new string[] { };
try
{
keys = redis.GetKeys("PlayerStats:*");
}
catch (Exception ex)
{
Console.WriteLine("Error Getting Keys: " + ex.Message);
return;
}
foreach (string key in keys)
{
byte[] d = redis.Get(key);
int ttl;
if (d[0] == 128)
{
ttl = redis.TimeToLive(key);
Manager.Invoke(String.Format("SET\nPlayerStats\n{0}\n{1}\n[0,1]\n", key.Replace("PlayerStats:", ""), ttl), 10000);
}
else
{
ttl = redis.TimeToLive(key);
Manager.Invoke(String.Format("SET\nPlayerStats\n{0}\n{1}\n[0,0]\n", key.Replace("PlayerStats:", ""), ttl), 10000);
}
}
}
private static void ImportItems(ApplicationArguments options)
{
Redis redis = GetClient(options);
string[] ikeyp = new string[] { "Building", "Plotpole", "Storage", "Vehicle", "AI", "AI_Items", "Bank", "Group", "Player", "PlayerData", "PlayerData" };
foreach (string ik in ikeyp)
{
string[] keys = new string[] { };
try
{
keys = redis.GetKeys(String.Format("{0}:*", ik));
}
catch (Exception ex)
{
Console.WriteLine("Error Getting Keys: " + ex.Message);
continue;
}
foreach (string key in keys)
{
try
{
int ttl = redis.TimeToLive(key);
string rstring = Encoding.UTF8.GetString(redis.Get(key));
Manager.Invoke(String.Format("SET\n{0}\n{1}\n{2}\n{3}", ik, key.Replace(ik + ":", ""), ttl, rstring), 10000);
}
catch (Exception ex)
{
Console.WriteLine(String.Format("Error getting key {0}: {1}", key, ex.Message));
}
}
}
}
public void TestMSetNx()
{
// test array
Redis.Del("test1", "test2");
Assert.IsTrue(Redis.MSetNx("test1", "v1", "test2", "v2"));
Assert.AreEqual("v1", Redis.Get("test1"));
Assert.AreEqual("v2", Redis.Get("test2"));
Redis.Del("test1");
Assert.IsFalse(Redis.MSetNx("test1", "V1", "test2", "V2"));
Assert.IsNull(Redis.Get("test1"));
Assert.AreEqual("v2", Redis.Get("test2"));
// test kvp
Redis.Del("test1", "test2");
Assert.IsTrue(Redis.MSetNx(new[]
{
Tuple.Create("test1", "v1"),
Tuple.Create("test2", "v2"),
}));
Assert.AreEqual("v1", Redis.Get("test1"));
Assert.AreEqual("v2", Redis.Get("test2"));
Redis.Del("test1");
Assert.IsFalse(Redis.MSetNx(new[]
{
Tuple.Create("test1", "v1"),
Tuple.Create("test2", "v2"),
}));
Assert.IsNull(Redis.Get("test1"));
Assert.AreEqual("v2", Redis.Get("test2"));
Redis.Del("test1", "test2");
}
public Board GetBoard(string name)
{
Board newBoard;
if (ContainsKey <Board>(name))
{
return(Get <Board>(name));
}
var newBoardId = Values <Board>().Count() + 1;
// Check redis first, then fall back to creation
if (Redis.KeyExists(Board.GetStorageKey(name)))
{
newBoard = Redis.Get <Board>(Board.GetStorageKey(name));
GameLog.Info("Board: loaded {boardname}", name);
newBoard.Id = newBoardId;
}
else
{
newBoard = new Board(name)
{
Id = newBoardId
};
newBoard.Save();
GameLog.Info("Board: Creating {boardname}", name);
}
SetWithIndex(name, newBoard, newBoard.Id);
return(Get <Board>(name));
}
public void Can_Subscribe_and_Publish_multiple_message()
{
var channelName = PrefixedKey("CHANNEL2");
const string messagePrefix = "MESSAGE ";
string key = PrefixedKey("Can_Subscribe_and_Publish_multiple_message");
const int publishMessageCount = 5;
var messagesReceived = 0;
Redis.IncrementValue(key);
using (var subscription = Redis.CreateSubscription())
{
subscription.OnSubscribe = channel =>
{
Log("Subscribed to '{0}'", channel);
Assert.That(channel, Is.EqualTo(channelName));
};
subscription.OnUnSubscribe = channel =>
{
Log("UnSubscribed from '{0}'", channel);
Assert.That(channel, Is.EqualTo(channelName));
};
subscription.OnMessage = (channel, msg) =>
{
Log("Received '{0}' from channel '{1}'", msg, channel);
Assert.That(channel, Is.EqualTo(channelName));
Assert.That(msg, Is.EqualTo(messagePrefix + messagesReceived++));
if (messagesReceived == publishMessageCount)
{
subscription.UnSubscribeFromAllChannels();
}
};
ThreadPool.QueueUserWorkItem(x =>
{
Thread.Sleep(100); // to be sure that we have subscribers
using (var redisClient = CreateRedisClient())
{
for (var i = 0; i < publishMessageCount; i++)
{
var message = messagePrefix + i;
Log("Publishing '{0}' to '{1}'", message, channelName);
redisClient.PublishMessage(channelName, message);
}
}
});
Log("Start Listening On");
subscription.SubscribeToChannels(channelName); //blocking
}
Log("Using as normal client again...");
Redis.IncrementValue(key);
Assert.That(Redis.Get <int>(key), Is.EqualTo(2));
Assert.That(messagesReceived, Is.EqualTo(publishMessageCount));
}
public ISessionUser GetUserBySessionId(string sessionId)
{
if (Redis.Exist(sessionId))
{
return(Json.GetObject <SessionUser>(Redis.Get(sessionId)));
}
return(null);
}
/// <summary>
/// 获取旧流位置
/// </summary>
/// <returns></returns>
public long GetFilePosition()
{
lock (this)
{
long position = Redis.Get <long>("LogPosition");
return(position);
}
}
/// <summary>
/// 获取与指定键关联的值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key">键名</param>
/// <returns>与指定键关联的值</returns>
public virtual T Get <T>(string key)
{
try
{
return(Redis.Get <T>(key));
}
catch (Exception err) { throw new Exception(err.Message); }
}
public void Can_Set_and_Get_string()
{
Redis.SetEntry("key", Value);
var valueBytes = Redis.Get("key");
var valueString = GetString(valueBytes);
Assert.That(valueString, Is.EqualTo(Value));
}
public void Can_Set_and_Get_key_with_space()
{
Redis.SetEntry("key with space", Value);
var valueBytes = Redis.Get("key with space");
var valueString = GetString(valueBytes);
Assert.That(valueString, Is.EqualTo(Value));
}
public void TestGet()
{
Redis.Del("test");
Assert.IsNull(Redis.Get("test"));
Redis.Set("test", 1);
Assert.AreEqual("1", Redis.Get("test"));
Redis.Del("test");
}
public void CacheTest()
{
Redis r = new Redis();
r.Insert("k001", "value001");
object oo = r.Get("k001");
CacheHelper.Insert("key01", "test001");
object obj = CacheHelper.Get("key01");
}
public void TestSetNx()
{
Redis.Del("test");
Assert.IsTrue(Redis.SetNx("test", "Hello"));
Assert.IsFalse(Redis.SetNx("test", "World"));
Assert.AreEqual("Hello", Redis.Get("test"));
Redis.Del("test");
}
public void TestSetEx()
{
Redis.Del("test");
Assert.AreEqual("OK", Redis.SetEx("test", 10, 1));
Assert.AreEqual("1", Redis.Get("test"));
Assert.IsTrue(Redis.Ttl("test") > 0);
Redis.Del("test");
}
public void TestSetBit()
{
Redis.Del("test");
Assert.IsFalse(Redis.SetBit("test", 7, true));
Assert.IsTrue(Redis.SetBit("test", 7, false));
Assert.AreEqual("\0", Redis.Get("test"));
Redis.Del("test");
}
public void TestLargeBulk()
{
string random = GetRandomString(1048576);
using (new RedisTestKeys(Redis, "test"))
{
Assert.AreEqual("OK", Redis.Set("test", random));
Assert.AreEqual(random, Redis.Get("test"));
}
}
public void TestGetSet()
{
Redis.Del("test");
Redis.Set("test", "Hello");
Assert.AreEqual("Hello", Redis.GetSet("test", "World"));
Assert.AreEqual("World", Redis.Get("test"));
Redis.Del("test");
}
public void TestSetRange()
{
Redis.Del("test");
Redis.Set("test", "Hello World");
Assert.AreEqual(11, Redis.SetRange("test", 6, "Redis"));
Assert.AreEqual("Hello Redis", Redis.Get("test"));
Redis.Del("test");
}
public void Can_Set_and_Get_key_with_spaces()
{
const string key = "key with spaces";
Redis.SetEntry(key, Value);
var valueBytes = Redis.Get(key);
var valueString = GetString(valueBytes);
Assert.That(valueString, Is.EqualTo(Value));
}
public void Can_StoreObject()
{
object poco = new MyPoco {
Id = 1, Name = "Test"
};
Redis.StoreObject(poco);
Assert.That(Redis.Get <string>("urn:mypoco:1"), Is.EqualTo("{\"Id\":1,\"Name\":\"Test\"}"));
Assert.That(Redis.PopItemFromSet("ids:MyPoco"), Is.EqualTo("1"));
}
public void Can_Store_with_Prefix()
{
var expected = new CacheRecord()
{
Id = "123"
};
RedisTyped.Store(expected);
var current = Redis.Get <CacheRecord>("RedisTypedClientTests:urn:cacherecord:123");
Assert.AreEqual(expected.Id, current.Id);
}
public void Can_save_via_types()
{
var dtos = 10.Times(i => new Dummy {
Id = i, Name = "Name" + i
});
Redis.Set("dummy:strings", dtos);
var fromDtos = Redis.Get <List <Dummy> >("dummy:strings");
Assert.That(fromDtos.Count, Is.EqualTo(10));
}
public void Can_AcquireLock()
{
Redis.IncrementValue("key"); //1
var asyncResults = 5.TimesAsync(i =>
IncrementKeyInsideLock(i, new RedisClient(TestConfig.SingleHost)));
asyncResults.WaitAll(TimeSpan.FromSeconds(5));
var val = Redis.Get <int>("key");
Assert.That(val, Is.EqualTo(1 + 5));
}
public T Get <T>(string Key)
{
try
{
var json = Redis.Get(Key);
if (!json.IsEmpty())
{
return(JsonConvert.DeserializeObject <T>(json));
}
}
catch { }
return(default(T));
}
bool ICachingProvider.TryGet <TValue>(string key, out TValue value)
{
AssertKey(key);
try
{
value = Redis.Get <TValue>(key);
return(!Equals(value, default(TValue)));
}
catch
{
value = default(TValue);
return(false);
}
}
public void TestSelect()
{
string test_key = Guid.NewGuid().ToString();
string test_value = "1";
using (new RedisTestKeys(Redis, test_key))
{
Redis.Set(test_key, test_value);
Assert.AreEqual(test_value, Redis.Get(test_key));
Assert.AreEqual("OK", Redis.Select(1));
Assert.IsNull(Redis.Get(test_key));
Assert.AreEqual("OK", Redis.Select(0));
Assert.AreEqual(test_value, Redis.Get(test_key));
}
}
public void VerifyPerformanceImprovement()
{
int asyncTimer, sync, op = 0, asyncFaF, syncFaF;
using (var muxer= Config.GetUnsecuredConnection())
{
// do these outside the timings, just to ensure the core methods are JITted etc
for (int db = 0; db < 5; db++)
{
muxer.GetDatabase(db).KeyDeleteAsync("perftest");
}
var timer = Stopwatch.StartNew();
for (int i = 0; i < 100; i++)
{
// want to test multiplex scenario; test each db, but to make it fair we'll
// do in batches of 10 on each
for (int db = 0; db < 5; db++)
{
var conn = muxer.GetDatabase(db);
for (int j = 0; j < 10; j++)
conn.StringIncrementAsync("perftest");
}
}
asyncFaF = (int)timer.ElapsedMilliseconds;
Task<RedisValue>[] final = new Task<RedisValue>[5];
for (int db = 0; db < 5; db++)
final[db] = muxer.GetDatabase(db).StringGetAsync("perftest");
muxer.WaitAll(final);
timer.Stop();
asyncTimer = (int)timer.ElapsedMilliseconds;
Console.WriteLine("async to completion (local): {0}ms", timer.ElapsedMilliseconds);
for (int db = 0; db < 5; db++)
Assert.AreEqual(1000, (long)final[db].Result, "async, db:" + db);
}
using (var conn = new Redis(Config.LocalHost, 6379))
{
// do these outside the timings, just to ensure the core methods are JITted etc
for (int db = 0; db < 5; db++)
{
conn.Db = db;
conn.Remove("perftest");
}
var timer = Stopwatch.StartNew();
for (int i = 0; i < 100; i++)
{
// want to test multiplex scenario; test each db, but to make it fair we'll
// do in batches of 10 on each
for (int db = 0; db < 5; db++)
{
conn.Db = db;
op++;
for (int j = 0; j < 10; j++)
{
conn.Increment("perftest");
op++;
}
}
}
syncFaF = (int)timer.ElapsedMilliseconds;
string[] final = new string[5];
for (int db = 0; db < 5; db++)
{
conn.Db = db;
final[db] = Encoding.ASCII.GetString(conn.Get("perftest"));
}
timer.Stop();
sync = (int)timer.ElapsedMilliseconds;
Console.WriteLine("sync to completion (local): {0}ms", timer.ElapsedMilliseconds);
for (int db = 0; db < 5; db++)
Assert.AreEqual("1000", final[db], "async, db:" + db);
}
int effectiveAsync = ((10 * asyncTimer) + 3) / 10;
int effectiveSync = ((10 * sync) + (op * 3)) / 10;
Console.WriteLine("async to completion with assumed 0.3ms LAN latency: " + effectiveAsync);
Console.WriteLine("sync to completion with assumed 0.3ms LAN latency: " + effectiveSync);
Console.WriteLine("fire-and-forget: {0}ms sync vs {1}ms async ", syncFaF, asyncFaF);
Assert.Less(effectiveAsync, effectiveSync, "Everything");
Assert.Less(asyncFaF, syncFaF, "Fire and Forget");
}