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)); }