public void emit <T>(string type, params object[] data) where T : Event
{
Type eventType = typeof(T);
T e = Activator.CreateInstance(eventType, type) as T;
e.somedata = data;
List <object> handlers;
if (!this._events.TryGetValue(e.type, out handlers))
{
Logger.Warn(string.Format("Event [{0}] does not exist in the emitter. Consider calling EventEmitter.On", e.type));
}
else
{
e.somedata = data;
foreach (var handler in handlers)
{
if (handler.GetType().GenericTypeArguments[0] == eventType)
{
vitamin.EventHandler <T> eventHandler = (vitamin.EventHandler <T>)handler;
eventHandler(e);
}
}
}
}
/// <summary>
/// Whenever eventName is emitted, the methods attached to this event will be called
/// </summary>
/// <param name="eventName">Event name to subscribe to</param>
/// <param name="handler">Method to add to the event</param>
public void on <T>(string type, vitamin.EventHandler <T> handler) where T : Event
{
List <object> handlers;
if (this._events.TryGetValue(type, out handlers))
{
handlers.Add(handler);
}
else
{
this._events.Add(type, new List <object> {
handler
});
}
}
public void emitAsync <T>(T e, params object[] data) where T : Event
{
List <object> handlers;
if (!this._events.TryGetValue(e.type, out handlers))
{
Logger.Warn(string.Format("Event [{0}] does not exist in the emitter. Consider calling EventEmitter.On", e.type));
}
else
{
foreach (var handler in handlers)
{
vitamin.EventHandler <T> eventHandler = (vitamin.EventHandler <T>)handler;
Task.Run(() => eventHandler(e));
}
}
}
/// <summary>
/// Emits the event and runs all associated methods asynchronously
/// 发出事件并异步运行所有关联的方法
/// </summary>
/// <param name="type">The event name to call methods for</param>
/// <param name="data">The data to call all the methods with</param>
public void emitAsync(string type, params object[] data)
{
this._event.type = type;
this._event.somedata = data;
List <object> handlers;
if (!this._events.TryGetValue(type, out handlers))
{
Logger.Warn(string.Format("Event [{0}] does not exist in the emitter. Consider calling EventEmitter.On", type));
}
else
{
foreach (var handler in handlers)
{
vitamin.EventHandler <Event> eventHandler = (vitamin.EventHandler <Event>)handler;
Task.Run(() => eventHandler(this._event));
}
}
}
/// <summary>
/// Removes [method] from the event
/// </summary>
/// <param name="eventName">Event name to remove function from</param>
/// <param name="method">Method to remove from eventName</param>
public void removeListener <T>(string eventName, vitamin.EventHandler <T> method) where T : Event
{
List <object> handlers;
if (!this._events.TryGetValue(eventName, out handlers))
{
Logger.Warn(string.Format("Event [{0}] does not exist to have listeners removed.", eventName));
}
else
{
var _event = handlers.Exists(e => (vitamin.EventHandler <T>)e == method);
if (_event == false)
{
Logger.Warn(string.Format("Func [{0}] does not exist to be removed.", method.Method));
}
else
{
handlers.Remove(method);
}
}
}
/// <summary>
/// Emits the event and associated data
/// 发出事件和相关数据
/// </summary>
/// <param name="eventName">Event name to be emitted</param>
/// <param name="data">Data to call the attached methods with</param>
public void emit(string type, params object[] data)
{
Type eventType = this._event.GetType();
this._event.type = type;
this._event.somedata = data;
List <object> handlers;
if (!this._events.TryGetValue(type, out handlers))
{
Logger.Warn(string.Format("Event [{0}] does not exist in the emitter. Consider calling EventEmitter.On", type));
}
else
{
foreach (var handler in handlers)
{
if (handler.GetType().GenericTypeArguments[0] == eventType)
{
vitamin.EventHandler <Event> eventHandler = (vitamin.EventHandler <Event>)handler;
eventHandler(this._event);
}
}
}
}
