public void ConnectAsync()
{
Connection = new HubConnection("http://54.69.68.144:8733/signalr");
HubProxy = Connection.CreateHubProxy("ChatHub");
//Handle incoming event from server: use Invoke to write to console from SignalR's thread
HubProxy.On<string>("AddMessage", (msg) =>
Console.WriteLine("AddMessage Call: " + msg)
);
HubProxy.On<string>("GetAllMessage", (s) =>
Console.WriteLine(String.Format("{0}: {1}", Environment.NewLine, s))
);
HubProxy.On<int>("GetNumberOfUsers",(s) =>
Console.WriteLine(s)
)
;
try
{
Connection.Start().Wait();
}
catch (HttpRequestException)
{
Console.WriteLine("Unable to connect to server: Start server before connecting clients.");
}
//HubProxy.Invoke("GetAllMessages");
//await HubProxy.Invoke("GetNumberOfUsers");
}
private async Task OpenConnection()
{
var url = $"http://{await _serverFinder.GetServerAddressAsync()}/";
try
{
_hubConnection = new HubConnection(url);
_hubProxy = _hubConnection.CreateHubProxy("device");
_hubProxy.On<string>("hello", message => Hello(message));
_hubProxy.On("helloMsg", () => Hello("EMPTY"));
_hubProxy.On<long, bool, bool>("binaryDeviceUpdated", (deviceId, success, binarySetting) => InvokeDeviceUpdated(deviceId, success, binarySetting: binarySetting));
_hubProxy.On<long, bool, double>("continousDeviceUpdated", (deviceId, success, continousSetting) => InvokeDeviceUpdated(deviceId, success, continousSetting));
await _hubConnection.Start();
await _hubProxy.Invoke("helloMsg", "mobile device here");
Debug.WriteLine($"{nameof(RealTimeService)}.{nameof(OpenConnection)} SignalR connection opened");
}
catch (Exception e)
{
Debug.WriteLine($"{nameof(RealTimeService)}.{nameof(OpenConnection)} ex: {e.GetType()}, msg: {e.Message}");
}
}
private async Task RunDemo(string url)
{
cde = new CountdownEvent(invocations);
ITaskAgent client = this;
ITaskScheduler server = this;
var hubConnection = new HubConnection(url);
hubConnection.TraceWriter = _traceWriter;
_hubProxy = hubConnection.CreateHubProxy("TaskSchedulerHub");
_hubProxy.On<TimeSpan>("RunSync", client.RunSync);
_hubProxy.On<TimeSpan>("RunAsync", (data) => client.RunAsync(data));
await hubConnection.Start(new LongPollingTransport());
var smallDuration = TimeSpan.FromMilliseconds(500);
var largeDuration = TimeSpan.FromSeconds(10);
for (int i = 0; i < invocations; i++ )
{
server.AssignMeShortRunningTask(smallDuration);
server.AssignMeLongRunningTask(largeDuration);
}
cde.Wait();
}
public Hub(User user, Dispatcher dispatcher)
{
this.user = user;
this.dispatcher = dispatcher;
#if DEBUG && !LIVE
hubConnection = new HubConnection("http://localhost:51443/");
#else
hubConnection = new HubConnection("http://poolq3.zoo.lan/");
#endif
hubConnection.TraceLevel = TraceLevels.All;
hubConnection.TraceWriter = new NLogTextWriter("signalr");
hub = hubConnection.CreateHubProxy("QHub");
hub.On<Queue>("NewQueue", q => RaiseEvent("created", QueueCreated, q));
hub.On<Queue>("QueueMembershipChanged", q => RaiseEvent("membershipchanged", QueueMembershipChanged, q));
hub.On<Queue>("QueueStatusChanged", q => RaiseEvent("statuschanged", QueueStatusChanged, q));
hub.On<int, User, string>("QueueMessageSent", RaiseMessageEvent);
hub.On<int>("NagQueue", id => RaiseEvent("nag", QueueNagged, id));
hubConnection.Headers["User"] = this.user.ToString();
hubConnection.StateChanged += HubConnectionOnStateChanged;
hubConnection.Error += e => logger.Error(e, "hub error");
TryConnect();
}
public async Task SetHub(IHubProxy hub)
{
this.hub = hub;
hub.On<string>("info", info => ServedInformation = string.Join("\r\n", ServedInformation, info));
hub.On("completed", () => _isCompleted = true);
await hub.Invoke("SetupServer");
}
public ShellViewModel()
{
_hubConnection = new HubConnection("http://localhost:52029/");
_gameHub = _hubConnection.CreateHubProxy("ScattergoramentHub");
_gameHub.On<char, DateTime>("gameStart", GameStart);
_gameHub.On<string, DateTime>("gameEnd", GameEnd);
_gameHub.On<bool, char, DateTime>("gameStatus", GameStatus);
_timer = new DispatcherTimer();
_timer.Interval = TimeSpan.FromMilliseconds(100);
_timer.Tick += _timer_Tick;
_timer.Start();
_hubConnection.Start()
.ContinueWith(task=>
{
if (task.IsFaulted)
{
Console.WriteLine("An error occurred during the method call {0}", task.Exception.GetBaseException());
}
else
{
RegisterPlayer();
}
}
);
}
public void HubInitial()
{
Connection = new HubConnection("http://54.69.68.144:8733/signalr");
HubProxy = Connection.CreateHubProxy("ChatHub");
HubProxy.On<string>("AddMessage",(msg) =>
Device.BeginInvokeOnMainThread(() =>
{
MessageService.AddMessage(msg,false,_controls);
}));
HubProxy.On<int>("GetNumberOfUsers", (count) =>
Device.BeginInvokeOnMainThread(() =>
{
MessageService.SetUsersCount(count, _controls);
}));
try
{
Connection.Start().Wait();
Device.BeginInvokeOnMainThread(() =>
{
_controls.ProgressBar.ProgressTo(.9, 250, Easing.Linear);
});
}
catch (Exception e)
{
MessageTemplate.RenderError("Невозможно подключиться к серверу");
}
HubProxy.Invoke("GetNumberOfUsers");
}
partial void Application_Initialize()
{
HubConnection hubConnection;
http://localhost:49499
hubConnection = new HubConnection("http://localhost:49499"); //make sure it matches your port in development
// HubProxy = hubConnection.CreateProxy("MyHub");
HubProxy = hubConnection.CreateHubProxy("Chat");
HubProxy.On<string, string>("CustomersInserted", (r, user) =>
{
this.ActiveScreens.First().Screen.Details.Dispatcher.BeginInvoke(delegate() {
this.ActiveScreens.First().Screen.ShowMessageBox("han creat un client");
});
// this.Details.Dispatcher.BeginInvoke(() =>
// {
// this.ActiveScreens.First().Screen.ShowMessageBox("han creat un client");
//// Console.WriteLine("Han creat un client");
// });
});
HubProxy.On<string>("addMessage", (missatge) =>
{
this.ActiveScreens.First().Screen.Details.Dispatcher.BeginInvoke(delegate()
{
this.ActiveScreens.First().Screen.ShowMessageBox("has rebut un "+missatge);
});
// this.Details.Dispatcher.BeginInvoke(() =>
// {
// this.ActiveScreens.First().Screen.ShowMessageBox("han creat un client");
//// Console.WriteLine("Han creat un client");
// });
});
hubConnection.Start().Wait();
}
public Chat(HubConnection connection)
{
_chat = connection.CreateHubProxy("Chat");
_chat.On<User>("markOnline", user =>
{
if (UserOnline != null)
{
UserOnline(user);
}
});
_chat.On<User>("markOffline", user =>
{
if (UserOffline != null)
{
UserOffline(user);
}
});
_chat.On<Message>("addMessage", message =>
{
if (Message != null)
{
Message(message);
}
});
}
public void Start()
{
_connection = new HubConnection("http://localhost:27367/");
_job=_connection.CreateHubProxy("JobStatusHub");
_job.On("started",onStarted);
_job.On("finished", onFinished);
_connection.Start();
}
public void Start()
{
_connection = new HubConnection(_testswarmUrl);
_job = _connection.CreateHubProxy("JobStatusHub");
_job.On("started", onStarted);
_job.On("finished", onFinished);
_connection.Start();
}
private void RegisterEventHandlers(IHubProxy proxy)
{
// Register event for setting the QR-code for client URL
proxy.On<Uri>("SetQrCode", SetQrCode);
// Register events for controlling the robot
proxy.On<string>("LockRobot", LockRobot);
proxy.On<string>("UnlockRobot", UnlockRobot);
}
public async Task StartAsync()
{
hubConnection = new HubConnection(Url);
eventHubProxy = hubConnection.CreateHubProxy("EventHub");
eventHubProxy.On<Message>("Receive",
async message => await FilterMessage(message, async () => await OnReceive(message)));
eventHubProxy.On<Message>("UpdateConfiguration",
async message => await FilterMessage(message, async () => await OnUpdateConfiguration(message.Values["Locations"] as IEnumerable<Location>)));
await hubConnection.Start();
await eventHubProxy.Invoke<Message>("RequestConfiguration");
}
public SignalRClient(IEventAggregator eventAggregator, IApplicationSettings settings)
{
this.eventAggregator = eventAggregator;
connection = new HubConnection(settings.Endpoint);
hubProxy = connection.CreateHubProxy(HubName);
hubProxy.On<string>(ProductUpdatedEvent.HubEventName, OnProductUpdatedRemote);
hubProxy.On<List<string>>(ProductUpdatedBatchEvent.HubEventName, OnProductUpdatedBatchRemote);
hubProxy.On<List<string>>(ProductDeletedBatchEvent.HubEventName, OnProductDeletedBatchRemote);
}
public SignalRClient(IEventAggregator eventAggregator)
{
this.eventAggregator = eventAggregator;
connection = new HubConnection(System.Windows.Browser.HtmlPage.Document.DocumentUri.ToString());
hubProxy = connection.CreateHubProxy(HubName);
hubProxy.On<string>(ProductUpdatedEvent.HubEventName, OnProductUpdatedRemote);
hubProxy.On<List<string>>(ProductUpdatedBatchEvent.HubEventName, OnProductUpdatedBatchRemote);
hubProxy.On<List<string>>(ProductDeletedBatchEvent.HubEventName, OnProductDeletedBatchRemote);
}
public virtual void ConnectToServer() {
hubConnection = new HubConnection("http://localhost:52807/signalR", false);
hubProxy = hubConnection.CreateHubProxy("QmsHub");
hubProxy.On("OnRegisterConfirm", OnRegisteConfirm);
hubProxy.On<Guid>("AddPersonToQueue", AddPersonToQueue);
hubProxy.On("OnStart", OnStart);
hubProxy.On("OnStop", OnStop);
hubConnection.Start().Wait();
OnConnectedToServer();
}
private async void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
var deviceName = ConfigurationManager.AppSettings["DeviceName"];
device = PTZDevice.GetDevice(deviceName, PTZType.Relative);
url = ConfigurationManager.AppSettings["relayServerUrl"];
remoteGroup = Environment.MachineName; //They have to hardcode the group, but for us it's our machine name
connection = new HubConnection(url);
proxy = connection.CreateHubProxy("RelayHub");
connection.TraceLevel = TraceLevels.StateChanges | TraceLevels.Events;
connection.TraceWriter = new PTZRemoteTraceWriter(Log);
//Can't do this here because DirectShow has to be on the UI thread!
// This would cause an obscure COM casting error with no clue what's up. So, um, ya.
//proxy.On<int, int>("Move",(x,y) => device.Move(x, y));
//proxy.On<int>("Zoom", (z) => device.Zoom(z));
magic = SynchronizationContext.Current;
proxy.On<int, int>("Move", (x, y) =>
{
//Toss this over the fence from this background thread to the UI thread
magic.Post((_) => {
Log(String.Format("Move({0},{1})", x,y));
device.Move(x, y);
}, null);
});
proxy.On<int>("Zoom", (z) =>
{
magic.Post((_) =>
{
Log(String.Format("Zoom({0})", z));
device.Zoom(z);
}, null);
});
try
{
await connection.Start();
Log("After connection.Start()");
await proxy.Invoke("JoinRelay", remoteGroup);
Log("After JoinRelay");
}
catch (Exception pants)
{
Log(pants.GetError().ToString());
throw;
}
}
public bool Connect(Gateway gateway, string serverUrl, string connectionPassword)
{
DebugState(String.Format("Connecting to server {0}... ", serverUrl));
isAuthorized = false;
var querystringData = new Dictionary<string, string>();
querystringData.Add("IsGateway", "true");
querystringData.Add("ConnectionPassword", connectionPassword);
hubConnection = new HubConnection(serverUrl, querystringData);
hubProxy = hubConnection.CreateHubProxy("gatewayHub");
try
{
hubProxy.On<string>("clearLog", ClearLog);
hubProxy.On("clearNodes", ClearNodes);
hubProxy.On<string>("getLog", GetLog);
hubProxy.On<string>("getNodes", GetNodes);
hubProxy.On<string>("getGatewayInfo", GetGatewayInfo);
hubProxy.On<string>("getGatewayHardwareConnected", GetGatewayHardwareConnected);
hubProxy.On("authorizationFailed", AuthorizationFailed);
hubProxy.On("authorizationCompleted", AuthorizationCompleted);
hubProxy.On<string, string>("sendMessage", SendMessage);
hubConnection.Start().Wait();
hubConnection.Closed += Disconnect;
this.gateway = gateway;
gateway.OnMessageRecievedEvent += OnMessageRecievedEvent;
gateway.OnMessageSendEvent += OnMessageSendEvent;
gateway.messagesLog.OnClearMessages += OnClearMessages;
gateway.OnNewNodeEvent += OnNewNodeEvent;
gateway.OnNodeLastSeenUpdatedEvent += OnNodeLastSeenUpdatedEvent;
gateway.OnNodeUpdatedEvent += OnNodeUpdatedEvent;
gateway.OnNodeBatteryUpdatedEvent += OnNodeBatteryUpdatedEvent;
gateway.OnNewSensorEvent += OnNewSensorEvent;
gateway.OnSensorUpdatedEvent += OnSensorUpdatedEvent;
gateway.OnClearNodesListEvent += OnClearNodesListEvent;
gateway.OnDisconnectedEvent += OnGatewayDisconnectedEvent;
gateway.OnConnectedEvent += OnGatewayConnectedEvent;
if (OnConnected != null && IsConnected())
OnConnected(this, null);
// DebugState("Connected.");
return true;
}
catch
{
DebugState("Can`t connect.");
if (OnConnectionFailed != null)
OnConnectionFailed(this, null);
return false;
}
}
public async Task Connect()
{
_hubConnection = new HubConnection(ConfigurationManager.AppSettings["ServerPath"]);
_hubConnection.Headers.Add("login", _accessProvider.Login);
_hubConnection.Headers.Add("token", _accessProvider.Token);
_hubProxy = _hubConnection.CreateHubProxy("waiterHub");
_hubProxy.On<OrderModel>("NewOrderMade", order => _waiterApp.NewOrderMade(order));
_hubProxy.On<IEnumerable<OrderModel>>("OrdersAwaiting", awaitingOrders => _waiterApp.OrdersAwaiting(awaitingOrders));
_hubProxy.On<AcceptedOrderCurrentStateModel>("AcceptedOrderInfoUpdated", acceptedOrder => _waiterApp.AcceptedOrderInfoUpdated(acceptedOrder));
_hubProxy.On<AcceptOrderModel>("OrderWasAccepted", acceptedOrder => _waiterApp.OrderWasAccepted(acceptedOrder));
_hubProxy.On<String>("CallWaiter", tableLogin => _waiterApp.CallWaiter(tableLogin));
await _hubConnection.Start();
}
public static void Main()
{
Timer.Elapsed += Elapsed;
Timer.Start();
_hubConnection = new HubConnection("http://localhost:50025");
_conversationProxy = _hubConnection.CreateHubProxy("RecycleHub");
_conversationProxy.On("Broadcast", message => Console.WriteLine(message));
_conversationProxy.On("Online", message => Console.WriteLine(message));
_hubConnection.Closed += HubConnectionOnClosed;
_hubConnection.StateChanged += HubConnectionStateChanged;
ConnectToHub();
Console.ReadLine();
}
public ConnectionManager(IDispatcher dispatcher)
{
_dispatcher = dispatcher;
var hub = new HubConnection("http://signallines.apphb.com");
_gameHub = hub.CreateProxy("GameHub");
_gameHub.On("addMessage", ProcessMessage);
_gameHub.On<int, int, int>("lineClicked", HandleLineClicked);
_gameHub.On<Player>("newPlayerJoined", ProcessNewPlayerJoined);
_gameHub.On<GameState>("resetGame", HandleResetGame);
_gameHub.On<Player>("playerLeft", HandlePlayerLeft);
hub.Start().Wait();
}
public ChatHubProxy(HubConnection connection, SynchronizationContext context)
{
_connection = connection;
_context = context;
_proxy = _connection.CreateHubProxy("ChatHub");
_proxy.On<UserDetail, ChatMessage>("OnMessageReceived", OnMessageReceived);
MessageReceived = (sender, message) => { };
_proxy.On<UserDetail, UserDetail[]>("OnConnected", OnConnected);
Connected = (userdetail, userdetails) => { };
_proxy.On<UserDetail>("OnNewUserConnected", OnNewUserConnected);
NewUserConnected = (userdetail) => { };
}
public CoordinateHubClient(Action<Coordinate> callback)
{
_hubConnection = new HubConnection("http://indoorgps.azurewebsites.net");
_hubProxy = _hubConnection.CreateHubProxy("CoordinateHub");
_hubProxy.On<Coordinate>("SendNewCoordinate", callback);
_hubConnection.Start().Wait();
}
public async Task Connect()
{
if (_hubConnection != null && _hubConnection.State == ConnectionState.Connected)
return;
_hubConnection = new HubConnection(ConfigurationManager.AppSettings["ServerPath"]);
_hubConnection.Headers.Add("login", _accessProvider.Login);
_hubConnection.Headers.Add("token", _accessProvider.Token);
_hubProxy = _hubConnection.CreateHubProxy("tableHub");
_hubProxy.On<string>("NotifyTable", message => _tableApp.NotifyTable(message));
_hubProxy.On<EndOrderModel>("NotifyOrderEnded", endedOrder => _tableApp.NotifyOrderEnded(endedOrder));
_hubProxy.On<int>("SendOrderId", id => _tableApp.SendOrderId(id));
_hubProxy.On<OrderItemState>("NotifyOrderItemStateChanged", state => _tableApp.NotifyOrderItemStateChanged(state));
_hubProxy.On<ReservationOrderScheduledModel>("LockTable", scheduledOrder => _tableApp.LockTable(scheduledOrder));
await _hubConnection.Start();
}
public App()
{
InitializeComponent();
var label = new Label();
var button = new Button()
{
Text = "送信",
};
conn = new HubConnection("http://localhost:5000");
proxy = conn.CreateHubProxy("hello");
proxy.On<string>("helloWorld", x => { label.Text = x; });
conn.Start();
button.Clicked += OnClick;
var stack = new StackLayout()
{
Orientation = StackOrientation.Vertical,
};
stack.Children.Add(label);
stack.Children.Add(button);
MainPage = new ContentPage()
{
Content = stack,
};
}
// Constructor
public MainPage()
{
_hubConnection = new HubConnection("http://signalrandiot.azurewebsites.net");
_deviceHubProxy = _hubConnection.CreateHubProxy("DeviceDataHub");
_deviceHubProxy.On<DeviceData>("NewDataRecieved", x =>
{
Dispatcher.BeginInvoke(() =>
{
if (x.DataType == "Temperature")
{
((ArrowGaugeIndicator)this.TempatureGauge.Indicators.Single(y => y.GetType() == typeof(ArrowGaugeIndicator))).Value = x.DataValue;
}
else if (x.DataType == "Humidity")
{
((ArrowGaugeIndicator)this.HumidityGauge.Indicators.Single(y => y.GetType() == typeof(ArrowGaugeIndicator))).Value = x.DataValue;
}
else if (x.DataType == "Light")
{
((ArrowGaugeIndicator)this.LightGauge.Indicators.Single(y => y.GetType() == typeof(ArrowGaugeIndicator))).Value = x.DataValue;
}
else if (x.DataType == "Distance")
{
((ArrowGaugeIndicator)this.DistanceGauge.Indicators.Single(y => y.GetType() == typeof(ArrowGaugeIndicator))).Value = x.DataValue;
}
});
});
InitializeComponent();
this._hubConnection.Start();
}
// Constructor
public MainPage()
{
InitializeComponent();
DataContext = App.ViewModel;
var hubConnection = new HubConnection("http://192.168.2.128:50188");
chat = hubConnection.CreateHubProxy("chat");
chat.On<string>("newMessage", msg => Dispatcher.BeginInvoke(() => App.ViewModel.Items.Add(new ItemViewModel { LineOne = msg })));
hubConnection.Error += ex => Dispatcher.BeginInvoke(() =>
{
var aggEx = (AggregateException)ex;
App.ViewModel.Items.Add(new ItemViewModel { LineOne = aggEx.InnerExceptions[0].Message });
});
var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
hubConnection.Start().ContinueWith(task =>
{
var ex = task.Exception.InnerExceptions[0];
App.ViewModel.Items.Add(new ItemViewModel { LineOne = ex.Message });
},
CancellationToken.None,
TaskContinuationOptions.OnlyOnFaulted,
scheduler);
}
private void StartService()
{
try
{
if (_ProxyAuth != null)
{
if (_ProxyAuth.Authenticated)
{
_Hub = new Microsoft.AspNet.SignalR.Client.HubConnection(RemoteDesktop_CSLibrary.Config.SignalRHubUrl);
_ProxyHub = _Hub.CreateHubProxy(RemoteDesktop_CSLibrary.Config.SignalRHubName);
_Hub.TransportConnectTimeout = new TimeSpan(0, 0, 4);
_ProxyHub.On<List<Client>>("AvailableClients", ReceivedClients);
_Hub.Error += _Hub_Error;
if (ProxyAuth.UsingWindowsAuth)
{
_Hub.Credentials = System.Net.CredentialCache.DefaultNetworkCredentials;
}
else
{
_Hub.CookieContainer = new CookieContainer();
_Hub.CookieContainer.Add(_ProxyAuth.AuthCookie);
}
_Hub.Start();
}
}
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
}
}
/// <summary>
/// Hubをセットする
/// </summary>
/// <param name="hub"></param>
public void SetHub(IHubProxy hub)
{
if(hub == null) throw new ArgumentNullException(nameof(hub));
this.hub = hub;
hub.On<string, Type>("serve",async (json, type) =>
{
var noodles = lib.NoodleListConverter.Convert(json, type);
if(!noodles.Any()) return;
ServedInformation = string.Join("\r\n", ServedInformation, $"{noodles.First().Name}が流れてきたよ！");
_flowing = true;
try
{
await Task.Delay(5000);
if(!_isPick)
{
await hub.Invoke("Picking", 0);
return;
}
var pickedCount = Guest.Picking(noodles);
ServedInformation = string.Join("\r\n", ServedInformation, Guest.Eat(noodles.Take(pickedCount)));
await hub.Invoke("Picking", pickedCount);
}
finally
{
_flowing = false;
_isPick = false;
}
});
}
private void Initialize()
{
try
{
connection = new HubConnection(url);
hub = connection.CreateHubProxy("TickerHub");
//await connection.Start();
hub?.On("OnNextTick", x => OnNextTick(x));
}
catch (Exception ex)
{
Message = ex.Message;
}
}
private static async Task RunAsync()
{
var connection = new HubConnection("http://localhost:44914/");
IHubProxy chat = connection.CreateHubProxy("Chat");
chat.On <string>("send", Console.WriteLine);
await connection.Start();
string line = null;
await Task.Factory.StartNew(() =>
{
while (!String.IsNullOrEmpty(line = Console.ReadLine()))
{
chat.Invoke("send", "Console: " + line);
}
});
}
private void btnSave_Click(object sender, RoutedEventArgs e)
{
var hubCn = new HubConnection(txtServerUrl.Text);
IHubProxy proxy = hubCn.CreateHubProxy("MyHub");
proxy.On <string>("hello", (message) =>
{
TaskbarIcon notifyIcon = (TaskbarIcon)FindResource("MyNotifyIcon");
MainWindow._messages.Add(message);
notifyIcon.ShowBalloonTip("Alert", message, BalloonIcon.Info);
});
hubCn.Start().Wait();
App.ServerUrl = txtServerUrl.Text;
App.Current.MainWindow.Show();
this.Close();
}
public async static void ConnectToHub()
{
if (!string.IsNullOrEmpty(endpoint) && !string.IsNullOrEmpty(hubName))
{
connection = new HubConnection(endpoint);
proxy = connection.CreateHubProxy(hubName);
// setup Methods and Link
// Has to be the same call as the hub
proxy.On("RecieveMessage", new Action <string, string>(OnRecieveMessage));
//Connect to server
connection.Received += Connection_Recieved;
await connection.Start();// Waits For task to complete
}
}
public void OnConnect()
{
CloseConnection();
_hubConnection = new HubConnection(ServerURI);
_hubConnection.Closed += HubConnectionClosed;
_hubProxy = _hubConnection.CreateHubProxy("GroupChatHub");
_hubProxy.On <string, string, string>("MessageToGroup", OnMessageReceived);
try
{
_hubConnection.Start();
}
catch (HttpRequestException ex)
{
_messagingService.ShowMessage(ex.Message);
}
_messagingService.ShowMessage("client connected");
}
public MainPage()
{
InitializeComponent();
// create connection
var hubConnection = new HubConnection("http://signalrmeetupdemo.azurewebsites.net/signalr");
// create proxy
loungeProxy = hubConnection.CreateHubProxy("Lounge");
loungeProxy.On <string>("pongHello",
data =>
Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() => { pongTxt.Text += Environment.NewLine + data; })
);
hubConnection.Start().Wait();
}
/// <summary>
/// Realiza la configuración inicial de signalR para este viewmodel.
/// </summary>
private async void SignalR()
{
proxy = Connection.Connection.proxy;
conn = Connection.Connection.conn;
proxy.On <List <clsQuestion> >("sendQuestions", receiveQuestions);
proxy.On <bool, int>("sendIsCorrect", receiveIsCorrect);
proxy.On <bool, int>("sendRivalIsCorrect", receiveIsCorrectRival);
proxy.On <String, String, List <clsQuestion> >("comenzarPartida", comenzarPartida);
proxy.On <int, int, int, int>("mandarEstadisticasFinalPartida", receiveMatchStats);
proxy.On <int>("questionBeingPlayed", receiveQuestionBeingPlayed);
}
async private void makeConnection()
{
try
{
// Pass parameter form client to server.
var querystringData = new Dictionary <string, string>();
querystringData.Add("chatversion", "1.1");
var hubConnection = new HubConnection("http://localhost:53748", querystringData);
// Windows authentication.
hubConnection.Credentials = CredentialCache.DefaultCredentials;
// Connection Header.
// hubConnection.Headers.Add("myauthtoken", /* token data */);
//// Auth(Certificate).
//hubConnection.AddClientCertificate(X509Certificate.CreateFromCertFile("MyCert.cer"));
chat = hubConnection.CreateHubProxy("ChatHub");
chatShow.Text = "";
Context = SynchronizationContext.Current;
chat.On <string, string>("broadcastMessage",
(name, message) =>
Context.Post(delegate
{
this.chatShow.Text += name + ": "; this.chatShow.Text += message + "\n";
}, null)
);
chat.Subscribe("notifyWrongVersion").Received += notifyWrongVersion_chat;
await hubConnection.Start();
await chat.Invoke("Notify", chatName.Text, hubConnection.ConnectionId);
}
catch (HubException ex)
{
}
catch (Exception ex)
{
}
}
static void Main(string[] args)
{
string msg = null;
DataTable dados;
var hubConnection = new HubConnection("http://localhost:54132/");
IHubProxy serverHub = hubConnection.CreateHubProxy("BroadcastHub");
serverHub.On <RequisicaoSql>("obterConsulta", (requisicao) =>
{
//RequisicaoSql requisicao = ProcessamentoBroadcast.DeserializaRequisicaoSql(requisicaoJSON);
if (requisicao.CodigoUsuario == 45)
{
Console.WriteLine($"Horário disparo: {requisicao.DataHoraRequisicao}");
Console.WriteLine($"Horário recebimento: {DateTime.Now:G}");
Console.WriteLine($"SQL Recebido: {requisicao.ComandoSql}");
Console.WriteLine($"Código Requisição: {requisicao.CodigoRequisicao}");
Console.WriteLine($"Tipo Consulta: {requisicao.Tipo}");
Console.WriteLine($"Parametros:");
foreach (var parametro in requisicao.Parametros)
{
Console.WriteLine($" Nome: {parametro.Nome}, Valor: {parametro.Valor}, Tipo: {parametro.Tipo}");
}
RespostaRequisicaoSql resposta = Conexao.ObterDados(requisicao.ComandoSql, requisicao.Parametros);
resposta.CodigoRequisicaoSql = requisicao.CodigoRequisicao;
resposta.Parametros = ProcessamentoBroadcast.CriarParametros();
serverHub.Invoke("devolverDados", resposta);
}
}
);
hubConnection.Start().Wait();
serverHub.Invoke("Notify", "Console app", hubConnection.ConnectionId);
while ((msg = Console.ReadLine()) != null)
{
return;
}
}
public async Task ConnectAsync()
{
_connection = new HubConnection(url);
_hubProxy = _connection.CreateHubProxy("OrderBook");
_hubProxy.On <User>("UserLogin", (u) => UserLoggedIn?.Invoke(u));
_hubProxy.On <string>("UserLogout", (n) => UserLoggedOut?.Invoke(n));
_hubProxy.On <string>("UserDisconnection", (n) => UserDisconnected?.Invoke(n));
_hubProxy.On <string>("UserReconnection", (n) => UserReconnected?.Invoke(n));
_hubProxy.On <IEnumerable <Order> >("BroadcastOrders", (n) => ReceiveNewOrder?.Invoke(n));
_hubProxy.On <string, MessageType>("NotifyUser", (n, m) => ReceiveNotification?.Invoke(n, m));
_hubProxy.On <string>("SendBidDepth", (x) => ReceiveBidDepth?.Invoke(x));
_hubProxy.On <string>("SendAskDepth", (x => ReceiveAskDepth?.Invoke(x)));
_connection.Reconnecting += Reconnecting;
_connection.Reconnected += Reconnected;
_connection.Closed += Disconnected;
ServicePointManager.DefaultConnectionLimit = 10;
await _connection.Start();
}
public async Task ConnectAsync()
{
hubConnection = new HubConnection(this.ServerURI);
// hubConnection.Closed += hubConnection_Closed;
hubProxy = hubConnection.CreateHubProxy("ChatHub");
//Handle incoming event from server: use Invoke to write to console from SignalR's thread
hubProxy.On <string, string>("BroadcastMessage", (sender, message) =>
this.Dispatcher.Invoke(() =>
PrintMessage(sender, message)));
hubProxy.On <string, string>("BroadcastMessage", (sender, message) =>
this.Dispatcher.Invoke(() =>
m_data.notifycount++));
hubProxy.On <string, string>("BroadcastMessage", (sender, message) =>
this.Dispatcher.Invoke(() =>
ShowStandardBalloon(String.Format("{0}: {1}" + Environment.NewLine, sender, message))));
hubProxy.On <string>("whoIsOn", (grps) =>
this.Dispatcher.Invoke((Action)(() => names2 = (String.Format("{0}", grps)))));
hubProxy.On <string>("whoIsOn", (grps) =>
this.Dispatcher.Invoke((Action)(() => SplitUsers())));
hubProxy.On <string>("whoIsOn", (grps) =>
this.Dispatcher.Invoke((Action)(() => names1 = (String.Format("{0}", grps)))));
try
{
await hubConnection.Start().ContinueWith((antecedent) =>
{
hubProxy.Invoke("getMyName", this.ConnectedUser);
});
}
catch (HttpRequestException)
{
// StatusText.Text = "Unable to connect to server: Start server before connecting clients.";
//No connection: Don't enable Send button or show chat UI
return;
}
/*
* SignInPanel.Visible = false;
* ChatPanel.Visible = true;
* TextBoxMessage.Focus();
*/
ServerName.Text = ("Connected to server at " + ServerURI + " Default Username is " + ConnectedUser + Environment.NewLine);
}
public async Task ConnectAsync()
{
connection = new HubConnection(url);
hubProxy = connection.CreateHubProxy("ChatHub");
hubProxy.On <User>("ParticipantLogin", (u) => ParticipantLoggedIn?.Invoke(u));
hubProxy.On <string>("ParticipantLogout", (n) => ParticipantLoggedOut?.Invoke(n));
hubProxy.On <string>("ParticipantDisconnection", (n) => ParticipantDisconnected?.Invoke(n));
hubProxy.On <string>("ParticipantReconnection", (n) => ParticipantReconnected?.Invoke(n));
hubProxy.On <string, string>("BroadcastTextMessage", (n, m) => NewTextMessage?.Invoke(n, m, MessageType.Broadcast));
hubProxy.On <string, byte[]>("BroadcastPictureMessage", (n, m) => NewImageMessage?.Invoke(n, m, MessageType.Broadcast));
hubProxy.On <string, string>("UnicastTextMessage", (n, m) => NewTextMessage?.Invoke(n, m, MessageType.Unicast));
hubProxy.On <string, byte[]>("UnicastPictureMessage", (n, m) => NewImageMessage?.Invoke(n, m, MessageType.Unicast));
hubProxy.On <string>("ParticipantTyping", (p) => ParticipantTyping?.Invoke(p));
connection.Reconnecting += Reconnecting;
connection.Reconnected += Reconnected;
connection.Closed += Disconnected;
ServicePointManager.DefaultConnectionLimit = 10;
client = new Client();
await client.Start();
//await connection.Start();
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// create input engine
new InputEngine(this);
new FadeTextManager(this);
new ChatTextManager(this);
new Leaderboard(this);
_tManager = new TileManager();
cam = new Camera(Vector2.Zero,
new Vector2(tileMap.GetLength(1) * tileWidth, tileMap.GetLength(0) * tileHeight));
// TODO: Add your initialization logic here change local host to newly created local host
serverConnection = new HubConnection("http://cgmazerunner.azurewebsites.net");
serverConnection.StateChanged += ServerConnection_StateChanged;
proxy = serverConnection.CreateHubProxy("GameHub");
serverConnection.Start();
Action <PlayerData> joined = clientJoined;
proxy.On <PlayerData>("Joined", joined);
Action <string> Leave = clientleft;
proxy.On <string>("left", Leave);
Action <List <PlayerData> > currentPlayers = clientPlayers;
proxy.On <List <PlayerData> >("CurrentPlayers", currentPlayers);
Action <string> _Chat = writeChat;
proxy.On <string>("chat", _Chat);
Action <string> LeaderB = writeLeaderboard;
proxy.On <string>("leader", LeaderB);
Action <string, Position> otherMove = clientOtherMoved;
proxy.On <string, Position>("OtherMove", otherMove);
// Add the proxy client as a Game service o components can send messages
Services.AddService <IHubProxy>(proxy);
base.Initialize();
}
public void Init()
{
if (_isInitialized)
{
return;
}
_isInitialized = true;
_hubConnection = new HubConnection(Secrets.GoHubUrl);
_goHub = _hubConnection.CreateHubProxy("GoHub");
_goHub.On(nameof(UserConnected), (UserPrefs user) => UserConnected?.Invoke(user));
_goHub.On(nameof(UserDisconnected), (string user) => UserDisconnected?.Invoke(user));
_goHub.On(nameof(LobbyPost), (Post post) => LobbyPost?.Invoke(post));
_goHub.On(nameof(GamePost), (Post post) => GamePost?.Invoke(post));
_goHub.On(nameof(GameRequested), (string name) => GameRequested?.Invoke(name));
_goHub.On(nameof(GameRequestDeclined), (string name) => GameRequestDeclined?.Invoke(name));
_goHub.On(nameof(GameRequestCancelled), (string name) => GameRequestCancelled?.Invoke(name));
_goHub.On(nameof(GameRequestAccepted), (string name) => GameRequestAccepted?.Invoke(name));
_goHub.On(nameof(GameAborted), (string name) => GameAborted?.Invoke(name));
}
private async void TestEmoConnection()
{
// Establish a connection to our Hub. The Hub is created in EmotivBridgeClassic
var hubConnection = new HubConnection("http://localhost:16566/");
// Get a proxy to our hub instance.
IHubProxy emotiveProxy = hubConnection.CreateHubProxy("EmotivBridgeHub");
// Wire up the UpdateEmotion event. When the server fires this event, it will call this code.
emotiveProxy.On("UpdateEmotion",
emo =>
{
// Not the best way to parse this data. JObject is from JSON.NET
// http://www.newtonsoft.com/json
var data = emo as JObject;
Debug.WriteLine(String.Format("My new emotion is {0} with magnitude {1} ",
Enum.Parse(typeof(EmotivEmotion),
data.SelectToken("Emotion").ToString()).ToString(),
data.SelectToken("Magnitude").ToString()).ToString()
);
// fix to use enum
String currentEmotion = Enum.Parse(typeof(EmotivEmotion), data.SelectToken("Emotion").ToString()).ToString();
if (currentEmotion == "ANGRY")
{
_spheroController.ChangeColor(SpheroColor.RED);
}
else if (currentEmotion == "HAPPY")
{
_spheroController.ChangeColor(SpheroColor.GREEN);
}
else
{
_spheroController.ChangeColor(SpheroColor.WHITE);
}
});
// Start the controller and kick off the listening
// Find InitializeController in EmotivServer
await hubConnection.Start();
await emotiveProxy.Invoke("InitializeController");
}
static void Main(string[] args)
{
HubConnection hub = new HubConnection("http://localhost:64277");
IHubProxy proxy = hub.CreateHubProxy("TimeQuery");
proxy.On("addMessage", message =>
{
Console.WriteLine(message);
});
hub.Start().Wait();
proxy.Invoke("StartTimer");
string line = null;
while ((line = Console.ReadLine()) != null)
{
}
}
static void Main(string[] args)
{
HubConnection connection = new HubConnection("http://localhost:56859");
proxy = connection.CreateHubProxy("UserInputHub");
//connection.Received += Connection_Received;
Action <int> sendPlayerNum = recieved_player_num;
Action <string, string> SendMessagerecieved = recieved_a_message;
Action <bool> sendValidated = recieved_validated;
proxy.On("BroadcastMessage", SendMessagerecieved);
connection.Start().Wait();
ModelUsers1 db = new ModelUsers1();
UsersViewModel uvm = new UsersViewModel();
//UsersDb db = new UsersDb();
name = null;
password = null;
Console.Write("User Name:");
name = Console.ReadLine();
Console.Write("\nPassword:"******"Please fill in all the details.");
}
if (name != null || password != null)
{
proxy.Invoke("RequestValidation", new object[] { name, password });
proxy.Invoke("RequestValidated");
}
//ServerSide.Models.UsersDb
}
public async void StartHub()
{
var hubConnection = new HubConnection("http://localhost:5263/signalr");
IHubProxy tickerHubProxy = hubConnection.CreateHubProxy("TickerHub");
await hubConnection.Start();
SendSubscription(tickerHubProxy).Wait();
tickerHubProxy.On <IEnumerable <TickerDto> >("SendTickers", tickers =>
{
foreach (var ticker in tickers)
{
Console.WriteLine("Stock update for '{0}' new price {1}", ticker.Name, ticker.Price);
}
});
}
public MainPage()
{
this.InitializeComponent();
Messages.Add("Connecting...");
_hubConnection = new HubConnection(ServerURI);
_hubConnection.Closed += HubConnectionClosed;
_hubProxy = _hubConnection.CreateHubProxy("ChatHub");
_hubProxy.On <string, string>("BroadcastMessage", OnMessageReceived);
try
{
_hubConnection.Start();
}
catch (HttpRequestException ex)
{
Messages.Add(ex.Message);
}
Messages.Add("client connected");
}
public SignalConnector(Action <Response> listener)
{
OnMessageReceived = listener;
chatConnection = new HubConnection("http://chatsignalrtst.apphb.com/", true);
SignalRChatHub = chatConnection.CreateHubProxy("ChatHub");
SignalRChatHub.On <string, string>("addNewMessageToPage", (timestamp, message) =>
{
if (OnMessageReceived != null)
{
var response = new Response()
{
Size = MeasureSize(message), Delay = MeasureDelay(timestamp), Message = message
};
listener(response);
}
});
}
public async Task Connect(string url, Action <MessageDto> callback)
{
connection = connection ?? new HubConnection(url);
proxy = proxy ?? connection.CreateHubProxy(nameof(GameHub));
proxy.On <string>("SendMessage", messageJson =>
{
callback(JsonConvert.DeserializeObject <MessageDto>(messageJson, new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto,
ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor
}));
});
await connection.Start();
await proxy.Invoke("SendToHost", new MessageDto { MessageType = Core.Enums.MessageType.InitialConnection });
}
public async Task HubProgressThrowsInvalidOperationExceptionIfAttemptToReportProgressAfterMethodReturn(HostType hostType, TransportType transportType, MessageBusType messageBusType)
{
using (var host = CreateHost(hostType, transportType))
{
host.Initialize(messageBusType: messageBusType);
HubConnection hubConnection = CreateHubConnection(host);
IHubProxy proxy = hubConnection.CreateHubProxy("progress");
proxy.On <bool>("sendProgressAfterMethodReturnResult", result => Assert.True(result));
using (hubConnection)
{
await hubConnection.Start(host.Transport);
await proxy.Invoke <int>("SendProgressAfterMethodReturn", _ => { });
}
}
}
public ServerEventsManager(string apiUri)
{
IDictionary <string, string> queryString = new Dictionary <string, string>
{
["id"] = _id.ToString()
};
_hubConnection = new HubConnection(apiUri, queryString);
_hubConnection.StateChanged += HubConnection_StateChanged;
_hubConnection.Closed += HubConnection_Closed;
_hubConnection.ConnectionSlow += HubConnection_ConnectionSlow;
_hubConnection.Error += HubConnection_Error;
_hubConnection.Received += HubConnection_Received;
_hubConnection.Reconnected += HubConnection_Reconnected;
_hubConnection.Reconnecting += HubConnection_Reconnecting;
_hubProxy = _hubConnection.CreateHubProxy("UpdatesHub");
_hubProxy.On <TypeOfInterest>(nameof(IClient.Updated), OnUpdated);
Console.WriteLine($"Created {nameof(ServerEventsManager)} with id={_id}");
}
public async void On1()
{
using (HubConnection connection = new HubConnection(BaseUrl))
{
IHubProxy hubProxy = connection.CreateHubProxy("TestHub");
await connection.Start();
ManualResetEvent resetEvent = new ManualResetEvent(false);
int value1 = 0;
hubProxy.On <int>("ClientCallback", (v1) => { value1 = v1; resetEvent.Set(); });
await hubProxy.Invoke("InvokeClientCallback1", 1);
Assert.True(resetEvent.WaitOne(3000));
Assert.Equal(1, value1);
}
}
async Task RegisterPC(ComputerInfo computer)
{
hubCnn = new HubConnection("http://*****:*****@"temp.txt", true))
{
outfile.WriteLine(msg);
}
});
await hubCnn.Start();
await hubProxy.Invoke("RegisterPCClient", computer.Make, computer.Model);
}
public void Configuration(IAppBuilder app)
{
if (ConfigurationManagerHelper.GetValueOnKey("stardust.UseAzureAd") == "true")
{
ConfigureAuth(app);
}
if (ConfigurationManagerHelper.GetValueOnKey("stardust.UseRealtimeUpdate") == "true")
{
app.MapSignalR("/signalr", new HubConfiguration
{
EnableJSONP = true,
EnableDetailedErrors = true,
EnableJavaScriptProxies = true
});
hub = GlobalHost.ConnectionManager.GetHubContext <ConfigSetHub>();
Resolver.Activate <ICacheManagementService>().RegisterRealtimeNotificationService(
(id, environment) =>
{
try
{
Logging.DebugMessage("Sending update message {0}-{1}", id, environment);
hub.Clients.All.changed(id, environment);
}
catch (Exception ex)
{
ex.Log();
}
});
if (!Utilities.IsDevelopementEnv())
{
return;
}
hubConnection = new HubConnection("https://localhost:44305/");
hubClient = hubConnection.CreateHubProxy("configSetHub");
hubClient.On(
"changed",
(string id, string environment) =>
{
Logging.DebugMessage("UpdateMessage: {0}-{1}", id, environment);
});
hubConnection.Start();
}
}
// Connects to SignalR Server
void connectSignalR()
{
_connection.Start(); // Starts SignalR Connection
// Current message
var toFront = txtSignalRMessage.Text;
// Solves Cross threading issue
var uiCtx = SynchronizationContext.Current;
_hub.On("recieveMessage", x =>
{
// You are no longer on the UI thread, so you have to post back to it
uiCtx.Post(_ =>
{
// Put all code that touches the UI here
hubMessages(x);
}, null);
});
}
public IObservable <PriceDto> GetSpotStreamForConnection(string currencyPair, IHubProxy pricingHubProxy)
{
return(Observable.Create <PriceDto>(
observer =>
{
// subscribe to price feed first, otherwise there is a race condition
var priceSubscription = pricingHubProxy.On <PriceDto>(
"OnNewPrice",
p =>
{
if (p.Symbol == currencyPair)
{
observer.OnNext(p);
}
});
// send a subscription request
Console.WriteLine("Sending price subscription for currency pair {0}", currencyPair);
var subscription =
SendSubscription(currencyPair, pricingHubProxy)
.Subscribe(_ => Console.WriteLine("Subscribed to {0}", currencyPair), observer.OnError);
var unsubscriptionDisposable = Disposable.Create(
() =>
{
// send unsubscription when the observable gets disposed
Console.WriteLine("Sending price unsubscription for currency pair {0}", currencyPair);
SendUnsubscription(currencyPair, pricingHubProxy)
.Subscribe(
_ => Console.WriteLine("Unsubscribed from {0}", currencyPair),
ex =>
Console.WriteLine(
"An error occurred while sending unsubscription request for {0}:{1}",
currencyPair,
ex.Message));
});
return new CompositeDisposable {
priceSubscription, unsubscriptionDisposable, subscription
};
}).Publish().RefCount());
}
public async Task ConnectAsync()
{
connection = new HubConnection(string.Format(url, "127.0.0.1", "8080"));
hubProxy = connection.CreateHubProxy("ChatHub");
hubProxy.On <User>("ParticipantLogin", (u) => ParticipantLoggedIn?.Invoke(u));
hubProxy.On <string>("ParticipantLogout", (n) => ParticipantLoggedOut?.Invoke(n));
hubProxy.On <string>("ParticipantDisconnection", (n) => ParticipantDisconnected?.Invoke(n));
hubProxy.On <string>("ParticipantReconnection", (n) => ParticipantReconnected?.Invoke(n));
hubProxy.On <string, string>("BroadcastMessage", (n, m) => NewMessage?.Invoke(n, m, MessageType.Broadcast));
hubProxy.On <string, string>("UnicastMessage", (n, m) => NewMessage?.Invoke(n, m, MessageType.Unicast));
hubProxy.On <string, string, string>("SetNewTask", (n, m, k) => SetNewTask?.Invoke(n, m, k));
connection.Reconnecting += Reconnecting;
connection.Reconnected += Reconnected;
connection.Closed += Disconnected;
ServicePointManager.DefaultConnectionLimit = 10;
await connection.Start();
}
public PictureView()
{
this.InitializeComponent();
InitializeVideo();
InitializeGPIO();
// SignalR connection
var hubConnection = new HubConnection("http://iotlock-api.azurewebsites.net");
IHubProxy lightingHubProxy = hubConnection.CreateHubProxy("LightingHub");
lightingHubProxy.On <string>("toggle", room =>
{
GpioPinValue value;
switch (room)
{
case "hallway":
value = hallwayPin.Read() == GpioPinValue.Low ? GpioPinValue.High : GpioPinValue.Low;
hallwayPin.Write(value);
hallwayPin.SetDriveMode(GpioPinDriveMode.Output);
break;
case "kitchen":
value = kitchenPin.Read() == GpioPinValue.Low ? GpioPinValue.High : GpioPinValue.Low;
kitchenPin.Write(value);
kitchenPin.SetDriveMode(GpioPinDriveMode.Output);
break;
case "garden":
value = gardenPin.Read() == GpioPinValue.Low ? GpioPinValue.High : GpioPinValue.Low;
gardenPin.Write(value);
gardenPin.SetDriveMode(GpioPinDriveMode.Output);
break;
case "bedroom":
value = bedroomPin.Read() == GpioPinValue.Low ? GpioPinValue.High : GpioPinValue.Low;
bedroomPin.Write(value);
bedroomPin.SetDriveMode(GpioPinDriveMode.Output);
break;
}
});
hubConnection.Start();
}
public bool Initialize(string cacheName, string clientId, string connection, Action<string, string> onExpireCache, Action<string, string, string> onMessage, Action<Exception> onError)
{
var connectionDict = connection.ToObject<Dictionary<string, object>>();
_cacheName = cacheName;
ClientId = clientId;
_url = connectionDict.GetSetting("url", "");
_hubConnection = new HubConnection(_url);
_proxy = _hubConnection.CreateHubProxy("CacheHub");
_proxy.On<string, string, string>("serverMessage", (cid, clientName, message) =>
{
Debug.WriteLine(message);
if (onMessage != null)
onMessage(cid, clientName, message);
});
_proxy.On<string, string>("expireCache", onExpireCache);
_hubConnection.ConnectionSlow += () =>
{
Debug.WriteLine("Connection problems...");
};
_hubConnection.Error += onError;
_hubConnection.Start().Wait();
return true;
}
