public static IHubClients <IClientProxy> TryGetHubClients(this ISignalREvent theEvent)
{
if (theEvent is IHubEvent hubEvent)
{
if (hubEvent.RaiseHub != null)
{
return(hubEvent.RaiseHub.Clients);
}
}
if (theEvent is IHubContextEvent hubContextEvent)
{
if (hubContextEvent.Context != null)
{
return(hubContextEvent.Context.Clients);
}
}
throw new ArgumentException("event must have not null RaiseHub or Context");
//switch (theEvent)
//{
// //IHubCrossEvent : ISignalREvent, IHubEvent, IHubContextEvent
// case IHubEvent hubEvent:
// return hubEvent.RaiseHub.Clients;
// case IHubContextEvent hubContextEvent:
// return hubContextEvent.Context.Clients;
// default:
// throw new ArgumentException(nameof(theEvent));
//}
}
public async Task Raise(ISignalREvent hubEvent)
{
var hubEventHandlers = ResolveHubEventHandlers()
.Where(x => x.ShouldHandle(hubEvent))
.OrderBy(x => x.HandleOrder)
.ToList();
foreach (var hubEventHandler in hubEventHandlers)
{
try
{
if (hubEventHandler is IHubContextEventHandler hubContextEventHandler)
{
await hubContextEventHandler.HandleHubContextEventAsync(hubEvent).ConfigureAwait(false);
}
else
{
await hubEventHandler.HandleAsync(hubEvent).ConfigureAwait(false);
}
}
catch (Exception e)
{
//todo log
Console.WriteLine(e);
throw;
}
}
}
public async Task HandleAsync(ISignalREvent hubEvent)
{
if (!ShouldHandle(hubEvent))
{
return;
}
var theEvent = (OnConnectedEvent)hubEvent;
await _scopedConnectionManager.OnConnected(theEvent).ConfigureAwait(false);
}
private static T GetAs <T>(this ISignalREvent @event, ISignalREventHandler handler, string key, T defaultValue)
{
var theValue = @event.Get(handler, key, defaultValue);
if (theValue == null)
{
return(defaultValue);
}
return((T)Convert.ChangeType(theValue, typeof(T)));
}
/// <summary>
/// Broadcasts the specified SignalR event to clients. Can also be called directly rather
/// than via any shims.
/// </summary>
/// <param name="event">The event to broadcast.</param>
public static void Broadcast(ISignalREvent @event)
{
var eventWrapper = new EventWrapper
{
Type = @event.GetType(),
Json = JsonConvert.SerializeObject(@event)
};
Context.Clients.All.PubSubBusEvent(eventWrapper);
}
public static string GetCurrentScope(this ISignalREvent theEvent)
{
//if (!string.IsNullOrWhiteSpace(theEvent.ScopeId))
//{
// return theEvent.ScopeId;
//}
var hubClients = theEvent.TryGetHubClients();
return(null);
}
/// <summary>
/// Broadcasts the specified SignalR event to clients. Can also be called directly rather
/// than via any shims.
/// </summary>
/// <param name="event">The event to broadcast.</param>
public static void Broadcast(ISignalREvent @event)
{
var eventWrapper = new EventWrapper
{
Type = @event.GetType(),
Json = JsonConvert.SerializeObject(@event)
};
Context.Clients.All.PubSubBusEvent(eventWrapper);
}
public Task HandleAsync(ISignalREvent hubEvent)
{
if (!ShouldHandle(hubEvent))
{
return(Task.CompletedTask);
}
var theEvent = (OnDisconnectedEvent)hubEvent;
return(_scopedConnectionManager.OnDisconnected(theEvent));
}
//helpers
private static void Set(this ISignalREvent @event, ISignalREventHandler handler, string key, object value)
{
if (@event == null)
{
throw new ArgumentNullException(nameof(@event));
}
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
var theKey = string.Format("{0}_{1}", key, handler.GetType().FullName);
@event.Bags[theKey] = value;
}
public async Task HandleAsync(ISignalREvent hubEvent)
{
if (!ShouldHandle(hubEvent))
{
return;
}
if (hubEvent is OnUpdateBagsEvent theEvent)
{
await _scopedConnectionManager.UpdateScopedConnectionBags(theEvent).ConfigureAwait(false);
}
else
{
var outsideHubEvent = (OnUpdateBagsHubContextEvent)hubEvent;
await _scopedConnectionManager.UpdateScopedConnectionBagsOutSideHub(outsideHubEvent).ConfigureAwait(false);
}
}
private static object Get(this ISignalREvent @event, ISignalREventHandler handler, string key, object defaultValue)
{
if (@event == null)
{
throw new ArgumentNullException(nameof(@event));
}
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
var theKey = string.Format("{0}_{1}", key, handler.GetType().FullName);
if ([email protected](theKey))
{
return(defaultValue);
}
return(@event.Bags[theKey]);
}
public async Task HandleAsync(ISignalREvent @event)
{
if (!ShouldHandle(@event))
{
return;
}
var theEvent = (InvokeClientStubEvent)@event;
var hubClients = theEvent.TryGetHubClients();
//var proxy = hubClients.GetClientProxy("", new List<string>());
//IClientProxy clientProxy = hubClients.Clients(new List<string>());
//hubClients.Clients("");
Trace.WriteLine(string.Format("[_AnyHub] {0} >>>>>>>> {1}", "InvokeClientStub", JsonConvert.SerializeObject(theEvent.Args, Formatting.None)));
await hubClients.All.SendAsync("InvokeClientStub", theEvent.Args);
////await _clientMethodInvokeBus.Process(theEvent.Args).ConfigureAwait(false);
////todo
//await theEvent.RaiseHub.Clients.All.SendAsync("InvokeClientStub", theEvent.Args);
}
public async Task Raise(ISignalREvent hubEvent)
{
var sortedHandlers = Handlers
.Where(x => x.ShouldHandle(hubEvent))
.OrderBy(x => x.HandleOrder)
.ToList();
foreach (var handler in sortedHandlers)
{
try
{
//todo trace log
await handler.HandleAsync(hubEvent).ConfigureAwait(false);
}
catch (Exception e)
{
//todo log
Console.WriteLine(e);
throw;
}
}
}
public bool ShouldHandle(ISignalREvent @event)
{
return(@event is InvokeClientStubEvent);
}
public static void SetStopSend(this ISignalREvent @event, ISignalREventHandler handler, bool shouldStop)
{
@event.Set(handler, ShouldStopSend, shouldStop);
}
public static bool GetStopSend(this ISignalREvent @event, ISignalREventHandler handler, bool defaultValue)
{
return(@event.GetAs(handler, ShouldStopSend, defaultValue));
}
public static void SetShouldThrowWhenException(this ISignalREvent @event, ISignalREventHandler handler, bool shouldThrow)
{
@event.Set(handler, ShouldThrowWhenException, shouldThrow);
}
public static bool GetShouldThrowWhenException(this ISignalREvent @event, ISignalREventHandler handler, bool defaultValue)
{
return(@event.GetAs(handler, ShouldThrowWhenException, defaultValue));
}
public static void SetShouldWaitComplete(this ISignalREvent @event, ISignalREventHandler handler, bool shouldWait)
{
@event.Set(handler, ShouldWaitComplete, shouldWait);
}
public static bool GetShouldWaitComplete(this ISignalREvent @event, ISignalREventHandler handler, bool defaultValue)
{
return(@event.GetAs(handler, ShouldWaitComplete, defaultValue));
}
public bool ShouldHandle(ISignalREvent hubEvent)
{
return(hubEvent is OnUpdateBagsEvent || hubEvent is OnUpdateBagsHubContextEvent);
}
private void Enqueue(ISignalREvent message) => buffer.AddLast(message);
private void HandleReceived(object sender, ISignalREvent e)
{
this.onMessage(e);
}
public bool ShouldHandle(ISignalREvent hubEvent)
{
return(hubEvent is OnDisconnectedEvent);
}
/// <summary> /// Called by SignalR Hub to push client messages downstream via Events /// </summary> /// <param name="e"></param> internal void OnEvents(ISignalREvent e) => Events?.Invoke(this, e);
public void Send <TStream>(ISignalREvent message, Type hubType)
where TStream : StreamConnector
{
GetStream <TStream>(hubType).OnEvents(message);
}
