private Type GetType(EventHandlerTypes eventHandlerType)
{
switch (eventHandlerType)
{
case EventHandlerTypes.Bool:
return(typeof(bool));
case EventHandlerTypes.Float:
return(typeof(float));
case EventHandlerTypes.GameObject:
return(typeof(GameObject));
case EventHandlerTypes.Int:
return(typeof(int));
case EventHandlerTypes.RaycastHitNullable:
return(typeof(RaycastHit?));
case EventHandlerTypes.Vector2:
return(typeof(Vector2));
case EventHandlerTypes.Vector3:
return(typeof(Vector3));
case EventHandlerTypes.Vector4:
return(typeof(Vector4));
default:
throw new ArgumentOutOfRangeException("An does not exist with value: " + eventHandlerType);
}
}
public static void Call <N>(object sender, EventHandlerTypes type, int?group, N data)
{
SharedEventArgs arg = new SharedEventArgs(data);
var events = from h in handlers where h.Value.First == type && ([email protected] || h.Value.Second == (int)@group) select h.Value.Third;
foreach (var ev in events)
{
ev(sender, arg);
}
}
/// <summary>
/// Relays the event to all event functions.
/// </summary>
/// <param name="eventType">Type of the event.</param>
/// <param name="eventMessage">The event message.</param>
/// <param name="underlayingMessage">The underlaying message.</param>
private static void RelayEvent(EventHandlerTypes eventType, BeamEventMessage eventMessage,
string underlayingMessage)
{
foreach (var handler in _eventHandlers)
{
if (handler.Value == eventType)
{
handler.Key(eventMessage, underlayingMessage);
}
}
}
public static void Call <N>(object sender, EventHandlerTypes type, int?group, N data)
{
lock (handlers)
{
var invalid = from h in handlers where h.Value.Third.Target == null select h.Key;
foreach (var inv in invalid.ToList())
{
handlers.Remove(inv);
}
var events = from h in handlers where h.Value.First == type && ([email protected] || h.Value.Second == (int)@group) select h.Value.Third;
foreach (var ev in events.ToList())
{
((Action <object, SharedEventArgs>)ev.Target)(sender, arg);
}
}
}
private async System.Threading.Tasks.Task ProcessEvent(string eventTypeName, string message)
{
if (EventHandlerTypes.ContainsKey(eventTypeName))
{
// New!
using (var scope = ServiceScopeFactory.CreateScope())
{
System.Collections.Generic.List <System.Type>
subscriptions = EventHandlerTypes[eventTypeName];
foreach (var subscription in subscriptions)
{
//var eventHandler =
// System.Activator.CreateInstance(subscription);
// Updated!
var eventHandler =
scope.ServiceProvider.GetService(subscription);
if (eventHandler == null)
{
continue;
}
var eventType =
EventTypes
.Where(current => current.Name.ToLower() == eventTypeName.ToLower())
.FirstOrDefault();
var @event =
Newtonsoft.Json.JsonConvert
.DeserializeObject(value: message, type: eventType);
var concreteType =
typeof(Domain.Core.Bus.IEventHandler <>).MakeGenericType(typeArguments: eventType);
await System.Threading.Tasks.Task.Run(() =>
{
concreteType.GetMethod("Handle").Invoke(eventHandler, new object[] { @event });
});
}
}
}
}
public static void Call <N>(object sender, EventHandlerTypes type, int?group, N data)
{
SharedEventArgs arg = new SharedEventArgs(data);
var invalid = from h in handlers where h.Value.Third.Target == null select h.Key;
// removing expired weak references
foreach (var inv in invalid.ToList())
{
handlers.Remove(inv);
}
// selecting handlers of classes of this group
var events = from h in handlers where h.Value.First == type && ([email protected] || h.Value.Second == (int)@group) select h.Value.Third;
foreach (var ev in events.ToList())
{
// this converts the weakReference target to the real method and executes it
((Action <object, SharedEventArgs>)ev.Target)(sender, arg);
}
}
public void Subscribe <TEvent, TEventHandler>()
where TEvent : Domain.Core.Events.Event
where TEventHandler : Domain.Core.Bus.IEventHandler <TEvent>
{
try
{
string eventTypeName = typeof(TEvent).Name;
System.Type eventHandlerType = typeof(TEventHandler);
if (EventTypes.Contains(typeof(TEvent)) == false)
{
EventTypes.Add(typeof(TEvent));
}
if (EventHandlerTypes.ContainsKey(eventTypeName) == false)
{
EventHandlerTypes.Add(eventTypeName,
new System.Collections.Generic.List <System.Type>());
}
if (EventHandlerTypes[eventTypeName].Any(current => current.GetType() == eventHandlerType))
{
string errorMessage =
$"Handler Type '{ eventHandlerType.Name }' already is registered for '{ eventTypeName }'!";
throw new System.ArgumentException
(message: errorMessage, paramName: nameof(eventHandlerType));
}
EventHandlerTypes[eventTypeName].Add(eventHandlerType);
StartBasicConsume <TEvent>();
}
catch (System.Exception ex)
{
System.Console.WriteLine(ex.Message);
}
}
public static void Call <N>(EventHandlerTypes type, int?group, N data)
{
Call <N>(null, type, group, data);
}
private static void registerSharedHandlers(IKey subscriber, int?group, EventHandlerTypes type, Action <object, SharedEventArgs> handler)
{
handlers.Add(subscriber, new Triple <EventHandlerTypes, int, Action <object, SharedEventArgs> >(type, group ?? -1, handler));
}
/// <summary>
/// Adds the event handler.
/// </summary>
/// <param name="handlerType">Type of the handler.</param>
/// <param name="function">The function.</param>
public static void AddEventHandler(EventHandlerTypes handlerType, HandleEventFunc function)
{
_eventHandlers.Add(function, handlerType);
}