public void AddEventHandler <TEvent>(Action <TEvent> callback)
{
Validate();
if (callback == null)
{
throw new ArgumentNullException(nameof(callback));
}
if (callback.Target == null)
{
throw new ArgumentException("Can't use static methods in callbacks.", nameof(callback));
}
Type type = typeof(TEvent);
EventHandler eventHandler = new EventHandler(callback);
lock (_eventHandlers)
{
if (!_eventHandlers.ContainsKey(type))
{
_eventHandlers[type] = new List <EventHandler>();
}
if (!_eventHandlers[type].Contains(eventHandler))
{
_eventHandlers[type].Add(eventHandler);
}
}
}
public void Register(object handler)
{
Validate();
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
// Look for, and save, any IEventHandler implementations
IEnumerable <Type> eventInterfaces = handler.GetType().GetInterfaces()
.Where(x => typeof(IEventHandler).IsAssignableFrom(x) && x.IsGenericType);
lock (_eventHandlers)
{
foreach (var @interface in eventInterfaces)
{
Type type = @interface.GetGenericArguments()[0];
MethodInfo method = @interface.GetMethod("HandleEvent", new[] { type });
if (method != null)
{
Delegate @delegate = Delegate.CreateDelegate(typeof(Action <>).MakeGenericType(type), handler, method);
EventHandler eventHandler = new EventHandler(@delegate);
if (!_eventHandlers.ContainsKey(type))
{
_eventHandlers[type] = new List <EventHandler>();
}
if (!_eventHandlers[type].Contains(eventHandler))
{
_eventHandlers[type].Add(eventHandler);
}
}
}
}
// Look for, and save, any ISynchronizedHandler implementations
IEnumerable <Type> synchronizedInterfaces = handler.GetType().GetInterfaces()
.Where(x => typeof(ISynchronizedHandler).IsAssignableFrom(x) && x.IsGenericType);
lock (_synchronizedHandlers)
{
foreach (var @interface in synchronizedInterfaces)
{
Type requestType = @interface.GetGenericArguments()[0];
Type responseType = @interface.GetGenericArguments()[1];
MethodInfo method = @interface.GetMethod("HandleSynchronized", new[] { requestType });
if (method != null && method.ReturnType.IsAssignableFrom(responseType))
{
Delegate @delegate = Delegate.CreateDelegate(typeof(Func <,>).MakeGenericType(requestType, responseType), handler, method);
SynchronizedHandlerKey key = new SynchronizedHandlerKey(requestType, responseType);
SynchronizedHandler synchronizedHandler = new SynchronizedHandler(@delegate);
lock (_synchronizedHandlers)
{
if (_synchronizedHandlers.ContainsKey(key))
{
throw new ArgumentException($"A SynchronizedHandler already exists for request type {requestType} and response type {responseType}", nameof(@delegate));
}
_synchronizedHandlers[key] = synchronizedHandler;
}
}
}
}
}
private void PublishUnhandledException(Exception ex)
{
EventHandler <ErrorEventArgs> eh = UnhandledException;
eh?.Invoke(this, new ErrorEventArgs(ex));
}
