public IHttpActionResult InsertBag(RBCreateBag bag)
{
var rt = ISoftSmart.Core.IoC.IoCFactory.Instance.CurrentContainer.Resolve <IRedBag>();//使用接口
bag.CreateTime = DateTime.Now;
var Code = string.Empty;
var ResponseMessage = string.Empty;
RBCreateBag Result = null;
bag.CreateTime = DateTime.Now;
var db = RedisManager.Instance.GetDatabase();
if (StackExchangeRedisExtensions.HasKey(db, CacheKey.BagKey))
{
lock (_locker)
{
var bagcache = StackExchangeRedisExtensions.Get <List <RBCreateBag> >(db, CacheKey.BagKey);
bagcache.Add(bag);
StackExchangeRedisExtensions.Set(db, CacheKey.BagKey, bagcache, 240);
var res = rt.InsertBag(bag);
if (res > 0)
{
Code = "SCCESS";
ResponseMessage = "金豆发放成功！";
}
else
{
Code = "ERROR";
ResponseMessage = "金豆发放失败！";
}
}
}
else
{
StackExchangeRedisExtensions.Set(db, CacheKey.BagKey, bag);
var res = rt.InsertBag(bag);
if (res > 0)
{
Code = "SCCESS";
ResponseMessage = "金豆发放成功！";
}
else
{
Code = "ERROR";
ResponseMessage = "金豆发放失败！";
}
}
return(Ok(new APIResponse <RBCreateBag>
{
Code = Code,
ResponseMessage = ResponseMessage,
Result = Result
}));
}
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 Update(string key, object value, bool isFullKey = false)
{
//var cacheKey = GetFinalKey(key, isFullKey);
var hashKeyAndField = this.GetHashKeyAndField(key);
//value.Key = cacheKey;//储存最终的键
//_cache.StringSet(cacheKey, value.Serialize());
//_cache.HashSet(hashKeyAndField.Key, hashKeyAndField.Field, value.Serialize());
_cache.HashSet(hashKeyAndField.Key, hashKeyAndField.Field, StackExchangeRedisExtensions.Serialize(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 InsertToCache(string key, object value)
{
if (string.IsNullOrEmpty(key) || value == null)
{
return;
}
//var cacheKey = GetFinalKey(key);
var hashKeyAndField = this.GetHashKeyAndField(key);
//if (value is IDictionary)
//{
// //Dictionary类型
//}
//_cache.StringSet(cacheKey, value.Serialize());
//_cache.HashSet(hashKeyAndField.Key, hashKeyAndField.Field, value.Serialize());
_cache.HashSet(hashKeyAndField.Key, hashKeyAndField.Field, StackExchangeRedisExtensions.Serialize(value));
#if DEBUG
var value1 = _cache.HashGet(hashKeyAndField.Key, hashKeyAndField.Field);//正常情况下可以得到 //_cache.GetValue(cacheKey);
#endif
}
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 ContainerTest()
{
MutipleCacheTestHelper.RunMutipleCache(() =>
{
//获取Token完整结果（包括当前过期秒数）
DateTime dt1 = DateTime.Now;
var tokenResult = AccessTokenContainer.GetAccessTokenResult(base._appId);
DateTime dt2 = DateTime.Now;
Assert.IsNotNull(tokenResult);
Console.WriteLine(tokenResult.access_token);
Console.WriteLine("耗时：{0}毫秒", (dt2 - dt1).TotalMilliseconds);
if (base._useRedis)
{
Thread.Sleep(2500);//等待缓存更新
}
//只获取Token字符串
dt1 = DateTime.Now;
var token = AccessTokenContainer.GetAccessToken(base._appId);
dt2 = DateTime.Now;
Assert.AreEqual(tokenResult.access_token, token);
Console.WriteLine(tokenResult.access_token);
Console.WriteLine("耗时：{0}毫秒", (dt2 - dt1).TotalMilliseconds);
//getNewToken
{
dt1 = DateTime.Now;
token = AccessTokenContainer.TryGetAccessToken(base._appId, base._appSecret, false);
dt2 = DateTime.Now;
Console.WriteLine(token);
Assert.AreEqual(tokenResult.access_token, token);
Console.WriteLine("强制重新获取AccessToken");
dt1 = DateTime.Now;
token = AccessTokenContainer.TryGetAccessToken(base._appId, base._appSecret, true);
dt2 = DateTime.Now;
Console.WriteLine(token);
Assert.AreNotEqual(tokenResult.access_token, token);//如果微信服务器缓存，此处会相同
Console.WriteLine("耗时：{0}毫秒", (dt2 - dt1).TotalMilliseconds);
}
{
tokenResult = AccessTokenContainer.GetAccessTokenResult(base._appId);
if (base._useRedis)
{
Thread.Sleep(2500);//等待缓存更新
}
Console.WriteLine("HashCode：{0}", tokenResult.GetHashCode());
dt1 = DateTime.Now;
var allItems = AccessTokenContainer.GetAllItems();
dt2 = DateTime.Now;
Assert.IsTrue(allItems.Count > 0);
//序列化
var d1 = StackExchangeRedisExtensions.Serialize(tokenResult);
var d2 = StackExchangeRedisExtensions.Serialize(allItems[0].AccessTokenResult);
Assert.AreEqual(String.Concat(d1), String.Concat(d2));//证明缓存成功
Console.WriteLine("All Items:{0}", allItems.Count);
Console.WriteLine("HashCode：{0}", allItems[0].AccessTokenResult.GetHashCode());
Console.WriteLine("耗时：{0}毫秒", (dt2 - dt1).TotalMilliseconds);
}
}, CacheType.Local, CacheType.Redis);
}
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();
}
}
public IHttpActionResult Index()
{
#region IOC
// ISoftSmart.Core.IoC.IoCFactory.Instance.CurrentContainer.RegisterType(typeof(ITestUsers), typeof(UserExtents));//注册接口
//var rt = ISoftSmart.Core.IoC.IoCFactory.Instance.CurrentContainer.Resolve<ITestUsers>();//使用接口
//var tt = rt.Test2();//执行SQL返回JSON
#endregion
#region Redis
//var db = RedisManager.Instance.GetDatabase();
////var result2 = (int)RedisManager.Instance.GetDatabase().StringGet("abc123zzl");
////StackExchangeRedisExtensions.Set(db, "t", "testtttt");//操作字符
//var usr = new UserInfo()
//{
// Age = 1,
// ID = "2",
// Name = "22222"
//};
//List<UserInfo> list = new List<UserInfo>();
//list.Add(usr);//生成一个list
//StackExchangeRedisExtensions.Set(db, "t", list);//设置值
//var getDbVal = StackExchangeRedisExtensions.Get<List<UserInfo>>(db, "t");
//var usr1 = new UserInfo()
//{
// Age = 1,
// ID = "33332",
// Name = "2222333的2"
//};
//getDbVal.Add(usr1);
//StackExchangeRedisExtensions.Set(db, "t", getDbVal);//设置值
////StackExchangeRedisExtensions.Append(db, "t", usr);
//var getDbVal1 = StackExchangeRedisExtensions.Get(db, "t");
//var getkey = StackExchangeRedisExtensions.HasKey(db, "t1");
////StackExchangeRedisExtensions.Remove(db, "t");
#endregion
#region Redis队列
//RedisQueueManager.Push()
#endregion
//var rt = IoCFactory.Instance.CurrentContainer.Resolve<IRedBag>();//注册对象
//var bag = IoCFactory.Instance.CurrentContainer.Resolve<RBCreateBag>();//注册对象
//bag = rt.GetBag(bag);
var db = RedisManager.Instance.GetDatabase();
if (StackExchangeRedisExtensions.HasKey(db, CacheKey.BagKey))
{
var bagcaches = StackExchangeRedisExtensions.Get <RBCreateBag>(db, CacheKey.BagKey);
return(Ok(new APIResponse <RBCreateBag>
{
Code = "SUCCESS",
ResponseMessage = "获取列表成功！",
Result = bagcaches
}));
}
else
{
var rt = IoCFactory.Instance.CurrentContainer.Resolve <IRedBag>(); //注册对象
var bag = IoCFactory.Instance.CurrentContainer.Resolve <RBCreateBag>(); //注册对象
bag.BagStatus = 0;
bag = rt.GetBag(bag);
if (bag != null)
{
StackExchangeRedisExtensions.Set(db, CacheKey.BagKey, bag);
var bagcaches = StackExchangeRedisExtensions.Get <RBCreateBag>(db, CacheKey.BagKey);
return(Ok(new APIResponse <RBCreateBag>
{
Code = "SUCCESS",
ResponseMessage = "获取列表成功！",
Result = bagcaches
}));
}
else
{
return(Ok(new APIResponse <RBCreateBag>
{
Code = "ERROR",
ResponseMessage = "红包抢完了！",
}));
}
}
}
public IHttpActionResult OpenBag(RBCreateBag bag)
{
var rt = ISoftSmart.Core.IoC.IoCFactory.Instance.CurrentContainer.Resolve <IRedBag>();//使用接口
//bag.CreateTime = DateTime.Now;
//var res = await Task.Run(() =>rt.GetBag(bag));
var Code = string.Empty;
var ResponseMessage = string.Empty;
RBCreateBag Result = null;
//Task.Run(() =>
//{
bag.CreateTime = DateTime.Now;
var db = RedisManager.Instance.GetDatabase();
if (StackExchangeRedisExtensions.HasKey(db, CacheKey.BagKey))
{
lock (_locker)
{
var bagcache = StackExchangeRedisExtensions.Get <RBCreateBag>(db, CacheKey.BagKey);
if (bagcache.BagNum > 0)
{
decimal curAmount = 0;
var openResult = GenerateBag(bagcache, out curAmount);
Code = "SUCCESS";
ResponseMessage = "抢到" + curAmount + "元！";
Result = openResult;
RedisQueueManager.Push <RBCreateBag>(CacheKey.OpenBagKey, bagcache);
StackExchangeRedisExtensions.Set(db, CacheKey.BagKey, bagcache);
}
else
{
Code = "ERROR";
ResponseMessage = "红包抢完了！";
bag.BagStatus = 1;
//RedisQueueManager.DoQueue<int>((s) =>
//{
// rt.ChangeBagStatus(bag);
//}, CacheKey.OpenBagKey);
rt.ChangeBagStatus(bag);
StackExchangeRedisExtensions.Remove(db, CacheKey.BagKey);
}
}
}
else
{
StackExchangeRedisExtensions.Set(db, CacheKey.BagKey, bag);
}
return(Ok(new APIResponse <RBCreateBag>
{
Code = Code,
ResponseMessage = ResponseMessage,
Result = Result
}));
//});
//return Ok(new APIResponse<RBCreateBag>
//{
// Code = Code,
// ResponseMessage = ResponseMessage,
// Result = Result
//});
}