public void TestAll()
{
var mq = new SenparcMessageQueue();
var count = mq.GetCount();
var key = DateTime.Now.Ticks.ToString();
//Test Add()
var item = mq.Add(key, () => Console.WriteLine("测试SenparcMessageQueue写入Key=A"));
Assert.AreEqual(count + 1, mq.GetCount());
//var hashCode = item.GetHashCode();
//Test GetCurrentKey()
var currentKey = mq.GetCurrentKey();
Assert.AreEqual(key, currentKey);
//Test GetItem
var currentItem = mq.GetItem(currentKey);
Assert.AreEqual(currentItem.Key, item.Key);
Assert.AreEqual(currentItem.AddTime, item.AddTime);
//Test Remove
mq.Remove(key);
Assert.AreEqual(count, mq.GetCount());
}
public async Task <IResponseMessageBase> SendMessage(string appid, string openid, IResponseMessageBase responseMessage)
{
var messageQueue = new SenparcMessageQueue();
if (!(responseMessage is ResponseMessageText responseMessagea))
{
return(responseMessage);
}
return(await Task.Run(() =>
{
{
var key = SenparcMessageQueue.GenerateKey("MessageHandlerSendMessageAsync", responseMessage.GetType(), Guid.NewGuid().ToString(), "SendMessage");
messageQueue.Add(key, () =>
{
responseMessagea.Content += "\r\n[消息超时后客服发送的消息1]";
// 发送客服消息 在队列里面就可以不用 async await 了
CustomApi.SendText(appid, openid, responseMessagea.Content);
});
}
{
var key = SenparcMessageQueue.GenerateKey("MessageHandlerSendMessageAsync", responseMessage.GetType(), Guid.NewGuid().ToString(), "SendMessage");
messageQueue.Add(key, () =>
{
responseMessagea.Content += "\r\n[消息超时后客服发送的消息2]";
// 发送客服消息 在队列里面就可以不用 async await 了
CustomApi.SendText(appid, openid, responseMessagea.Content);
});
}
return new ResponseMessageNoResponse();
}));
}
/// <summary>
/// 保存响应信息
/// <para>测试时可开启此记录，帮助跟踪数据，使用前请确保App_Data文件夹存在，且有读写权限。</para>
/// </summary>
/// <param name="logPath">保存日志目录，默认为 ~/App_Data/<模块类型>/<yyyy-MM-dd>/</param>
public void SaveResponseMessageLog(string logPath = null)
{
try
{
logPath = logPath ?? GetLogPath();
SenparcMessageQueue queue = new SenparcMessageQueue();
var key = Guid.NewGuid().ToString();
queue.Add(key, () =>
{
if (this.ResponseDocument != null && this.ResponseDocument.Root != null)
{
this.ResponseDocument.Save(Path.Combine(logPath, string.Format("{0}_Response_{1}_{2}.txt", _getRandomFileName(),
this.ResponseMessage.ToUserName,
this.ResponseMessage.MsgType)));
}
if (this.UsingEcryptMessage &&
this.FinalResponseDocument != null && this.FinalResponseDocument.Root != null)
{
//记录加密后的响应信息
this.FinalResponseDocument.Save(Path.Combine(logPath, string.Format("{0}_Response_Final_{1}_{2}.txt", _getRandomFileName(),
this.ResponseMessage.ToUserName,
this.ResponseMessage.MsgType)));
}
});
}
catch (Exception ex)
{
new MessageHandlerException(ex.Message, ex);
}
}
/// <summary>
/// 保存请求信息
/// <para>测试时可开启此记录，帮助跟踪数据，使用前请确保App_Data文件夹存在，且有读写权限。</para>
/// </summary>
/// <param name="logPath">保存日志目录，默认为 ~/App_Data/<模块类型>/<yyyy-MM-dd>/</param>
public void SaveRequestMessageLog(string logPath = null)
{
try
{
logPath = logPath ?? GetLogPath();
SenparcMessageQueue queue = new SenparcMessageQueue();
var key = Guid.NewGuid().ToString();
queue.Add(key, () =>
{
this.RequestDocument.Save(Path.Combine(logPath, string.Format("{0}_Request_{1}_{2}.txt", _getRandomFileName(),
this.RequestMessage.FromUserName,
this.RequestMessage.MsgType)));
if (this.UsingEcryptMessage && this.EcryptRequestDocument != null)
{
this.EcryptRequestDocument.Save(Path.Combine(logPath, string.Format("{0}_Request_Ecrypt_{1}_{2}.txt", _getRandomFileName(),
this.RequestMessage.FromUserName,
this.RequestMessage.MsgType)));
}
});
}
catch (Exception ex)
{
new MessageHandlerException(ex.Message, ex);
}
}
public void ThreadUtilityTest()
{
ThreadUtility.Register();
ThreadUtility.Register();//多次注仍然只记录一次（最早的一次）
ThreadUtility.Register();
Assert.AreEqual(1, ThreadUtility.AsynThreadCollection.Count);
var smq = new SenparcMessageQueue();
var key = "ThreadUtilityTests";
smq.Add(key, () =>
{
Console.WriteLine("队列执行SenparcMessageQueue");
});
//不再需要操作 SenparcMessageQueueThreadUtility.Run()，队列已经会自动处理
while (smq.GetCount() > 0)
{
//执行队列
}
Console.WriteLine($"SenparcMessageQueue队列处理完毕，当前项目：{smq.GetCount()}");
}
/// <summary>
/// 释放，开始立即更新所有缓存
/// </summary>
public void Dispose()
{
if (DoFlush)
{
SenparcMessageQueue.OperateQueue();
}
}
/// <summary>
/// 保存请求信息
/// <para>测试时可开启此记录，帮助跟踪数据，使用前请确保App_Data文件夹存在，且有读写权限。</para>
/// </summary>
/// <param name="logPath">保存日志目录，默认为 ~/App_Data/<模块类型>/<yyyy-MM-dd>/</param>
public void SaveRequestMessageLog(string logPath = null)
{
try
{
logPath = logPath ?? GetLogPath();
SenparcMessageQueue queue = new SenparcMessageQueue();
var key = Guid.NewGuid().ToString();
queue.Add(key, () =>
{
if (this.RequestDocument != null)
{
this.RequestDocument.Save(Path.Combine(logPath, string.Format("{0}_Request_{1}_{2}.txt", _getRandomFileName(),
this.RequestMessage?.FromUserName,
this.RequestMessage?.MsgType)));
}
else
{
System.IO.File.WriteAllText(Path.Combine(logPath, string.Format("{0}_UntreatedRequest.txt", _getRandomFileName())),
this.TextResponseMessage);
}
if (this.UsingEncryptMessage && this.EcryptRequestDocument != null)
{
this.EcryptRequestDocument.Save(Path.Combine(logPath, string.Format("{0}_Request_Ecrypt_{1}_{2}.txt", _getRandomFileName(),
this.RequestMessage.FromUserName,
this.RequestMessage.MsgType)));
}
});
}
catch (Exception ex)
{
_ = new MessageHandlerException(ex.Message, ex);
}
}
public void SenparcMessageQueueThreadUtilityTest()
{
var smq = new SenparcMessageQueue();
var key = "SenparcMessageQueueThreadUtilityTest";
smq.Add(key, () =>
{
Console.WriteLine("执行SenparcMessageQueue");
});
Console.WriteLine($"SenparcMessageQueue.Count：{smq.GetCount()}");
var senparcMessageQueue = new SenparcMessageQueueThreadUtility();
Task.Factory.StartNew(() =>
{
senparcMessageQueue.Run();
});//异步执行
//
while (smq.GetCount() > 0)
{
//执行队列
}
Console.WriteLine($"SenparcMessageQueue队列处理完毕，当前项目：{smq.GetCount()}");
}
/// <summary>
/// 启动线程轮询
/// </summary>
public void Run()
{
do
{
SenparcMessageQueue.OperateQueue();
Thread.Sleep(_sleepMilliSeconds);
} while (true);
}
public void RemoveFromCache(string key)
{
if (string.IsNullOrEmpty(key))
{
return;
}
SenparcMessageQueue.OperateQueue(); //延迟缓存立即生效
_cache.KeyDelete(key); //删除键
}
public static readonly string AppId = ConfigurationManager.AppSettings["WeixinAppId"];// Config.SenparcWeixinSetting.WeixinAppId;//与微信公众账号后台的AppId设置保持一致，区分大小写。
public IResponseMessageBase SendMessage(string openId, IResponseMessageBase ResponseMessage)
{
var senparcMessageQueue = new SenparcMessageQueue();
if (ResponseMessage is ResponseMessageText)
{
string strResponseMsg = "";
//以下是：把同一用户的多个消息内容，加入到队列中
//myKey 加入队列排序执行
var myKey = SenparcMessageQueue.GenerateKey("MessageQueueHandlerAsync", ResponseMessage.GetType(),
Guid.NewGuid().ToString(), "SendMessage");
senparcMessageQueue.Add(myKey, () =>
{
//把需要回复的消息，整理一下
var asyncResponseMessage = ResponseMessage as ResponseMessageText;
if (asyncResponseMessage != null)
{
asyncResponseMessage.Content += "\r\n【1-执行超过5秒，以客服消息回复】";
strResponseMsg = asyncResponseMessage.Content;
}
});
//Thread.Sleep(10);
//myKey2 加入队列排序执行
var myKey2 = SenparcMessageQueue.GenerateKey("MessageQueueHandlerAsync", ResponseMessage.GetType(),
Guid.NewGuid().ToString(), "SendMessage");
senparcMessageQueue.Add(myKey2, () =>
{
//把需要回复的消息，整理一下
var asyncResponseMessage = ResponseMessage as ResponseMessageText;
if (asyncResponseMessage != null)
{
asyncResponseMessage.Content += "\r\n【2-执行超过5秒，以客服消息回复】";
strResponseMsg = asyncResponseMessage.Content;
}
});
//执行队列，把需要回复的消息整理
SenparcMessageQueue.OperateQueue();
//通过客服消息的方式，下发给用户
CustomApi.SendText(AppId, openId, strResponseMsg);
//不再给用户回复消息
return(new ResponseMessageNoResponse());
}
return(ResponseMessage);
}
public override async Task RemoveFromCacheAsync(string key, bool isFullKey = false)
{
if (string.IsNullOrEmpty(key))
{
return;
}
var cacheKey = GetFinalKey(key, isFullKey);
SenparcMessageQueue.OperateQueue(); //延迟缓存立即生效
await _cache.KeyDeleteAsync(cacheKey); //删除键
}
public override void RemoveFromCache(string key, bool isFullKey = false)
{
if (string.IsNullOrEmpty(key))
{
return;
}
var cacheKey = GetFinalKey(key, isFullKey);
SenparcMessageQueue.OperateQueue(); //延迟缓存立即生效
base.Client.Del(cacheKey); //删除键
}
public void RemoveFromCache(string key, bool isFullKey = false)
{
if (string.IsNullOrEmpty(key))
{
return;
}
var cacheKey = GetFinalKey(key, isFullKey);
SenparcMessageQueue.OperateQueue(); //延迟缓存立即生效
_cache.KeyDelete(cacheKey); //删除键
}
public override async Task RemoveFromCacheAsync(string key, bool isFullKey = false)
{
if (string.IsNullOrEmpty(key))
{
return;
}
var cacheKey = GetFinalKey(key, isFullKey);
SenparcMessageQueue.OperateQueue(); //延迟缓存立即生效
await base.Client.DelAsync(cacheKey).ConfigureAwait(false); //删除键
}
/// <summary>
/// 操作列队
/// </summary>
private void OperateQueue()
{
var mq = new SenparcMessageQueue();
var key = mq.GetCurrentKey(); //获取最新的Key
while (!string.IsNullOrEmpty(key))
{
var mqItem = mq.GetItem(key); //获取任务项
mqItem.Action(); //执行
mq.Remove(key); //清除
key = mq.GetCurrentKey(); //获取最新的Key
}
}
public ActionResult RunTest()
{
var sb = new StringBuilder();
var containerCacheStragegy = CacheStrategyFactory.GetContainerCacheStragegyInstance();
sb.AppendFormat("{0}：{1}<br />", "当前缓存策略", containerCacheStragegy.GetType().Name);
for (int i = 0; i < 3; i++)
{
sb.AppendFormat("<br />====== {0}：{1} ======<br /><br />", "开始一轮测试", i + 1);
var bagKey = DateTime.Now.Ticks.ToString();
var bag = new TestContainerBag1()
{
Key = bagKey,
DateTime = DateTime.Now
};
TestContainer1.Update(bagKey, bag);
sb.AppendFormat("{0}：{1}（Ticks：{2}）<br />", "bag.DateTime", bag.DateTime.ToLongTimeString(), bag.DateTime.Ticks);
Thread.Sleep(1);
bag.DateTime = DateTime.Now;//进行修改
//读取列队
var mq = new SenparcMessageQueue();
var mqKey = SenparcMessageQueue.GenerateKey("ContainerBag", bag.GetType(), bag.Key, "UpdateContainerBag");
var mqItem = mq.GetItem(mqKey);
sb.AppendFormat("{0}：{1}（Ticks：{2}）<br />", "bag.DateTime", bag.DateTime.ToLongTimeString(), bag.DateTime.Ticks);
sb.AppendFormat("{0}：{1}<br />", "已经加入列队", mqItem != null);
sb.AppendFormat("{0}：{1}<br />", "当前消息列队数量（未更新缓存）", mq.GetCount());
var cacheKey = TestContainer1.GetCacheKey();
var itemCollection = containerCacheStragegy.Get(cacheKey);
sb.AppendFormat("{0}：{1}<br />", "当前缓存是否存在", itemCollection.CheckExisted(bagKey));
sb.AppendFormat("{0}：{1}<br />", "插入缓存时间", itemCollection[bagKey].CacheTime.Ticks);//应为0
var waitSeconds = i;
sb.AppendFormat("{0}：{1}<br />", "操作", "等待" + waitSeconds + "秒");
Thread.Sleep(waitSeconds * 1000);//线程默认轮询等待时间为2秒
sb.AppendFormat("{0}：{1}<br />", "当前消息列队数量（未更新缓存）", mq.GetCount());
itemCollection = containerCacheStragegy.Get(cacheKey);
sb.AppendFormat("{0}：{1}<br />", "当前缓存是否存在", itemCollection.CheckExisted(bagKey));
sb.AppendFormat("{0}：{1}（Ticks：{2}）<br />", "插入缓存时间", itemCollection[bagKey].CacheTime.ToLongTimeString(), itemCollection[bagKey].CacheTime.Ticks);//应为当前加入到缓存的最新时间
}
return(Content(sb.ToString()));
//ViewData["Result"] = sb.ToString();
//return View();
}
public override async Task RemoveFromCacheAsync(string key, bool isFullKey = false)
{
if (string.IsNullOrEmpty(key))
{
return;
}
//var cacheKey = GetFinalKey(key, isFullKey);
var hashKeyAndField = this.GetHashKeyAndField(key);
SenparcMessageQueue.OperateQueue(); //延迟缓存立即生效
//_cache.KeyDelete(cacheKey);//删除键
await _cache.HashDeleteAsync(hashKeyAndField.Key, hashKeyAndField.Field).ConfigureAwait(false); //删除项
}
public void RemoveFromCache(string key, bool isFullKey = false)
{
if (string.IsNullOrEmpty(key))
{
return;
}
//var cacheKey = GetFinalKey(key, isFullKey);
var hashKeyAndField = this.GetHashKeyAndField(key);
SenparcMessageQueue.OperateQueue(); //延迟缓存立即生效
//_cache.KeyDelete(cacheKey);//删除键
_cache.HashDelete(hashKeyAndField.Key, hashKeyAndField.Field); //删除项
}
/// <summary>
/// 保存请求信息
/// <para>测试时可开启此记录，帮助跟踪数据，使用前请确保App_Data文件夹存在，且有读写权限。</para>
/// </summary>
/// <param name="logPath">保存日志目录，默认为 ~/App_Data/<模块类型>/<yyyy-MM-dd>/</param>
public void SaveRequestMessageLog(string logPath = null)
{
try
{
logPath = logPath ?? GetLogPath();
SenparcMessageQueue queue = new SenparcMessageQueue();
var key = Guid.NewGuid().ToString();
queue.Add(key, async() =>
{
if (this.RequestDocument != null)
{
var filePath = Path.Combine(logPath, string.Format("{0}_Request_{1}_{2}.txt", _getRandomFileName(),
this.RequestMessage?.FromUserName,
this.RequestMessage?.MsgType));
#if NETSTANDARD2_1_OR_GREATER
using (var fs = new FileStream(filePath, FileMode.CreateNew))
{
await this.RequestDocument.SaveAsync(fs, System.Xml.Linq.SaveOptions.None, new CancellationToken());
}
#else
this.RequestDocument.Save(filePath);
#endif
}
else
{
System.IO.File.WriteAllText(Path.Combine(logPath, string.Format("{0}_UntreatedRequest.txt", _getRandomFileName())),
this.TextResponseMessage);
}
if (this.UsingEncryptMessage && this.EcryptRequestDocument != null)
{
var filePath = Path.Combine(logPath, string.Format("{0}_Request_Ecrypt_{1}_{2}.txt", _getRandomFileName(),
this.RequestMessage.FromUserName,
this.RequestMessage.MsgType));
#if NETSTANDARD2_1_OR_GREATER
using (var fs = new FileStream(filePath, FileMode.CreateNew))
{
await this.RequestDocument.SaveAsync(fs, System.Xml.Linq.SaveOptions.None, new CancellationToken());
}
#else
this.EcryptRequestDocument.Save(filePath);
#endif
}
});
}
catch (Exception ex)
{
_ = new MessageHandlerException(ex.Message, ex);
}
}
public void Run()
{
do
{
var mq = new SenparcMessageQueue();
var key = mq.GetCurrentKey();//获取最新的Key
while (!string.IsNullOrEmpty(key))
{
var mqItem = mq.GetItem(key); //获取任务项
mqItem.Action(); //执行
mq.Remove(key); //清除
key = mq.GetCurrentKey(); //获取最新的Key
}
Thread.Sleep(_sleepMilliSeconds);
} while (true);
}
private void BaseContainerBag_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
var containerBag = (IBaseContainerBag)sender;
var key = SenparcMessageQueue.GenerateKey("ContainerBag", sender.GetType(), containerBag.Key, "UpdateContainerBag");
//获取对应Container的缓存相关
//加入消息列队，每过一段时间进行自动更新，防止属性连续被编辑，短时间内反复更新缓存。
SenparcMessageQueue mq = new SenparcMessageQueue();
mq.Add(key, () =>
{
var containerCacheStragegy = CacheStrategyFactory.GetContainerCacheStragegyInstance();
containerCacheStragegy.UpdateContainerBag(key, containerBag);
containerBag.CacheTime = DateTime.Now;//记录缓存时间
});
}
public void SenparcMessageQueueTest()
{
var smq = new SenparcMessageQueue();
var keyPrefix = "TestMQ_";
var count = smq.GetCount();
for (int i = 0; i < 3; i++)
{
var key = keyPrefix + i;
//测试Add
smq.Add(key, () =>
{
Console.WriteLine("执行队列：" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ffffff"));
});
Console.WriteLine("添加队列项：" + key);
Console.WriteLine("当前数量：" + smq.GetCount());
Console.WriteLine("CurrentKey：" + smq.GetCurrentKey());
Assert.AreEqual(count + 1, smq.GetCount());
count = smq.GetCount();
//测试GetItem
var item = smq.GetItem(key);
Console.WriteLine("item.AddTime：" + item.AddTime);
Assert.AreEqual(key, item.Key);
}
//测试Remove
smq.Add("ToRemove", () =>
{
Console.WriteLine("如果看到这一条，说明没有清楚成功");
});
smq.Remove("ToRemove");
//启动线程
ThreadUtility.Register();
while (smq.GetCount() > 0)
{
//等待队列处理完
}
Console.WriteLine("队列处理完毕，当前队列数量：" + smq.GetCount());
}
public void FlushCacheTest()
{
var smq = new SenparcMessageQueue();
using (var flushCache = new FlushCache())
{
for (int i = 0; i < 10; i++)
{
smq.Add("测试" + Guid.NewGuid().ToString(), () =>
{
Console.WriteLine("执行队列：" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ffffff"));
});
}
}//立即执行所有队列
//已经执行完
Assert.AreEqual(0, smq.GetCount());
}
/// <summary>
/// 客服消息返回用户信息
/// </summary>
/// <param name="openId"></param>
/// <param name="responseMessage"></param>
/// <returns></returns>
public IResponseMessageBase SendKfMessage(string openId, IResponseMessageBase responseMessage)
{
var messageQueue = new SenparcMessageQueue();
if (responseMessage is ResponseMessageText)
{
{
var myKey = SenparcMessageQueue.GenerateKey("MessageHandlerSendMessageAsync", responseMessage.GetType(),
Guid.NewGuid().ToString(), "SendMessage");
messageQueue.Add(myKey, () =>
{
var kfResponseMessage = responseMessage as ResponseMessageText;
if (kfResponseMessage != null)
{
kfResponseMessage.Content += "\r\n【客服消息队列-1】";
//在队列中发送消息
CustomApi.SendText(Config.AppId, openId, kfResponseMessage.Content);
}
});
}
{
var myKey = SenparcMessageQueue.GenerateKey("MessageHandlerSendMessageAsync", responseMessage.GetType(),
Guid.NewGuid().ToString(), "SendMessage");
messageQueue.Add(myKey, () =>
{
var kfResponseMessage = responseMessage as ResponseMessageText;
if (kfResponseMessage != null)
{
kfResponseMessage.Content += "\r\n【客服消息队列-2】";
//在队列中发送消息
CustomApi.SendText(Config.AppId, openId, kfResponseMessage.Content);
}
});
}
}
return(new ResponseMessageNoResponse());
}
private void BaseContainerBag_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
var containerBag = (IBaseContainerBag)sender;
var mqKey = SenparcMessageQueue.GenerateKey("ContainerBag", sender.GetType(), containerBag.Key, "UpdateContainerBag");
//获取对应Container的缓存相关
//加入消息列队，每过一段时间进行自动更新，防止属性连续被编辑，短时间内反复更新缓存。
SenparcMessageQueue mq = new SenparcMessageQueue();
mq.Add(mqKey, () =>
{
var containerCacheStragegy = CacheStrategyFactory.GetContainerCacheStragegyInstance();
var itemCacheKey = ContainerHelper.GetItemCacheKey(containerBag);
containerBag.CacheTime = DateTime.Now;//记录缓存时间
//cacheKey形如:Container:Senparc.Weixin.MP.Containers.AccessTokenBag:wx669ef95216eef885
containerCacheStragegy.UpdateContainerBag(itemCacheKey, containerBag);
});
}
public void LogTest()
{
//直接调用此方法不会记录到log文件中，而是输出到系统日志中
var keyword = Guid.NewGuid().ToString();//随机字符串
SenparcTrace.Log($"添加Log：{keyword}");
var dt1 = SystemTime.Now;
while (SystemTime.DiffTotalMS(dt1) < 600)
{
//等待队列执行
}
SenparcMessageQueue.OperateQueue();
Console.WriteLine(SenparcMessageQueue.MessageQueueDictionary.Count);
Console.WriteLine(ThreadUtility.AsynThreadCollection.Count);
//Assert.IsTrue(UnitTestHelper.CheckKeywordsExist(_logFilePath,keyword));
}
public IResponseMessageBase SendMessage(string openId, IResponseMessageBase responseMessage)
{
var messageQueue = new SenparcMessageQueue();
if (responseMessage is ResponseMessageText)
{
{
var mqKey = SenparcMessageQueue.GenerateKey("MessageHandlerSendMessageAsync", responseMessage.GetType(), Guid.NewGuid().ToString(), "SendMessage");
messageQueue.Add(mqKey, () =>
{
var asyncResponseMessage = responseMessage as ResponseMessageText;
asyncResponseMessage.Content += "\r\n\r\n - 这条消息来自客服接口-1";
//发送客服消息
CustomApi.SendText(Config.AppId, openId, asyncResponseMessage.Content);
});
}
{
var mqKey = SenparcMessageQueue.GenerateKey("MessageHandlerSendMessageAsync", responseMessage.GetType(), Guid.NewGuid().ToString(), "SendMessage");
messageQueue.Add(mqKey, () =>
{
var asyncResponseMessage = responseMessage as ResponseMessageText;
asyncResponseMessage.Content += "\r\n\r\n - 这条消息来自客服接口-2";
//发送客服消息
CustomApi.SendText(Config.AppId, openId, asyncResponseMessage.Content);
});
}
return(new ResponseMessageNoResponse());
}
//else if ()
//{
// //...
//}
return(responseMessage);
}
public void RunTest()
{
//默认情况下ThreadUtility应该已经将SenparcMessageQueueThreadUtility加入列队
//下面对Container进行测试
var c1 = TestContainer1.GetCollectionList();
var key = DateTime.Now.Ticks.ToString();
var bag = new TestContainerBag1()
{
Key = key,
DateTime = DateTime.Now
};
TestContainer1.Update(key, bag);
bag.DateTime = DateTime.MinValue;//进行修改
//读取列队
var mq = new SenparcMessageQueue();
var mqKey = SenparcMessageQueue.GenerateKey("A", typeof(TestContainerBag1), bag.Key, "B");
var mqItem = mq.GetItem(mqKey);
Assert.IsNotNull(mqItem);
}
public ActionResult RunTest()
{
var sb = new StringBuilder();
//var containerCacheStrategy = CacheStrategyFactory.GetContainerCacheStrategyInstance();
var containerCacheStrategy = ContainerCacheStrategyFactory.GetContainerCacheStrategyInstance() /*.ContainerCacheStrategy*/;
var baseCacheStrategy = containerCacheStrategy.BaseCacheStrategy();
sb.AppendFormat("{0}：{1}<br />", "当前缓存策略", containerCacheStrategy.GetType().Name);
var finalExisted = false;
for (int i = 0; i < 3; i++)
{
sb.AppendFormat("<br />====== {0}：{1} ======<br /><br />", "开始一轮测试", i + 1);
var shortBagKey = SystemTime.Now.ToString("yyyyMMdd-HHmmss");
var finalBagKey = baseCacheStrategy.GetFinalKey(ContainerHelper.GetItemCacheKey(typeof(TestContainerBag1), shortBagKey));//获取最终缓存中的键
var bag = new TestContainerBag1()
{
Key = shortBagKey,
DateTime = SystemTime.Now
};
TestContainer1.Update(shortBagKey, bag, TimeSpan.FromHours(1)); //更新到缓存（立即更新）
sb.AppendFormat("{0}：{1}<br />", "bag.DateTime", bag.DateTime.ToString("o"));
Thread.Sleep(1);
bag.DateTime = SystemTime.Now; //进行修改
//读取队列
var mq = new SenparcMessageQueue();
var mqKey = SenparcMessageQueue.GenerateKey("ContainerBag", bag.GetType(), bag.Key, "UpdateContainerBag");
var mqItem = mq.GetItem(mqKey);
sb.AppendFormat("{0}：{1}<br />", "bag.DateTime", bag.DateTime.ToString("o"));
sb.AppendFormat("{0}：{1}<br />", "已经加入队列", mqItem != null);
sb.AppendFormat("{0}：{1}<br />", "当前消息队列数量（未更新缓存）", mq.GetCount());
if (mq.GetCount() >= 3)
{
//超过3是不正常的，或有其他外部干扰
sb.AppendFormat("<br>=====MQ队列（{0}）start=======<br>", mq.GetCount());
foreach (var item in SenparcMessageQueue.MessageQueueDictionary)
{
sb.AppendFormat("{0}：{1}<br />", item.Key, item.Value.Key);
}
sb.AppendFormat("=====MQ队列（{0}）=======<br><br>", mq.GetCount());
}
var itemCollection = containerCacheStrategy.GetAll <TestContainerBag1>();
var existed = itemCollection.ContainsKey(finalBagKey);
sb.AppendFormat("{0}：{1}<br />", "当前缓存是否存在", existed);
sb.AppendFormat("{0}：{1}<br />", "插入缓存时间",
!existed ? "不存在" : itemCollection[finalBagKey].CacheTime.ToString("o")); //应为0
var waitSeconds = i;
sb.AppendFormat("{0}：{1}<br />", "操作", "等待" + waitSeconds + "秒");
Thread.Sleep(waitSeconds * 1000); //队列线程默认轮询等待时间为1秒，当等待时间超过1秒时，应该都已经处理完毕
sb.AppendFormat("{0}：{1}<br />", "当前消息队列数量（未更新缓存）", mq.GetCount());
itemCollection = containerCacheStrategy.GetAll <TestContainerBag1>();
existed = itemCollection.ContainsKey(finalBagKey);
finalExisted = existed && itemCollection[finalBagKey].CacheTime.Date == SystemTime.Now.Date;
sb.AppendFormat("{0}：{1}<br />", "当前缓存是否存在", existed);
sb.AppendFormat("{0}：{1}<br />", "插入缓存时间",
!existed ? "不存在" : itemCollection[finalBagKey].CacheTime.ToString("o")); //应为当前加入到缓存的最新时间
}
sb.AppendFormat("<br />============<br /><br />");
sb.AppendFormat("{0}：{1}<br />", "测试结果", !finalExisted ? "失败" : "成功");
return(Content(sb.ToString()));
//ViewData["Result"] = sb.ToString();
//return View();
}
