/// <summary>
/// Clears the given MessageSubscription.
/// </summary>
/// <param name="messageSubscription">The subscription to clear.</param>
public void Unsubscribe(MessageSubscription messageSubscription)
{
messageSubscription.EnsureNotNull(nameof(messageSubscription));
if (messageSubscription != null && !messageSubscription.IsDisposed)
{
Type messageType = messageSubscription.MessageType;
//Remove subscription from internal list
lock (m_messageSubscriptionsLock)
{
if (m_messageSubscriptions.ContainsKey(messageType))
{
List <MessageSubscription> listOfSubscriptions = m_messageSubscriptions[messageType];
listOfSubscriptions.Remove(messageSubscription);
if (listOfSubscriptions.Count == 0)
{
m_messageSubscriptions.Remove(messageType);
}
}
}
//Clear given subscription
messageSubscription.Clear();
}
}
/// <summary>
/// Subscribes to the given message type.
/// </summary>
/// <param name="messageType">The type of the message.</param>
/// <param name="actionOnMessage">Action to perform on incoming message.</param>
public MessageSubscription Subscribe(
Delegate actionOnMessage, Type messageType)
{
actionOnMessage.EnsureNotNull(nameof(actionOnMessage));
messageType.EnsureNotNull(nameof(messageType));
if (!messageType.GetTypeInfo().IsSubclassOf(typeof(SeeingSharpMessage)))
{
throw new ArgumentException("Given message type does not derive from SeeingSharpMessage!");
}
MessageSubscription newOne = new MessageSubscription(this, messageType, actionOnMessage);
lock (m_messageSubscriptionsLock)
{
if (m_messageSubscriptions.ContainsKey(messageType))
{
m_messageSubscriptions[messageType].Add(newOne);
}
else
{
List <MessageSubscription> newList = new List <MessageSubscription>();
newList.Add(newOne);
m_messageSubscriptions[messageType] = newList;
}
}
return(newOne);
}
/// <summary>
/// Subscribes to the given MessageType during the livetime of the given control.
/// Events OnHandleCreated and OnHandleDestroyed are used for subscribing / unsubscribing.
/// </summary>
/// <typeparam name="MessageType">Type of the message.</typeparam>
/// <param name="actionOnMessage">Action to perform on incoming message.</param>
/// <param name="target">The target control.</param>
public void SubscribeOnControl <MessageType>(System.Windows.Forms.Control target, Action <MessageType> actionOnMessage)
where MessageType : SeeingSharpMessage
{
target.EnsureNotNull(nameof(target));
actionOnMessage.EnsureNotNull(nameof(actionOnMessage));
MessageSubscription subscription = null;
//Create handler delegates
EventHandler onHandleCreated = (sender, eArgs) =>
{
if (subscription == null)
{
subscription = Subscribe(actionOnMessage);
}
};
EventHandler onHandleDestroyed = (inner, eArgs) =>
{
if (subscription != null)
{
Unsubscribe(subscription);
subscription = null;
}
};
//Attach to events and subscribe on message, if handle is already created
target.HandleCreated += onHandleCreated;
target.HandleDestroyed += onHandleDestroyed;
if (target.IsHandleCreated)
{
subscription = Subscribe(actionOnMessage);
}
}
/// <summary>
/// Waits for the given message.
/// </summary>
public Task <T> WaitForMessageAsync <T>()
where T : SeeingSharpMessage
{
TaskCompletionSource <T> taskComplSource = new TaskCompletionSource <T>();
MessageSubscription subscription = null;
subscription = this.Subscribe <T>((message) =>
{
// Unsubscribe first
subscription.Unsubscribe();
// Set the task's result
taskComplSource.SetResult(message);
});
return(taskComplSource.Task);
}
