//This is the "UI entry point" and as such will handle the UI update by another thread
public void HandleMessage(IBMessage message)
{
if (this.InvokeRequired)
{
MessageHandlerDelegate callback = new MessageHandlerDelegate(HandleMessage);
this.Invoke(callback, new object[] { message });
}
else
{
UpdateUI(message);
}
}
public void SetHandler(string msgCode, MessageHandlerDelegate handler)
{
responseHandlers.SetHandler(msgCode, handler);
}
public void SetHandler(string msgCode, MessageHandlerDelegate handler)
{
handlers.Add(msgCode, handler);
}
/// <summary>
/// Registers an entity for a message type
/// </summary>
/// <param name="type">Message type the entity is going to register</param>
/// <param name="entityID">The entity that its registering</param>
/// <param name="handler">The handler delegate that should be called when a message arrives for this entity</param>
public void RegisterForMessage(MessageType type, int entityID, MessageHandlerDelegate handler)
{
//If the table for this type of message didn´t exist we set it up and register ourselves
if (registeredEntities[type] == null)
{
registeredEntities[type] = new Dictionary<int, MessageHandlerDelegate>();
registeredEntities[type][entityID] = handler;
return;
}
//If another handler existed it will be overriden
registeredEntities[type][entityID] = handler;
}
public void RegisterClientMessage(ushort msgType, MessageHandlerDelegate handlerDelegate)
{
Client.RegisterMessage(msgType, handlerDelegate);
}
public void SetHandler(Guid msgId, MessageHandlerDelegate handler)
{
//set a timeout to remove item
handlers.Add(msgId, handler);
}
public async Task <TResponse> Dispatch <TMessageContext, TMessage, TResponse>(TMessageContext context, MessageHandlerDelegate <TMessageContext, TMessage, TResponse> endDelegate)
where TMessageContext : MessageContext <TMessage>
{
Guard.NotNull(endDelegate, nameof(endDelegate));
Guard.NotNull(context, nameof(context));
using (this.callScopeFactory.CreateScope())
{
var filters = this.messageHandlerFactory.Create <TMessageContext, TMessage, TResponse>();
return(await filters.Reverse().Aggregate(
endDelegate,
(nextHandler, filter) => ctx => filter.Handle(ctx, nextHandler))(context));
}
}
public void RegisterServerMessage(ushort msgType, MessageHandlerDelegate handlerDelegate)
{
Server.RegisterMessage(msgType, handlerDelegate);
}
public void Register()
{
// Make a copy of the delegate
Del = Handler;
register_message_handler(Del);
}
public static extern void register_message_handler(MessageHandlerDelegate del);
public void RegisterMessage(ushort msgType, MessageHandlerDelegate handlerDelegate)
{
messageHandlers[msgType] = handlerDelegate;
}
public Task Respond <TResponse>(SendContext <TResponse> context)
where TResponse : class
{
MessageHandlerDelegate <SendContext <TResponse>, TResponse, EmptyResponse> endDelegate = async c =>
{
await this.GetChannel <TResponse>().Respond(c);
return(EmptyResponse.Instance);
};
return(this.DispatchInternal(context, endDelegate));
}
public IDisposable Build(MessageHandlerDelegate <TMessage> callback)
{
return(_transporter.RegisterMessageHandler <TMessage>(callback));
}
public void RegisterHandler(ushort msgType, MessageHandlerDelegate handler)
{
m_Handlers.Add(msgType, handler);
}
protected void TryRegisterMessageHandler <T>(MessageHandlerDelegate <T> handler) where T : IMessage
