/// <summary>
/// Notifies an observer based on the MessageType
/// </summary>
/// <param name="observer">IObserverIOIO that is also IObserver<MessageType></param>
/// <param name="self">this message as a cast MessageType</param>
protected virtual void NotifyDynamic(IObserverIOIO observer, MessageType self)
{
IObserver<MessageType> genericizedObserver = observer as IObserver<MessageType>;
if (genericizedObserver != null)
{
genericizedObserver.OnNext(self);
}
}
/// <summary>
/// Dispatch method on the message itself that notifies the passed in observer via the most targeted method
/// </summary>
/// <param name="observer">non genericized observer</param>
public virtual void Notify(IObserverIOIO observer)
{
MessageType messageAsMessageType = this as MessageType;
if (messageAsMessageType != null)
{
NotifyDynamic(observer, messageAsMessageType);
}
}
/// <summary>
/// This method notifies the observers in parallel and does not wait.
/// </summary>
/// <param name="message"></param>
public override void HandleMessage(IMessageIOIO message)
{
// messages must support notification to do notification...
IMessageNotificationIOIO notifier = message as IMessageNotificationIOIO;
if (notifier != null)
{
foreach (IObserverIOIO observer in Interested_)
{
try {
// copy the loop value so it doesn't get replaced
IObserverIOIO taskObserver = observer;
Task.Factory.StartNew(() => notifier.Notify(taskObserver));
}
catch (Exception e)
{
LOG.Error("Caught exception ", e);
}
}
}
}
/// <summary>
/// Does not yet return an actual unsubscriber
/// </summary>
/// <param name="t">the specific subtype of IMessageFromIOIO you are interested in</param>
/// <param name="observer">object that wishes to be notified</param>
/// <returns></returns>
public virtual IDisposable Subscribe(IObserverIOIO observer)
{
Interested_.Add(observer);
return(null);
}
