public IBaseContainerBag Get(string key, bool isFullKey = false)
{
var value = base.Get(key, isFullKey);
if (value == null)
{
return(null);
}
return(StackExchangeRedisExtensions.Deserialize <IBaseContainerBag>((RedisValue)value));
}
public void ThreadsEfficiencyTest()
{
var dt1 = DateTime.Now;
var threadCount = 10;
var finishCount = 0;
for (int i = 0; i < threadCount; i++)
{
var thread = new Thread(() =>
{
CacheStrategyFactory.RegisterObjectCacheStrategy(() => RedisObjectCacheStrategy.Instance);
var dtx = DateTime.Now;
var cacheStrategy = CacheStrategyFactory.GetObjectCacheStrategyInstance();
var dt = DateTime.Now;
cacheStrategy.Set("RedisTest_" + dt.Ticks, new ContainerBag()
{
Key = "123",
Name = "hi",
AddTime = dt
}); //37ms
var obj = cacheStrategy.Get("RedisTest_" + dt.Ticks); //14-25ms
Assert.IsNotNull(obj);
Assert.IsInstanceOfType(obj, typeof(RedisValue));
//Console.WriteLine(obj);
var containerBag = StackExchangeRedisExtensions.Deserialize <ContainerBag>((RedisValue)obj);//11ms
Assert.IsNotNull(containerBag);
Assert.AreEqual(dt.Ticks, containerBag.AddTime.Ticks);
Console.WriteLine($"Thread内单条测试耗时：{(DateTime.Now - dtx).TotalMilliseconds}ms");
finishCount++;
});
thread.Start();
}
while (finishCount < threadCount)
{
//等待
}
Console.WriteLine($"EfficiencyTest总测试时间：{(DateTime.Now - dt1).TotalMilliseconds}ms");
}
public IDictionary <string, TBag> GetAll <TBag>() where TBag : IBaseContainerBag
{
#region 旧方法（没有使用Hash之前）
//var itemCacheKey = ContainerHelper.GetItemCacheKey(typeof(TBag), "*");
////var keyPattern = string.Format("*{0}", itemCacheKey);
//var keyPattern = GetFinalKey(itemCacheKey);
//var keys = GetServer().Keys(pattern: keyPattern);
//var dic = new Dictionary<string, TBag>();
//foreach (var redisKey in keys)
//{
// try
// {
// var bag = Get(redisKey, true);
// dic[redisKey] = (TBag)bag;
// }
// catch (Exception)
// {
// }
//}
#endregion
//var key = ContainerHelper.GetItemCacheKey(typeof(TBag), "");
var key = "";
key = key.Substring(0, key.Length - 1); //去掉:号
key = GetFinalKey(key); //获取带SenparcWeixin:DefaultCache:前缀的Key（[DefaultCache]可配置）
var list = _cache.HashGetAll(key);
var dic = new Dictionary <string, TBag>();
foreach (var hashEntry in list)
{
var fullKey = key + ":" + hashEntry.Name;//最完整的finalKey（可用于LocalCache），还原完整Key，格式：[命名空间]:[Key]
dic[fullKey] = StackExchangeRedisExtensions.Deserialize <TBag>(hashEntry.Value);
}
return(dic);
}
public virtual T Get(string key)
{
if (string.IsNullOrEmpty(key))
{
return(null);
}
if (!CheckExisted(key))
{
return(null);
//InsertToCache(key, new ContainerItemCollection());
}
var cacheKey = GetFinalKey(key);
var value = _cache.StringGet(cacheKey);
//var value = _cache.HashGet(cacheKey, key);
return(StackExchangeRedisExtensions.Deserialize <T>(value));
}
/// <summary>
/// 获取所有指定Key下所有Value【大数据量不要使用容易造成Redis线程阻塞】
/// </summary>
/// <param name="key">xxxxxx*</param>
/// <returns></returns>
public IList <T> GetAll(string key)
{
//TODO:consider using SCAN or sets
var list = new List <T>();
//var finalKey = GetFinalKey(key);
//var hashList = _cache.HashGetAll(finalKey);
//foreach (var hashEntry in hashList)
//{
// var value = hashEntry.Value;
// list.Add(StackExchangeRedisExtensions.Deserialize<T>(value));
//}
var keys = GetServer().Keys(pattern: GetFinalKey(key + "*"));
foreach (var redisKey in keys)
{
var value = _cache.StringGet(redisKey);
list.Add(StackExchangeRedisExtensions.Deserialize <T>(value));
}
return(list);
}
public void CacheWapper_VS_BinaryTest()
{
var count = 50000;
var dt1 = SystemTime.Now;
for (int i = 0; i < count; i++)
{
var testClass = new TestClass()
{
ID = Guid.NewGuid().ToString(),
Star = SystemTime.Now.Ticks,
AddTime = SystemTime.Now
};
var dtx = SystemTime.Now;
var json = testClass.SerializeToCache();
//Console.WriteLine(json);
//Console.WriteLine($"testClass.SerializeToCache 耗时：{(SystemTime.Now - dtx).TotalMilliseconds}ms");
dtx = SystemTime.Now;
var obj = json.DeserializeFromCache <TestClass>();
//Console.WriteLine($"json.DeserializeFromCache<TestClass> 耗时：{(SystemTime.Now - dtx).TotalMilliseconds}ms");
Assert.AreEqual(obj.ID, testClass.ID);
Assert.AreEqual(obj.Star, testClass.Star);
Assert.AreEqual(obj.AddTime, testClass.AddTime);
}
var dt2 = SystemTime.Now;
Console.WriteLine($"CacheWrapper序列化 {count} 次，时间：{(dt2 - dt1).TotalMilliseconds}ms");
dt1 = SystemTime.Now;
for (int i = 0; i < count; i++)
{
var testClass = new TestClass()
{
ID = Guid.NewGuid().ToString(),
Star = SystemTime.Now.Ticks,
AddTime = SystemTime.Now
};
var dtx = SystemTime.Now;
var serializedObj = StackExchangeRedisExtensions.Serialize(testClass);
//Console.WriteLine($"StackExchangeRedisExtensions.Serialize耗时：{(SystemTime.Now - dtx).TotalMilliseconds}ms");
dtx = SystemTime.Now;
var containerBag = StackExchangeRedisExtensions.Deserialize <TestClass>((RedisValue)serializedObj);//11ms
//Console.WriteLine($"StackExchangeRedisExtensions.Deserialize耗时：{(SystemTime.Now - dtx).TotalMilliseconds}ms");
Assert.AreEqual(containerBag.AddTime.Ticks, testClass.AddTime.Ticks);
Assert.AreNotEqual(containerBag.GetHashCode(), testClass.GetHashCode());
}
dt2 = SystemTime.Now;
Console.WriteLine($"StackExchangeRedisExtensions序列化 {count} 次，时间：{(dt2 - dt1).TotalMilliseconds}ms");
dt1 = SystemTime.Now;
for (int i = 0; i < count; i++)
{
var testClass = new TestClass()
{
ID = Guid.NewGuid().ToString(),
Star = SystemTime.Now.Ticks,
AddTime = SystemTime.Now,
};
//模拟CacheWrapper的Type额外工作量，对比效率，主要的效率损失就在反射类型上
//testClass.Type = testClass.GetType();
var dtx = SystemTime.Now;
var serializedObj = Newtonsoft.Json.JsonConvert.SerializeObject(testClass);
//Console.WriteLine($"StackExchangeRedisExtensions.Serialize耗时：{(SystemTime.Now - dtx).TotalMilliseconds}ms");
dtx = SystemTime.Now;
var containerBag = Newtonsoft.Json.JsonConvert.DeserializeObject <TestClass>(serializedObj); //11ms
//Console.WriteLine($"StackExchangeRedisExtensions.Deserialize耗时：{(SystemTime.Now - dtx).TotalMilliseconds}ms");
Assert.AreEqual(containerBag.AddTime.Ticks, testClass.AddTime.Ticks);
Assert.AreNotEqual(containerBag.GetHashCode(), testClass.GetHashCode());
}
dt2 = SystemTime.Now;
Console.WriteLine($"Newtonsoft 序列化（无反射） {count} 次，时间：{(dt2 - dt1).TotalMilliseconds}ms");
dt1 = SystemTime.Now;
for (int i = 0; i < count; i++)
{
var testClass = new TestClass()
{
ID = Guid.NewGuid().ToString(),
Star = SystemTime.Now.Ticks,
AddTime = SystemTime.Now,
};
//模拟CacheWrapper的Type额外工作量，对比效率，主要的效率损失就在反射类型上
testClass.Type = testClass.GetType();
var dtx = SystemTime.Now;
var serializedObj = Newtonsoft.Json.JsonConvert.SerializeObject(testClass);
//Console.WriteLine($"StackExchangeRedisExtensions.Serialize耗时：{(SystemTime.Now - dtx).TotalMilliseconds}ms");
dtx = SystemTime.Now;
var containerBag = Newtonsoft.Json.JsonConvert.DeserializeObject <TestClass>(serializedObj);//11ms
//Console.WriteLine($"StackExchangeRedisExtensions.Deserialize耗时：{(SystemTime.Now - dtx).TotalMilliseconds}ms");
Assert.AreEqual(containerBag.AddTime.Ticks, testClass.AddTime.Ticks);
Assert.AreNotEqual(containerBag.GetHashCode(), testClass.GetHashCode());
}
dt2 = SystemTime.Now;
Console.WriteLine($"Newtonsoft 序列化+反射 {count} 次，时间：{(dt2 - dt1).TotalMilliseconds}ms");
dt1 = SystemTime.Now;
for (int i = 0; i < count; i++)
{
var testClass = new TestClass()
{
ID = Guid.NewGuid().ToString(),
Star = SystemTime.Now.Ticks,
AddTime = SystemTime.Now,
};
//模拟CacheWrapper的Type额外工作量，对比效率，主要的效率损失就在反射类型上
Expression <Func <TestClass> > fun = () => testClass;
//Console.WriteLine(fun.Body.Type);
testClass.Type = fun.Body.Type;
var dtx = SystemTime.Now;
var serializedObj = Newtonsoft.Json.JsonConvert.SerializeObject(testClass);
//Console.WriteLine($"StackExchangeRedisExtensions.Serialize耗时：{(SystemTime.Now - dtx).TotalMilliseconds}ms");
dtx = SystemTime.Now;
var containerBag = Newtonsoft.Json.JsonConvert.DeserializeObject <TestClass>(serializedObj); //11ms
//Console.WriteLine($"StackExchangeRedisExtensions.Deserialize耗时：{(SystemTime.Now - dtx).TotalMilliseconds}ms");
Assert.AreEqual(typeof(TestClass), containerBag.Type);
Assert.AreEqual(containerBag.AddTime.Ticks, testClass.AddTime.Ticks);
Assert.AreNotEqual(containerBag.GetHashCode(), testClass.GetHashCode());
}
dt2 = SystemTime.Now;
Console.WriteLine($"Newtonsoft 序列化（Lambda） {count} 次，时间：{(dt2 - dt1).TotalMilliseconds}ms");
}
public void SerializeCompareTest()
{
//var sessionBag = SessionContainer.UpdateSession(null, "OpenId", "SessionKey");
Func <SessionBag> getNewEntity = () =>
{
var sessionBag = new SessionBag()
{
Key = Guid.NewGuid().ToString(),
Name = "Jeffrey",
SessionKey = "SessionKey",
CacheTime = DateTime.Now,
ExpireTime = DateTime.Now,
OpenId = "OpenId"
};
return(sessionBag);
};
var testCycle = 50;
//使用 Newtonsoft.Json 进行 1 万次序列化并计算时间
DateTime dt1 = DateTime.Now;
for (int i = 0; i < testCycle; i++)
{
//获取一个 SessionBag 对象
var sessionBag = getNewEntity();
//序列化
var jsonString = Newtonsoft.Json.JsonConvert.SerializeObject(sessionBag);
var obj = Newtonsoft.Json.JsonConvert.DeserializeObject <SessionBag>(jsonString);
if (i == 0)
{
Console.WriteLine("Newtonsoft.JSON:");
Console.WriteLine(jsonString); //输出字符串
Console.WriteLine(obj.CacheTime); //输出反序列化后的参数
Console.WriteLine("==============");
dt1 = DateTime.Now; //过滤启动时间，Newtonsoft启动时间需要200多ms
}
}
DateTime dt2 = DateTime.Now;
DateTime dt3 = DateTime.Now;
//使用 Newtonsoft.Json 进行 1 万次序列化并计算时间
for (int i = 0; i < testCycle; i++)
{
//获取一个 SessionBag 对象
var sessionBag = getNewEntity();
//序列化
var jsonString = SerializerHelper.GetJsonString(sessionBag);
var obj = SerializerHelper.GetObject <SessionBag>(jsonString);
if (i == 0)
{
Console.WriteLine(".NET Serializer:");
Console.WriteLine(jsonString); //输出字符串
Console.WriteLine(obj.CacheTime); //输出反序列化后的参数
Console.WriteLine("==============");
dt3 = DateTime.Now; //过滤启动时间
}
}
DateTime dt4 = DateTime.Now;
DateTime dt5 = DateTime.Now;
//使用 .NET 内置 JSON 序列化
for (int i = 0; i < testCycle; i++)
{
//获取一个 SessionBag 对象
var sessionBag = getNewEntity();
var binaryFormatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
MemoryStream memoryStream = new MemoryStream();
{
//序列化
binaryFormatter.Serialize(memoryStream, sessionBag);
byte[] objectDataAsStream = memoryStream.ToArray();
//反序列化
var obj = StackExchangeRedisExtensions.Deserialize <SessionBag>(objectDataAsStream);
if (i == 0)
{
Console.WriteLine(".NET Serializer:");
Console.WriteLine(Encoding.UTF8.GetString(objectDataAsStream)); //输出字符串
Console.WriteLine(obj.CacheTime); //输出反序列化后的参数
Console.WriteLine("==============");
dt5 = DateTime.Now; //过滤启动时间
}
}
}
DateTime dt6 = DateTime.Now;
Console.WriteLine("Newtonsoft JSON 序列化 {0} 次，耗时：{1}ms", testCycle, (dt2 - dt1).TotalMilliseconds);
Console.WriteLine(".NET 内置 JSON 序列化 {0} 次，耗时：{1}ms", testCycle, (dt4 - dt3).TotalMilliseconds);
Console.WriteLine("二进制 序列化 {0} 次，耗时：{1}ms", testCycle, (dt6 - dt5).TotalMilliseconds);
//结果：Newtonsoft.JSON 效率更高，三个结果时间基本上1:2:3
}
public void StackExchangeRedisExtensionsTest()
{
Console.WriteLine("开始异步测试");
var threadCount = 100;
var finishCount = 0;
for (int i = 0; i < threadCount; i++)
{
var thread = new Thread(() => {
var newObj = new ContainerBag()
{
Key = Guid.NewGuid().ToString(),
Name = Newtonsoft.Json.JsonConvert.SerializeObject(this),
AddTime = DateTime.Now
};
var dtx = DateTime.Now;
var serializedObj = StackExchangeRedisExtensions.Serialize(newObj);
Console.WriteLine($"StackExchangeRedisExtensions.Serialize耗时：{(DateTime.Now - dtx).TotalMilliseconds}ms");
dtx = DateTime.Now;
var containerBag = StackExchangeRedisExtensions.Deserialize <ContainerBag>((RedisValue)serializedObj);//11ms
Console.WriteLine($"StackExchangeRedisExtensions.Deserialize耗时：{(DateTime.Now - dtx).TotalMilliseconds}ms");
Assert.AreEqual(containerBag.AddTime.Ticks, newObj.AddTime.Ticks);
Assert.AreNotEqual(containerBag.GetHashCode(), newObj.GetHashCode());
finishCount++;
});
thread.Start();
}
while (finishCount < threadCount)
{
//等待
}
Action action = () =>
{
var newObj = new ContainerBag()
{
Key = Guid.NewGuid().ToString(),
Name = Newtonsoft.Json.JsonConvert.SerializeObject(this),
AddTime = DateTime.Now
};
var dtx = DateTime.Now;
var serializedObj = StackExchangeRedisExtensions.Serialize(newObj);
Console.WriteLine($"StackExchangeRedisExtensions.Serialize耗时：{(DateTime.Now - dtx).TotalMilliseconds}ms");
dtx = DateTime.Now;
var containerBag = StackExchangeRedisExtensions.Deserialize <ContainerBag>((RedisValue)serializedObj);//11ms
Console.WriteLine($"StackExchangeRedisExtensions.Deserialize耗时：{(DateTime.Now - dtx).TotalMilliseconds}ms");
Assert.AreEqual(containerBag.AddTime.Ticks, newObj.AddTime.Ticks);
Assert.AreNotEqual(containerBag.GetHashCode(), newObj.GetHashCode());
};
Console.WriteLine("开始同步测试");
for (int i = 0; i < 10; i++)
{
action();
}
}