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))); }