private void DoAddSubscriber(
            Type handlerType,
            Type messageType,
            string messageName,
            bool isDynamic)
        {
            Assert.NotNull(handlerType, nameof(handlerType));
            Assert.NotNullOrEmpty(messageName, nameof(messageName));

            if (!_subscribers.ContainsKey(messageName))
            {
                _subscribers.Add(messageName, _subscriberCollection.New());
            }

            if (_subscribers[messageName].Any(s => s.MessageHandlerType == handlerType))
            {
                throw new ArgumentException(
                          $"Handler Type {handlerType.Name} already registered for '{messageName}'", nameof(handlerType));
            }

            if (isDynamic)
            {
                _subscribers[messageName].Add(MessageSubscriberDescriptor.Dynamic(messageName, handlerType));
            }
            else
            {
                Assert.NotNull(messageType, nameof(messageType));

                _subscribers[messageName].Add(MessageSubscriberDescriptor.Typed(messageType, handlerType));
            }
        }
        private void DoRemoveSubcriber(string messageName, MessageSubscriberDescriptor subsToRemove)
        {
            if (string.IsNullOrEmpty(messageName) ||
                subsToRemove == null)
            {
                return;
            }

            if (_subscribers[messageName].Any())
            {
                _subscribers[messageName].Remove(subsToRemove);

                if (!_subscribers[messageName].Any())
                {
                    _subscribers.Remove(messageName);
                }
            }
        }
 public void UnsubscribeDynamic <TMessageHandler>(string messageName)
     where TMessageHandler : IDynamicMessageHandler
 {
     DoRemoveSubcriber(messageName, MessageSubscriberDescriptor.Dynamic(messageName, typeof(TMessageHandler)));
 }
 public void Unsubscribe <TMessage, TMessageHandler>()
     where TMessage : IMessage
     where TMessageHandler : IMessageHandler <TMessage>
 {
     DoRemoveSubcriber(GetMessageName <TMessage>(), MessageSubscriberDescriptor.Typed(typeof(TMessage), typeof(TMessageHandler)));
 }
Esempio n. 5
0
 public void Insert(int index, MessageSubscriberDescriptor item)
 {
     _descriptors.Insert(index, item);
 }
Esempio n. 6
0
 public int IndexOf(MessageSubscriberDescriptor item)
 {
     return(_descriptors.IndexOf(item));
 }
Esempio n. 7
0
 public bool Remove(MessageSubscriberDescriptor item)
 {
     return(_descriptors.Remove(item));
 }
Esempio n. 8
0
 public bool Contains(MessageSubscriberDescriptor item)
 {
     return(_descriptors.Contains(item));
 }
Esempio n. 9
0
 public void Add(MessageSubscriberDescriptor item)
 {
     _descriptors.Add(item);
 }