private Task <AsyncTaskResult> DispatchMessages(IEnumerable <IMessage> messages)
{
var messageCount = messages.Count();
if (messageCount == 0)
{
return(Task.FromResult <AsyncTaskResult>(AsyncTaskResult.Success));
}
var rootDispatching = new RootDisptaching();
//先对每个事件调用其Handler
var queueMessageDispatching = new QueueMessageDisptaching(this, rootDispatching, messages);
DispatchSingleMessage(queueMessageDispatching.DequeueMessage(), queueMessageDispatching);
//如果有至少两个事件，则尝试调用针对两个事件的Handler
if (messageCount >= 2)
{
var twoMessageHandlers = _twoMessageHandlerProvider.GetHandlers(messages.Select(x => x.GetType()));
if (twoMessageHandlers.IsNotEmpty())
{
DispatchMultiMessage(messages, twoMessageHandlers, rootDispatching, DispatchTwoMessageToHandlerAsync);
}
}
//如果有至少三个事件，则尝试调用针对三个事件的Handler
if (messageCount >= 3)
{
var threeMessageHandlers = _threeMessageHandlerProvider.GetHandlers(messages.Select(x => x.GetType()));
if (threeMessageHandlers.IsNotEmpty())
{
DispatchMultiMessage(messages, threeMessageHandlers, rootDispatching, DispatchThreeMessageToHandlerAsync);
}
}
return(rootDispatching.Task);
}
public QueueMessageDisptaching(DefaultMessageDispatcher dispatcher, RootDisptaching rootDispatching, IEnumerable <IMessage> messages)
{
_dispatcher = dispatcher;
_messageQueue = new ConcurrentQueue <IMessage>();
messages.ForEach(message => _messageQueue.Enqueue(message));
_rootDispatching = rootDispatching;
_rootDispatching.AddChildDispatching(this);
}
public MultiMessageDisptaching(IEnumerable <IMessage> messages, IEnumerable <IObjectProxy> handlers, RootDisptaching rootDispatching, ITypeNameProvider typeNameProvider)
{
Messages = messages.ToArray();
_handlerDict = new ConcurrentDictionary <string, IObjectProxy>();
handlers.ForEach(x => _handlerDict.TryAdd(typeNameProvider.GetTypeName(x.GetInnerObject().GetType()), x));
_rootDispatching = rootDispatching;
_rootDispatching.AddChildDispatching(this);
}
private void DispatchMultiMessage <T>(IEnumerable <IMessage> messages, IEnumerable <MessageHandlerData <T> > messageHandlerDataList, RootDisptaching rootDispatching, Action <MultiMessageDisptaching, T, QueuedHandler <T>, int> dispatchAction) where T : class, IObjectProxy
{
foreach (var messageHandlerData in messageHandlerDataList)
{
var multiMessageDispatching = new MultiMessageDisptaching(messages, messageHandlerData.AllHandlers, rootDispatching, _typeNameProvider);
if (messageHandlerData.ListHandlers != null && messageHandlerData.ListHandlers.IsNotEmpty())
{
foreach (var handler in messageHandlerData.ListHandlers)
{
dispatchAction(multiMessageDispatching, handler, null, 0);
}
}
if (messageHandlerData.QueuedHandlers != null && messageHandlerData.QueuedHandlers.IsNotEmpty())
{
var queuedHandler = new QueuedHandler <T>(messageHandlerData.QueuedHandlers,
(currentQueuedHandler, nextHandler) => dispatchAction(multiMessageDispatching, nextHandler, currentQueuedHandler, 0));
dispatchAction(multiMessageDispatching, queuedHandler.DequeueHandler(), queuedHandler, 0);
}
}
}
