public void Subscribe <T>(IHandle <T> handler) where T : Message
{
Ensure.NotNull(handler, "handler");
List <Type> descendants;
if (!MessageHierarchy.Descendants.TryGetValue(typeof(T), out descendants))
{
throw new Exception(string.Format("No descendants for message of type '{0}'.", typeof(T).Name));
}
foreach (var descendant in descendants)
{
List <IMessageHandler> handlers;
if (!_typeHash.TryGetValue(descendant, out handlers))
{
handlers = new List <IMessageHandler>();
_typeHash.Add(descendant, handlers);
}
if (!handlers.Any(x => x.IsSame <T>(handler)))
{
handlers.Add(new MessageHandler <T>(handler, handler.GetType().Name));
}
}
}
public IDisposable Subscribe <T>(IHandle <T> handler) where T : Message
{
Ensure.NotNull(handler, "handler");
Subscribe(new MessageHandler <T>(handler, handler.GetType().Name));
// ReSharper disable once ConstantConditionalAccessQualifier
return(new Disposer(() => { this?.Unsubscribe(handler); return Unit.Default; }));
}
public void Subscribe <T>(IHandle <T> handler) where T : Message
{
Ensure.NotNull(handler, "handler");
var handlers = _handlers;
if (!handlers.Any(x => x.IsSame <T>(handler)))
{
handlers.Add(new MessageHandler <T>(handler, handler.GetType().Name));
}
}
public void Register(IHandle handler)
{
var type = handler.GetType();
var handlerTypes = type.GetInterfaces()
.Where(i => i.IsGenericType)
.Where(i => i.GetGenericTypeDefinition() == typeof(IHandle <>) || i.GetGenericTypeDefinition() == typeof(IHandleAsync <>))
.Select(i => i.GetGenericArguments().First());
foreach (var handlerType in handlerTypes)
{
AddHandler(handlerType, handler);
}
}
public IDisposable SubscribeToAll(IHandle <IMessage> handler)
{
Ensure.NotNull(handler, "handler");
var allHandler = new MessageHandler <IMessage>(handler, handler.GetType().Name);
var messageTypes = MessageHierarchy.DescendantsAndSelf(typeof(object)).ToArray();
for (var i = 0; i < messageTypes.Length; i++)
{
Subcribe(allHandler, messageTypes[i]);
}
return(new Disposer(() => { this?.Unsubscribe(handler); return Unit.Default; }));
}
public void Subscribe <T>(IHandle <T> handler) where T : Message
{
Ensure.NotNull(handler, "handler");
int[] descendants = MessageHierarchy.DescendantsByType[typeof(T)];
for (int i = 0; i < descendants.Length; ++i)
{
var handlers = _handlers[descendants[i]];
if (!handlers.Any(x => x.IsSame <T>(handler)))
{
handlers.Add(new MessageHandler <T>(handler, handler.GetType().Name));
}
}
}
public void Subscribe <T>(IHandle <T> handler) where T : Message
{
Ensure.NotNull(handler, "handler");
List <IMessageHandler> handlers;
var type = typeof(T);
if (!_typeLookup.TryGetValue(type, out handlers))
{
_typeLookup.Add(type, handlers = new List <IMessageHandler>());
}
if (!handlers.Any(h => h.IsSame(handler)))
{
handlers.Add(new MessageHandler <T>(handler, handler.GetType().Name));
}
}
public void Subscribe <T>(IHandle <T> handler) where T : Message
{
Ensure.NotNull(handler, "handler");
List <IMessageHandler> handlers;
if (!_typeHash.TryGetValue(typeof(T), out handlers))
{
handlers = new List <IMessageHandler>();
_typeHash.Add(typeof(T), handlers);
}
if (!handlers.Any(x => x.IsSame <T>(handler)))
{
handlers.Add(new MessageHandler <T>(handler, handler.GetType().Name));
}
}
public void AddHandler <T>(IHandle <T> handler) where T : Message
{
Contract.Requires(handler != null);
List <IMessageHandler> handlers;
var type = typeof(T);
if (!_typeLookup.TryGetValue(type, out handlers))
{
_typeLookup.Add(type, handlers = new List <IMessageHandler>());
}
if (!handlers.Any(h => h.IsSame(handler)))
{
handlers.Add(new MessageHandler <T>(handler, handler.GetType().Name));
}
}
internal static int GetEventHandleOrder <TEvent>(IHandle <TEvent> eventHandler) where TEvent : class, IEvent
{
var method = eventHandler.GetType().GetMethod(nameof(eventHandler.Handle), new Type[] { typeof(TEvent) });
if (method == null)
{
return((int)EventHandleOrder.Any);
}
var attribute = method.GetCustomAttributes(typeof(EventHandleOrderAttribute), true).FirstOrDefault() as EventHandleOrderAttribute;
if (attribute == null)
{
return((int)EventHandleOrder.Any);
}
return((int)attribute.EventHandleOrder);
}
public IDisposable Subscribe <T>(IHandle <T> handler) where T : Message
{
Ensure.NotNull(handler, "handler");
lock (_handlers)
{
int[] descendants = MessageHierarchy.DescendantsByType[typeof(T)];
for (int i = 0; i < descendants.Length; ++i)
{
var handlers = _handlers[descendants[i]];
if (!handlers.Any(x => x.IsSame <T>(handler)))
{
handlers.Add(new MessageHandler <T>(handler, handler.GetType().Name,
MessageHierarchy.GetMsgTypeId(typeof(T))));
}
}
return(new SubscriptionDisposer(() => { this?.Unsubscribe(handler); return Unit.Default; }));
}
}
public void Subscribe <T>(IHandle <T> handler)
{
var interfaces = handler.GetType().GetTypeInfo().ImplementedInterfaces
.Where(x => x.GetTypeInfo().IsGenericType&& x.GetGenericTypeDefinition() == typeof(IHandle <>));
foreach (var interfaceType in interfaces)
{
var eventType = interfaceType.GetTypeInfo().GenericTypeArguments[0];
List <object> handlerList;
if (!handlers.TryGetValue(eventType, out handlerList))
{
handlerList = new List <object>();
handlers[eventType] = handlerList;
}
handlerList.Add(handler);
}
}
private int GetEventHandleOrder <TEvent>(IHandle <TEvent> eventHandler) where TEvent : class, IEvent
{
// TODO: Convert "Handle" to nameof(eventHandler.Handle) after .net 4.5
var method = eventHandler.GetType().GetMethod("Handle", new Type[] { typeof(TEvent) });
if (method == null)
{
return((int)EventHandleOrder.Any);
}
var attribute = method.GetCustomAttributes(typeof(EventHandleOrderAttribute), true).FirstOrDefault() as EventHandleOrderAttribute;
if (attribute == null)
{
return((int)EventHandleOrder.Any);
}
return((int)attribute.EventHandleOrder);
}
public static void HandleMeWith(this IAmAnEventMessage @event, IHandle <IEnumerable <IAmAnEventMessage> > handler)
{
var handlerType = handler.GetType();
var eventType = @event.GetType();
var eventHandlerMethods =
from method in handlerType.GetTypeInfo().DeclaredMethods
from parameter in method.GetParameters()
where parameter.ParameterType == eventType
select method;
var allMethodes = eventHandlerMethods.ToList();
if (allMethodes.Any())
{
if (allMethodes.Count() > 1)
{
throw new MultipleHandlerMethodesDetected(eventType.Name);
}
allMethodes.First().Invoke(handler, new object[] { @event });
}
}
public void Handle(T message)
{
_logger.Debug($"Queue -> {_handler.GetType().Name}\nnote right: {message.GetType().Name}");
_handler.Handle(message);
}
public void Register <T>(IHandle <T> handler) where T : class
{
_registeredHandlers.Add(new HandlerRegistration(typeof(T), handler.GetType().AssemblyQualifiedName, msg => handler.Handle(msg as T)));
}
