public async Task <IMessageObject> SendMessageAsync(string message)
{
IMessageObject m = null;
channel
return(m);
}
public bool AddListener(IMessageObject l)
{
if (UniqueListener && Listeners.Count != 0)
return false;
Listeners.Add(l);
return true;
}
/// <summary>接收数据</summary>
/// <returns></returns>
public virtual IMessageObject Receive()
{
// 阻塞方式
IMessageObject data = null;
lock (lockObject)
{
if (queue == null)
{
InitializeQueue();
}
try
{
data = new MessageObject();
Message message = queue.Receive(new TimeSpan(0, 0, 10)); // 等待10秒
XmlDocument doc = new XmlDocument();
doc.LoadXml(message.Body.ToString());
data.Deserialize(doc.DocumentElement);
return(data);
}
catch
{
this.Close();
}
}
return(null);
}
/// <summary>发送数据</summary>
/// <param name="data"></param>
public virtual void Send(IMessageObject data)
{
if (data == null)
{
return;
}
lock (lockObject)
{
if (this.channel == null)
{
InitializeQueue();
}
try
{
// 在 MQ 上定义一个持久化队列，如果名称相同不会重复创建
channel.QueueDeclare(this.QueueName, true, false, false, null);
byte[] bytes = Encoding.UTF8.GetBytes(data.Serializable());
// 设置消息持久化
IBasicProperties properties = channel.CreateBasicProperties();
properties.DeliveryMode = 2;
channel.BasicPublish(string.Empty, this.QueueName, properties, bytes);
}
catch (Exception ex)
{
MessageQueueManagement.Log.Error(ex.Message, ex);
}
}
}
/// <summary>运行</summary>
public void Run()
{
if (running)
{
return;
}
try
{
running = true;
// 开始时间
TimeSpan beginTimeSpan = new TimeSpan(DateTime.Now.Ticks);
// 发送待办
ServiceTrace.Instance.WriteLine("正在检测是否有任务需要发送。");
// 接收待办信息
IMessageObject message = queue.Receive();
if (message != null)
{
// 发送待办
ServiceTrace.Instance.WriteLine("正在发送任务信息。");
int count = 0;
while (message != null)
{
if (message is TaskWorkInfo)
{
TasksContext.Instance.TaskService.Save((TaskWorkInfo)message);
count++;
}
message = queue.Receive();
}
// 成功发送待办
ServiceTrace.Instance.WriteLine("已成功发送【" + count + "】条任务信息。");
}
this.nextRunTime = DateTime.Now.AddSeconds(this.interval);
running = false;
}
catch (Exception ex)
{
// 发生异常是, 记录异常信息 并把运行标识为false.
ServiceTrace.Instance.WriteLine(ex.ToString());
EventLogHelper.Write(string.Format("{0} 监听器发生异常信息\r\n{1}。", this.Name, ex));
running = false;
}
}
public void TestReceive()
{
IMessageQueueObject messageQueueObject = MessageQueueManagement.GetMessageQueueInstance("MSMQ_Messages");
if (messageQueueObject.Enabled)
{
IMessageObject message = messageQueueObject.Receive();
}
}
public HEMessage(IMessageObject message)
{
Id = message.Id;
Message = message.Message;
Detail = message.Detail;
Type = message.Type.ToHEMessageType();
ExtraInfo = message.ExtraInfo;
HelpRef = message.HelpRef;
}
public async Task PingAsync(IMessageObject message)
{
Task <IMessageObject> sendMessage = message.Channel.SendMessageAsync("wait up...");
IMessageObject m = await sendMessage;
Task.WaitAll(sendMessage);
await m.ModifyAsync($"pong! {(m.CreatedAt - message.CreatedAt).TotalMilliseconds}ms!");
}
public static void IfInvoke <TKey>(this IMessageObject <TKey> message, Type exptecedMessageType, Action action)
{
Type msgType = message.GetType();
ThrowOnNotAssignable(typeof(IMessageObject <TKey>), exptecedMessageType);
if (msgType == exptecedMessageType)
{
action();
}
}
///<summary>
/// Execute a Command Async on this message object for all registered receivers.
///</summary>
public async Task CommandAsync(IMessageObject <TKey> message)
{
CheckNull(message);
var tasks = new List <Task>();
ForAllReceivers(message.Receivers)
.ForAll
(
x => tasks.Add(x.ReceiveCommandAsync(message))
);
await Task.WhenAll(tasks);
}
/// <summary>
/// Updates the state.
/// </summary>
/// <param name="state">The state.</param>
/// <returns></returns>
public override bool UpdateState(IMessageObject state)
{
var result = false;
var source = state as Outcome;
if (source != null)
{
Status = source.Status;
LastError = source.LastError;
result = true;
}
return(result);
}
public async Task MessageReceived(IMessageObject message)
{
foreach (Prefix p in _prefixes)
{
if (message.Content.StartsWith(p.Value))
{
string command = message.Content
.Substring(p.Value.Length)
.Split(' ')[0]
.ToLower();
if (cachedCommands.ContainsKey(command))
{
Command commandObject = cachedCommands[command];
if (OnPreCommandExecute != null)
{
if (!await OnPreCommandExecute.Invoke(commandObject))
{
if (OnPostCommandExecute != null)
{
await OnPreCommandFailure.Invoke(commandObject);
}
return;
}
}
Stopwatch timeTaken = Stopwatch.StartNew();
try
{
await cachedCommands[command].ProcessCommand(message);
timeTaken.Stop();
if (OnPostCommandExecute != null)
{
await OnPostCommandExecute(commandObject, timeTaken.ElapsedMilliseconds, true);
}
}
catch (Exception e)
{
timeTaken.Stop();
if (OnPostCommandExecute != null)
{
await OnPostCommandExecute(commandObject, timeTaken.ElapsedMilliseconds, false);
}
}
}
}
}
}
public void AddMessage(IMessageObject msg)
{
this.Errors.AddRange(msg.Errors);
this.Warnings.AddRange(msg.Warnings);
this.Confirmations.AddRange(msg.Confirmations);
this.Informations.AddRange(msg.Informations);
if (this.Exception == null)
{
this.Exception = msg.Exception;
}
if (this.ProcessingStatus && !msg.ProcessingStatus)
{
this.ProcessingStatus = msg.ProcessingStatus;
}
}
public bool Remove(IMessageObject messageObject)
{
if (_removeHelper.ContainsKey(messageObject) == false)
{
return(false);
}
List <eMessage> messages = _removeHelper[messageObject];
for (int i = 0; i < messages.Count; ++i)
{
_messageObjects[(int)messages[i]].Remove(messageObject);
}
_removeHelper.Remove(messageObject);
return(true);
}
/// <summary>接收数据</summary>
/// <returns></returns>
public override IMessageObject Receive()
{
// 阻塞方式
IMessageObject data = null;
lock (lockObject)
{
if (queue == null)
{
this.queue = this.GetQueueInstance();
}
try
{
data = new TaskWorkInfo();
// 如果消息队列为空时, 将会导致无限期占用线程, 设置等待10秒钟Receive()函数无响应，则返回空值。
Message message = queue.Receive(new TimeSpan(0, 0, 10));
XmlDocument doc = new XmlDocument();
doc.LoadXml(message.Body.ToString());
data.Deserialize(doc.DocumentElement);
return(data);
}
catch (MessageQueueException messageQueueException)
{
if (messageQueueException.MessageQueueErrorCode == MessageQueueErrorCode.IOTimeout)
{
// 等待10秒钟Receive()函数无响应，则返回空值。
return(null);
}
throw;
}
catch
{
this.Close();
throw;
}
}
}
public bool Add(eMessage type, IMessageObject messageObject)
{
if ((uint)type >= (uint)eMessage.TypeEnd)
{
return(false);
}
if (_messageObjects[(int)type].Contains(messageObject) == true)
{
return(false);
}
_messageObjects[(int)type].Add(messageObject);
if (_removeHelper.ContainsKey(messageObject) == false)
{
_removeHelper.Add(messageObject, new List <eMessage>());
}
_removeHelper[messageObject].Add(type);
return(true);
}
/// <summary>异步接收待办信息</summary>
public void AsyncReceive()
{
IMessageObject message = this.queue.Receive();
while (message != null)
{
if (message is TaskWorkInfo)
{
try
{
this.provider.Save((TaskWorkInfo)message);
}
catch (Exception ex)
{
this.queue.Send(message);
throw ex;
}
}
message = this.queue.Receive();
}
}
/// <summary>发送数据</summary>
/// <param name="data"></param>
public virtual void Send(IMessageObject data)
{
if (data == null)
{
return;
}
lock (lockObject)
{
try
{
if (queue == null)
{
this.queue = this.GetQueueInstance();
}
Message message = new Message();
message.Formatter = new XmlMessageFormatter(new Type[] { typeof(string) });
message.Priority = MessagePriority.Normal; // 消息优先级
message.Recoverable = true; // 可回收的
message.Body = data.Serializable();
queue.Send(message);
}
catch (Exception ex)
{
this.Close();
throw ex;
}
}
}
/// <summary>
/// Updates the state.
/// </summary>
/// <param name="state">The state.</param>
/// <returns></returns>
public virtual bool UpdateState(IMessageObject state)
{
throw new NotImplementedException();
}
public virtual void ReceiveCommand(IMessageObject <TKey> message) => messages[message.GetType()].Invoke(message);
/// <summary>接收数据</summary>
/// <returns></returns>
public virtual IMessageObject Receive()
{
// 阻塞方式
IMessageObject data = null;
lock (lockObject)
{
if (this.channel == null)
{
InitializeQueue();
}
try
{
data = new T();
BasicGetResult result = channel.BasicGet(this.QueueName, false);
if (result == null)
{
return(null);
}
else
{
byte[] bytes = result.Body;
XmlDocument doc = new XmlDocument();
doc.LoadXml(Encoding.UTF8.GetString(bytes));
data.Deserialize(doc.DocumentElement);
// 回复确认
channel.BasicAck(result.DeliveryTag, false);
return(data);
}
/*
* // 回复确认
* channel.BasicAck(result.DeliveryTag, false);
*
* //在MQ上定义一个持久化队列，如果名称相同不会重复创建
* channel.QueueDeclare(this.QueueName, true, false, false, null);
*
* // 输入1，那如果接收一个消息，但是没有应答，则客户端不会收到下一个消息
* channel.BasicQos(0, 1, false);
*
* // 在队列上定义一个消费者
* QueueingBasicConsumer consumer = new QueueingBasicConsumer(channel);
*
* // 消费队列，并设置应答模式为程序主动应答
* channel.BasicConsume(this.QueueName, false, consumer);
*
* // 阻塞函数，获取队列中的消息
* // BasicDeliverEventArgs ea = (BasicDeliverEventArgs)consumer.Queue.Dequeue();
* BasicDeliverEventArgs ea = (BasicDeliverEventArgs)consumer.Queue.DequeueNoWait(null);
* if (ea == null)
* {
* return null;
* }
* else
* {
* byte[] bytes = ea.Body;
*
* XmlDocument doc = new XmlDocument();
*
* doc.LoadXml(Encoding.UTF8.GetString(bytes));
*
* data.Deserialize(doc.DocumentElement);
*
* // 回复确认
* channel.BasicAck(ea.DeliveryTag, false);
*
* return data;
* }*/
}
catch (Exception ex)
{
MessageQueueManagement.Log.Error(ex.Message, ex);
}
}
return(null);
}
public Task ReceiveCommandAsync(IMessageObject <TKey> message) => asyncMessages[message.GetType()].InvokeAsync(message);
public bool Equals(IMessageObject <string> other)
{
throw new NotImplementedException();
}
public bool RemoveListener(IMessageObject l)
{
return Listeners.Remove(l);
}
/// <summary>
/// Removes a listener for a particular message
/// </summary>
/// <param name="listener">the listener object</param>
/// <param name="msg">Message to register to</param>
/// <returns></returns>
public bool RmoveListener(IMessageObject listener, String msg)
{
if (!_messageTypes.ContainsKey(msg))
{
return false;
}
return _messageTypes[msg].RemoveListener(listener);
}
public Task CommandAsync(IMessageObject <string> message)
{
SentMessage = message;
return(Task.CompletedTask);
}
public void Command(IMessageObject <string> message)
{
SentMessage = message;
}
public bool Equals(IMessageObject <string> other) => other == this;
public static void IfInvoke <TKey, ExpectedMessageType>(this IMessageObject <TKey> message, Action action)
where ExpectedMessageType : IMessageObject <TKey>
{
message.IfInvoke(typeof(ExpectedMessageType), action);
}
public virtual bool Equals(IMessageObject <TKey> other) => Receivers.Equals(other.Receivers) && Sender.Equals(other.Sender);
///<summary>
/// Execute a Command on this messageObject for all registered receivers in the message
///</summary>
public void Command(IMessageObject <TKey> message)
{
CheckNull(message);
ForAllReceivers(message.Receivers).ForAll(x => x.ReceiveCommand(message));
}
