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 TestMessageDescendents()
{
var sut = typeof(ParentTestEvent);
var descendants = MessageHierarchy.DescendantsAndSelf(sut).ToList();
Assert.Equal(3, descendants.Count());
Assert.Contains(typeof(ParentTestEvent), descendants);
Assert.Contains(typeof(ChildTestEvent), descendants);
Assert.Contains(typeof(GrandChildTestEvent), descendants);
sut = typeof(GrandChildTestEvent);
descendants = MessageHierarchy.DescendantsAndSelf(sut).ToList();
Assert.Single(descendants);
Assert.Contains(typeof(GrandChildTestEvent), descendants);
}
public void TestMessageChildType()
{
var sut = typeof(MessageChild);
var ancestors = MessageHierarchy.AncestorsAndSelf(sut);
Assert.Equal(3, ancestors.Count());
Assert.Contains(typeof(Message), ancestors);
Assert.Contains(typeof(MessageParent), ancestors);
Assert.Contains(typeof(MessageChild), ancestors);
var descendants = MessageHierarchy.DescendantsAndSelf(sut);
Assert.Single(descendants);
Assert.Contains(typeof(MessageChild), descendants);
}
public static void Main()
{
var type = typeof(Message);
Console.WriteLine("MessageChild has " + MessageHierarchy.AncestorsAndSelf(type).Count() + " Ancestors");
foreach (var parent in MessageHierarchy.AncestorsAndSelf(type))
{
Console.WriteLine(parent);
}
Console.WriteLine($"{type} has {MessageHierarchy.DescendantsAndSelf(type).Count()} Descendants");
foreach (var descendant in MessageHierarchy.DescendantsAndSelf(type))
{
Console.WriteLine(descendant);
}
}
private void Subscribe(IMessageHandler handler, bool includeDerived)
{
Type[] messageTypes;
if (includeDerived)
{
messageTypes = MessageHierarchy.DescendantsAndSelf(handler.MessageType).ToArray();
}
else
{
messageTypes = new[] { handler.MessageType };
}
for (var i = 0; i < messageTypes.Length; i++)
{
Subcribe(handler, messageTypes[i]);
}
}
protected bool HasSubscriberFor(Type type, bool includeDerived)
{
Type[] derivedTypes = { type };
if (includeDerived)
{
derivedTypes = MessageHierarchy.DescendantsAndSelf(type).ToArray();
}
for (var i = 0; i < derivedTypes.Length; i++)
{
var derivedType = derivedTypes[i];
if (HasSubscriberForExactType(derivedType))
{
return(true);
}
}
return(false);
}
public void Unsubscribe <T>(IHandle <T> handler) where T : Message
{
Ensure.NotNull(handler, "handler");
var descendants = MessageHierarchy.DescendantsAndSelf(typeof(T)).ToArray();
for (var d = 0; d < descendants.Length; d++)
{
var handlers = GetHandlesFor(descendants[d]);
for (var h = 0; h < handlers.Length; h++)
{
if (!handlers[h].IsSame(typeof(T), handler))
{
continue;
}
lock (_handlers) {
_handlers[descendants[d]].Remove(handlers[h]);
}
break;
}
}
}
private void Subscribe(IMessageHandler handler)
{
// Subscribe to the underlying message type and it's descendants
var messageTypes = MessageHierarchy.DescendantsAndSelf(handler.MessageType).ToArray();
for (var i = 0; i < messageTypes.Length; i++)
{
var messageType = messageTypes[i];
var handlers = GetHandlesFor(messageType);
if (!handlers.Any(hndl => hndl.IsSame(messageType, handler)))
{
lock (_handlers) {
if (!_handlers.TryGetValue(messageType, out var handleList))
{
handleList = new List <IMessageHandler>();
_handlers.Add(messageType, handleList);
}
handleList.Add(handler);
}
}
}
}
