public override void StartConnect()
{
if (this.State != TransportStates.Initial)
{
return;
}
HTTPManager.Logger.Information("LongPollingTransport", "StartConnect");
this.State = TransportStates.Connecting;
// https://github.com/aspnet/SignalR/blob/dev/specs/HubProtocol.md#overview
// When our connection is open, send the 'negotiation' message to the server.
var request = new HTTPRequest(BuildUri(this.connection.Uri), HTTPMethods.Post, OnHandshakeRequestFinished);
this.stream.Write(JsonProtocol.WithSeparator(string.Format("{{\"protocol\":\"{0}\", \"version\": 1}}", this.connection.Protocol.Encoder.Name)));
request.UploadStream = this.stream;
if (this.connection.AuthenticationProvider != null)
{
this.connection.AuthenticationProvider.PrepareRequest(request);
}
request.Send();
}
public void Should_be_able_to_stream(int count)
{
var jsonProtocol = new JsonProtocol();
var jsonPacketStream = new JsonPacketStream();
var messages = new List <byte[]>
{
jsonProtocol.SetPacketContents(1, "The quick brown fox jumped over the lazy dog"),
jsonProtocol.SetPacketContents(2, "Second message to be appended")
};
var message = messages[0].Concat(messages[1]).ToArray();
var messageResult = new List <byte[]>();
for (int i = 0; i < message.Length; i += count)
{
var array = message.Skip(i).Take(count).ToArray();
var result = jsonPacketStream.ParseBytes(array);
if (result != null)
{
messageResult.AddRange(result);
}
}
Assert.That(messageResult, Is.EqualTo(messages));
}
/// <summary>
/// GUI button callback
/// </summary>
public void OnConnectButton()
{
IProtocol protocol = null;
#if BESTHTTP_SIGNALR_CORE_ENABLE_GAMEDEVWARE_MESSAGEPACK
protocol = new MessagePackProtocol();
#else
protocol = new JsonProtocol(new LitJsonEncoder());
#endif
// Crete the HubConnection
hub = new HubConnection(new Uri(this.sampleSelector.BaseURL + this._path), protocol);
// Optionally add an authenticator
//hub.AuthenticationProvider = new BestHTTP.SignalRCore.Authentication.HeaderAuthenticator("<generated jwt token goes here>");
// Subscribe to hub events
hub.OnConnected += Hub_OnConnected;
hub.OnError += Hub_OnError;
hub.OnClosed += Hub_OnClosed;
hub.OnTransportEvent += (hub, transport, ev) => AddText(string.Format("Transport(<color=green>{0}</color>) event: <color=green>{1}</color>", transport.TransportType, ev));
// Set up server callable functions
hub.On("Send", (string arg) => AddText(string.Format("On '<color=green>Send</color>': '<color=yellow>{0}</color>'", arg)).AddLeftPadding(20));
hub.On <Person>("Person", (person) => AddText(string.Format("On '<color=green>Person</color>': '<color=yellow>{0}</color>'", person)).AddLeftPadding(20));
hub.On <Person, Person>("TwoPersons", (person1, person2) => AddText(string.Format("On '<color=green>TwoPersons</color>': '<color=yellow>{0}</color>', '<color=yellow>{1}</color>'", person1, person2)).AddLeftPadding(20));
// And finally start to connect to the server
hub.StartConnect();
AddText("StartConnect called");
SetButtons(false, false);
}
public void OnConnectButton()
{
IProtocol protocol = null;
#if BESTHTTP_SIGNALR_CORE_ENABLE_GAMEDEVWARE_MESSAGEPACK
protocol = new MessagePackProtocol();
#else
protocol = new JsonProtocol(new LitJsonEncoder());
#endif
// Crete the HubConnection
hub = new HubConnection(new Uri("http://localhost:5000" + this._path), protocol);
// Subscribe to hub events
hub.OnConnected += Hub_OnConnected;
hub.OnError += Hub_OnError;
hub.OnClosed += Hub_OnClosed;
hub.OnRedirected += Hub_Redirected;
hub.OnTransportEvent += (hub, transport, ev) => AddText(string.Format("Transport(<color=green>{0}</color>) event: <color=green>{1}</color>", transport.TransportType, ev));
// And finally start to connect to the server
hub.StartConnect();
AddText("StartConnect called");
SetButtons(false, false);
}
public void OnConnectButton()
{
// Server side of this example can be found here:
// https://github.com/Benedicht/BestHTTP_DemoSite/blob/master/BestHTTP_DemoSite/Hubs/
IProtocol protocol = null;
#if BESTHTTP_SIGNALR_CORE_ENABLE_GAMEDEVWARE_MESSAGEPACK
protocol = new MessagePackProtocol();
#else
protocol = new JsonProtocol(new LitJsonEncoder());
#endif
// Crete the HubConnection
hub = new HubConnection(new Uri(base.sampleSelector.BaseURL + this._hubPath), protocol);
hub.AuthenticationProvider = new PreAuthAccessTokenAuthenticator(new Uri(base.sampleSelector.BaseURL + this._jwtTokenPath));
hub.AuthenticationProvider.OnAuthenticationSucceded += AuthenticationProvider_OnAuthenticationSucceded;
hub.AuthenticationProvider.OnAuthenticationFailed += AuthenticationProvider_OnAuthenticationFailed;
// Subscribe to hub events
hub.OnConnected += Hub_OnConnected;
hub.OnError += Hub_OnError;
hub.OnClosed += Hub_OnClosed;
hub.OnTransportEvent += (hub, transport, ev) => AddText(string.Format("Transport(<color=green>{0}</color>) event: <color=green>{1}</color>", transport.TransportType, ev));
// And finally start to connect to the server
hub.StartConnect();
AddText("StartConnect called");
SetButtons(false, false);
}
private BlyncTcpClient.OnConnectedEvent SendIdentityOnConnectedEvent()
{
return((sender, eventArgs) =>
{
Console.WriteLine("Connected");
var devices = new List <Device>();
for (int i = 0; i < _blyncClient.NumberOfDevices; i++)
{
devices.Add(new Device {
DeviceId = i, DeviceType = _blyncClient.GetDeviceType(i).ToString()
});
}
var status = new JsonIdentityPacket
{
Name = Environment.MachineName,
Devices = devices
};
var protocol = new JsonProtocol();
var json = protocol.Serialize(status);
var packet = protocol.SetPacketContents(0, json);
_blyncTcpClient.Send(packet, new CancellationToken()).Wait();
});
}
// The websocket connection is open
private void OnOpen(WebSocket.WebSocket webSocket)
{
HTTPManager.Logger.Verbose("WebSocketTransport", "OnOpen");
// https://github.com/aspnet/SignalR/blob/dev/specs/HubProtocol.md#overview
// When our websocket connection is open, send the 'negotiation' message to the server.
(this as ITransport).Send(JsonProtocol.WithSeparator(string.Format("{{\"protocol\":\"{0}\", \"version\": 1}}", this.connection.Protocol.Name)));
}
private void OnOpen(WebSocket.WebSocket webSocket)
{
// When our websocket connection is open, send the 'negotiation' message to the server.
// It's not a real negotiation step, as we don't expect an answer to this.
string json = this.connection.ComposeNegotiationMessage();
byte[] buffer = JsonProtocol.WithSeparator(json);
Send(buffer);
}
public void OnConnectButton()
{
// Server side of this example can be found here:
// https://github.com/Benedicht/BestHTTP_DemoSite/blob/master/BestHTTP_DemoSite/Hubs/
#if BESTHTTP_SIGNALR_CORE_ENABLE_MESSAGEPACK_CSHARP
try
{
MessagePack.Resolvers.StaticCompositeResolver.Instance.Register(
MessagePack.Resolvers.DynamicEnumAsStringResolver.Instance,
MessagePack.Unity.UnityResolver.Instance,
//MessagePack.Unity.Extension.UnityBlitWithPrimitiveArrayResolver.Instance,
//MessagePack.Resolvers.StandardResolver.Instance,
MessagePack.Resolvers.ContractlessStandardResolver.Instance
);
var options = MessagePack.MessagePackSerializerOptions.Standard.WithResolver(MessagePack.Resolvers.StaticCompositeResolver.Instance);
MessagePack.MessagePackSerializer.DefaultOptions = options;
}
catch
{ }
#endif
IProtocol protocol = null;
#if BESTHTTP_SIGNALR_CORE_ENABLE_MESSAGEPACK_CSHARP
protocol = new MessagePackCSharpProtocol();
#elif BESTHTTP_SIGNALR_CORE_ENABLE_GAMEDEVWARE_MESSAGEPACK
protocol = new MessagePackProtocol();
#else
protocol = new JsonProtocol(new LitJsonEncoder());
#endif
// Crete the HubConnection
hub = new HubConnection(new Uri(base.sampleSelector.BaseURL + this._hubPath), protocol);
hub.AuthenticationProvider = new PreAuthAccessTokenAuthenticator(new Uri(base.sampleSelector.BaseURL + this._jwtTokenPath));
hub.AuthenticationProvider.OnAuthenticationSucceded += AuthenticationProvider_OnAuthenticationSucceded;
hub.AuthenticationProvider.OnAuthenticationFailed += AuthenticationProvider_OnAuthenticationFailed;
// Subscribe to hub events
hub.OnConnected += Hub_OnConnected;
hub.OnError += Hub_OnError;
hub.OnClosed += Hub_OnClosed;
hub.OnTransportEvent += (hub, transport, ev) => AddText(string.Format("Transport(<color=green>{0}</color>) event: <color=green>{1}</color>", transport.TransportType, ev));
// And finally start to connect to the server
hub.StartConnect();
AddText("StartConnect called");
SetButtons(false, false);
}
/// <summary>
/// GUI button callback
/// </summary>
public void OnConnectButton()
{
#if BESTHTTP_SIGNALR_CORE_ENABLE_MESSAGEPACK_CSHARP
try
{
MessagePack.Resolvers.StaticCompositeResolver.Instance.Register(
MessagePack.Resolvers.DynamicEnumAsStringResolver.Instance,
MessagePack.Unity.UnityResolver.Instance,
//MessagePack.Unity.Extension.UnityBlitWithPrimitiveArrayResolver.Instance,
//MessagePack.Resolvers.StandardResolver.Instance,
MessagePack.Resolvers.ContractlessStandardResolver.Instance
);
var options = MessagePack.MessagePackSerializerOptions.Standard.WithResolver(MessagePack.Resolvers.StaticCompositeResolver.Instance);
MessagePack.MessagePackSerializer.DefaultOptions = options;
}
catch
{ }
#endif
IProtocol protocol = null;
#if BESTHTTP_SIGNALR_CORE_ENABLE_MESSAGEPACK_CSHARP
protocol = new MessagePackCSharpProtocol();
#elif BESTHTTP_SIGNALR_CORE_ENABLE_GAMEDEVWARE_MESSAGEPACK
protocol = new MessagePackProtocol();
#else
protocol = new JsonProtocol(new LitJsonEncoder());
#endif
// Crete the HubConnection
hub = new HubConnection(new Uri(base.sampleSelector.BaseURL + this._path), protocol);
// Optionally add an authenticator
//hub.AuthenticationProvider = new BestHTTP.SignalRCore.Authentication.HeaderAuthenticator("<generated jwt token goes here>");
// Subscribe to hub events
hub.OnConnected += Hub_OnConnected;
hub.OnError += Hub_OnError;
hub.OnClosed += Hub_OnClosed;
hub.OnTransportEvent += (hub, transport, ev) => AddText(string.Format("Transport(<color=green>{0}</color>) event: <color=green>{1}</color>", transport.TransportType, ev));
// Set up server callable functions
hub.On("Send", (string arg) => AddText(string.Format("On '<color=green>Send</color>': '<color=yellow>{0}</color>'", arg)).AddLeftPadding(20));
hub.On <Person>("Person", (person) => AddText(string.Format("On '<color=green>Person</color>': '<color=yellow>{0}</color>'", person)).AddLeftPadding(20));
hub.On <Person, Person>("TwoPersons", (person1, person2) => AddText(string.Format("On '<color=green>TwoPersons</color>': '<color=yellow>{0}</color>', '<color=yellow>{1}</color>'", person1, person2)).AddLeftPadding(20));
// And finally start to connect to the server
hub.StartConnect();
AddText("StartConnect called");
SetButtons(false, false);
}
// The websocket connection is open
private void OnOpen(WebSocket.WebSocket webSocket)
{
HTTPManager.Logger.Verbose("WebSocketTransport", "OnOpen");
// https://github.com/aspnet/SignalR/blob/dev/specs/HubProtocol.md#overview
// When our websocket connection is open, send the 'negotiation' message to the server.
string json = string.Format("{{'protocol':'{0}', 'version': 1}}", this.connection.Protocol.Encoder.Name);
byte[] buffer = JsonProtocol.WithSeparator(json);
(this as ITransport).Send(buffer);
}
public void Connect(Uri uri)
{
var encoder = new LitJsonEncoder();
var protocol = new JsonProtocol(encoder);
connection = new HubConnection(uri, protocol);
connection.OnConnected += OnConnected;
connection.OnClosed += OnClosed;
connection.OnError += OnError;
connection.OnMessage += OnMessage;
connection.StartConnect();
}
public void Should_be_able_to_recieve_packet_from_server()
{
var packetProtocol = new JsonProtocol();
var server = new BlyncTcpServer(new TcpServerSettings
{
ConnectionTimeoutPeriod = 5000,
PacketStreamFactory = new JsonPacketStreamFactory(),
Port = Port
});
var client = new BlyncTcpClient(new TcpClientSettings
{
ConnectionTimeoutPeriod = 10000,
Hostname = "127.0.0.1",
PacketStreamFactory = new JsonPacketStreamFactory(),
Port = Port
});
var expectedMessage = packetProtocol.SetPacketContents(0, "Hello World!");
server.ClientConnectedEvent += (sender, args) =>
{
var clientContext = sender as TcpClientContext;
if (clientContext != null)
{
clientContext.Send(expectedMessage, new CancellationToken()).Wait();
}
};
byte[] actualMessage = null;
client.MessageReceivedEvent += (sender, args) =>
{
actualMessage = args;
client.Stop();
server.Stop();
};
server.Start();
client.Start();
var timeoutTask = Task.Delay(TimeSpan.FromSeconds(1));
while (!timeoutTask.IsCompleted && actualMessage == null)
{
// Wait
}
Assert.That(actualMessage, Is.EqualTo(expectedMessage));
}
public void Should_be_able_to_serialize_and_deserialize_correctly()
{
const string expectedMessage = "Hello World!";
const int expectedType = 4;
var jsonProtocol = new JsonProtocol();
var buffer = jsonProtocol.SetPacketContents(expectedType, expectedMessage);
var actualType = jsonProtocol.GetPacketType(buffer);
var length = jsonProtocol.GetPacketLength(buffer);
var actualMessage = jsonProtocol.GetPacketContents(buffer, length);
Assert.That(actualType, Is.EqualTo(expectedType));
Assert.That(actualMessage, Is.EqualTo(expectedMessage));
}
public void OnConnectButton()
{
#if BESTHTTP_SIGNALR_CORE_ENABLE_MESSAGEPACK_CSHARP
try
{
MessagePack.Resolvers.StaticCompositeResolver.Instance.Register(
MessagePack.Resolvers.DynamicEnumAsStringResolver.Instance,
MessagePack.Unity.UnityResolver.Instance,
//MessagePack.Unity.Extension.UnityBlitWithPrimitiveArrayResolver.Instance,
//MessagePack.Resolvers.StandardResolver.Instance,
MessagePack.Resolvers.ContractlessStandardResolver.Instance
);
var options = MessagePack.MessagePackSerializerOptions.Standard.WithResolver(MessagePack.Resolvers.StaticCompositeResolver.Instance);
MessagePack.MessagePackSerializer.DefaultOptions = options;
}
catch
{ }
#endif
IProtocol protocol = null;
#if BESTHTTP_SIGNALR_CORE_ENABLE_MESSAGEPACK_CSHARP
protocol = new MessagePackCSharpProtocol();
#elif BESTHTTP_SIGNALR_CORE_ENABLE_GAMEDEVWARE_MESSAGEPACK
protocol = new MessagePackProtocol();
#else
protocol = new JsonProtocol(new LitJsonEncoder());
#endif
// Crete the HubConnection
hub = new HubConnection(new Uri(this.sampleSelector.BaseURL + this._path), protocol);
// Subscribe to hub events
hub.OnConnected += Hub_OnConnected;
hub.OnError += Hub_OnError;
hub.OnClosed += Hub_OnClosed;
hub.OnRedirected += Hub_Redirected;
hub.OnTransportEvent += (hub, transport, ev) => AddText(string.Format("Transport(<color=green>{0}</color>) event: <color=green>{1}</color>", transport.TransportType, ev));
// And finally start to connect to the server
hub.StartConnect();
AddText("StartConnect called");
SetButtons(false, false);
}
private BlyncTcpClient.OnMessageReceivedEvent ExcuteInstructionsOnMessageReceivedEvent()
{
return((sender, bytes) =>
{
Console.WriteLine("Message recieved");
var protocol = new JsonProtocol();
var type = protocol.GetPacketType(bytes);
var length = protocol.GetPacketLength(bytes);
var content = protocol.GetPacketContents(bytes, length);
if (type == 1)
{
var instruction = protocol.Deserialize <JsonInstructionPacket>(content);
_instructionExecuter.Execute(instruction);
}
});
}
public void Should_be_notified_when_client_sends_a_message()
{
var expectedMessage = new JsonProtocol().SetPacketContents(0, "Hello world!");
var server = new BlyncTcpServer(new TcpServerSettings
{
Port = Port,
PacketStreamFactory = new JsonPacketStreamFactory()
});
byte[] actualMessage = null;
server.MessageReceivedEvent += (sender, args) =>
{
var context = sender as TcpClientContext;
if (context != null)
{
actualMessage = args;
}
server.Stop();
};
server.Start();
var tcpClient = new TcpClient("127.0.0.1", Port);
var stream = tcpClient.GetStream();
stream.Write(expectedMessage, 0, expectedMessage.Length);
var timeoutTask = Task.Delay(TimeSpan.FromSeconds(1));
while (!timeoutTask.IsCompleted && actualMessage == null)
{
// Wait
}
Assert.That(actualMessage, Is.EqualTo(expectedMessage));
}
public static string JsonSerialize(ObservableCollection <PlayerEntry> players, int?tableN, int?gameN,
ObservableCollection <int?> bestWayContainer, ObservableCollection <int?> killedAtNight, bool ugad, ObservableCollection <int?> ugadaykaContainer,
bool redWin, bool techRed, bool blackWin, bool techBlack, bool sheriffFirstNight, bool threeZv, bool authomate, int?falseCom)
{
var convertedPlayers = players.Select(t => new JsonPlayerEntry
{
Result = t.Result,
Foul = t.Foul,
Role = t.Role,
Nick = t.Nick,
Reflection = t.Reflection,
PositionInKillQueue = t.PositionInKillQueue,
KilledAtNight = t.KilledAtNight,
KilledAtDay = t.KilledAtDay,
CheckedAtNight = t.CheckedAtNight
});
var target = new JsonProtocol
{
Players = convertedPlayers.ToList(),
FalseCom = falseCom,
Ugadayka = ugadaykaContainer.ToList(),
BestPlayers =
players.Where(p => p.Reflection >= 0 && (p.Foul < 4 || p.Foul == null)).Select(t => t.Nick).ToList(),
BestWay = bestWayContainer.ToList(),
Date = DateTime.Now,
FirstNightSheriff = sheriffFirstNight,
Game = gameN,
Table = tableN,
NightKill = killedAtNight.ToList(),
ThreeZv = threeZv,
UgadaykaOn = ugad,
Winner = redWin ? techRed ? "TechRed" : "Red" : techBlack ? "TechBlack" : "Black"
};
return(JsonConvert.SerializeObject(target));
}
static void Main(string[] args)
{
var port = Int32.Parse(args[0]);
Console.WriteLine("Listening to port {0}", port);
var protocol = new JsonProtocol();
var server = new BlyncTcpServer(new TcpServerSettings
{
ConnectionTimeoutPeriod = 15000,
PacketStreamFactory = new JsonPacketStreamFactory(),
Port = port
});
server.ClientConnectedEvent += (sender, eventArgs) =>
{
var client = sender as TcpClientContext;
if (client != null)
{
Console.WriteLine("Client connected [{0}]", client.Id);
var redPacket = protocol.SetPacketContents(1, protocol.Serialize(new JsonInstructionPacket {
Color = "red"
}));
var greenPacket = protocol.SetPacketContents(1, protocol.Serialize(new JsonInstructionPacket {
Color = "green"
}));
for (int i = 0; i < 10; i++)
{
if (i % 2 == 0)
{
client.Send(redPacket, new CancellationToken()).Wait();
}
else
{
client.Send(greenPacket, new CancellationToken()).Wait();
}
Thread.Sleep(2000);
}
}
};
server.ClientDisconnectedEvent += (sender, eventArgs) =>
{
var client = sender as TcpClientContext;
if (client != null)
{
Console.WriteLine("Client disconnected [{0}]", client.Id);
}
};
server.MessageReceivedEvent += (sender, bytes) =>
{
var client = sender as TcpClientContext;
if (client != null)
{
Console.WriteLine("Client disconnected [{0}]", client.Id);
var type = protocol.GetPacketType(bytes);
var length = protocol.GetPacketLength(bytes);
var content = protocol.GetPacketContents(bytes, length);
Console.WriteLine(" [{0}] {1}", type, content);
}
};
try
{
server.Start();
Thread.Sleep(400000);
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
if (exception.InnerException != null)
{
foreach (var innerExceptionMessage in exception.InnerException.Message)
{
Console.WriteLine(" {0}", innerExceptionMessage);
}
}
}
}
void OnConnectButton()
{
#if CSHARP_7_OR_LATER
#if BESTHTTP_SIGNALR_CORE_ENABLE_MESSAGEPACK_CSHARP
try
{
MessagePack.Resolvers.StaticCompositeResolver.Instance.Register(
MessagePack.Resolvers.DynamicEnumAsStringResolver.Instance,
MessagePack.Unity.UnityResolver.Instance,
//MessagePack.Unity.Extension.UnityBlitWithPrimitiveArrayResolver.Instance,
//MessagePack.Resolvers.StandardResolver.Instance,
MessagePack.Resolvers.ContractlessStandardResolver.Instance
);
var options = MessagePack.MessagePackSerializerOptions.Standard.WithResolver(MessagePack.Resolvers.StaticCompositeResolver.Instance);
MessagePack.MessagePackSerializer.DefaultOptions = options;
}
catch
{ }
#endif
IProtocol protocol = null;
#if BESTHTTP_SIGNALR_CORE_ENABLE_MESSAGEPACK_CSHARP
protocol = new MessagePackCSharpProtocol();
#elif BESTHTTP_SIGNALR_CORE_ENABLE_GAMEDEVWARE_MESSAGEPACK
protocol = new MessagePackProtocol();
#else
protocol = new JsonProtocol(new LitJsonEncoder());
#endif
// Crete the HubConnection
hub = new HubConnection(new Uri(this.sampleSelector.BaseURL + this._path), protocol);
// Subscribe to hub events
hub.OnError += Hub_OnError;
hub.OnTransportEvent += (hub, transport, ev) => AddText(string.Format("Transport(<color=green>{0}</color>) event: <color=green>{1}</color>", transport.TransportType, ev));
// Set up server callable functions
hub.On("Send", (string arg) => AddText(string.Format("On '<color=green>Send</color>': '<color=yellow>{0}</color>'", arg)).AddLeftPadding(20));
hub.On <Person>("Person", (person) => AddText(string.Format("On '<color=green>Person</color>': '<color=yellow>{0}</color>'", person)).AddLeftPadding(20));
hub.On <Person, Person>("TwoPersons", (person1, person2) => AddText(string.Format("On '<color=green>TwoPersons</color>': '<color=yellow>{0}</color>', '<color=yellow>{1}</color>'", person1, person2)).AddLeftPadding(20));
AddText("StartConnect called");
SetButtons(false, false);
// And finally start to connect to the server
await hub.ConnectAsync();
SetButtons(false, true);
AddText(string.Format("Hub Connected with <color=green>{0}</color> transport using the <color=green>{1}</color> encoder.", hub.Transport.TransportType.ToString(), hub.Protocol.Name));
// Call a server function with a string param. We expect no return value.
await hub.SendAsync("Send", "my message");
// Call a parameterless function. We expect a string return value.
try
{
string result = await hub.InvokeAsync <string>("NoParam");
AddText(string.Format("'<color=green>NoParam</color>' returned: '<color=yellow>{0}</color>'", result))
.AddLeftPadding(20);
}
catch (Exception ex)
{
AddText(string.Format("'<color=green>NoParam</color>' error: '<color=red>{0}</color>'", ex.Message)).AddLeftPadding(20);
}
// Call a function on the server to add two numbers. OnSuccess will be called with the result and OnError if there's an error.
var addResult = await hub.InvokeAsync <int>("Add", 10, 20);
AddText(string.Format("'<color=green>Add(10, 20)</color>' returned: '<color=yellow>{0}</color>'", addResult)).AddLeftPadding(20);
var nullabelTestResult = await hub.InvokeAsync <int?>("NullableTest", 10);
AddText(string.Format("'<color=green>NullableTest(10)</color>' returned: '<color=yellow>{0}</color>'", nullabelTestResult)).AddLeftPadding(20);
// Call a function that will return a Person object constructed from the function's parameters.
var getPersonResult = await hub.InvokeAsync <Person>("GetPerson", "Mr. Smith", 26);
AddText(string.Format("'<color=green>GetPerson(\"Mr. Smith\", 26)</color>' returned: '<color=yellow>{0}</color>'", getPersonResult)).AddLeftPadding(20);
// To test errors/exceptions this call always throws an exception on the server side resulting in an OnError call.
// OnError expected here!
try
{
var singleResultFailureResult = await hub.InvokeAsync <int>("SingleResultFailure", 10, 20);
AddText(string.Format("'<color=green>SingleResultFailure(10, 20)</color>' returned: '<color=yellow>{0}</color>'", singleResultFailureResult)).AddLeftPadding(20);
}
catch (Exception ex)
{
AddText(string.Format("'<color=green>SingleResultFailure(10, 20)</color>' error: '<color=red>{0}</color>'", ex.Message)).AddLeftPadding(20);
}
// This call demonstrates IEnumerable<> functions, result will be the yielded numbers.
var batchedResult = await hub.InvokeAsync <int[]>("Batched", 10);
AddText(string.Format("'<color=green>Batched(10)</color>' returned items: '<color=yellow>{0}</color>'", batchedResult.Length)).AddLeftPadding(20);
// OnItem is called for a streaming request for every items returned by the server. OnSuccess will still be called with all the items.
hub.GetDownStreamController <int>("ObservableCounter", 10, 1000)
.OnItem(result => AddText(string.Format("'<color=green>ObservableCounter(10, 1000)</color>' OnItem: '<color=yellow>{0}</color>'", result)).AddLeftPadding(20))
.OnSuccess(result => AddText("'<color=green>ObservableCounter(10, 1000)</color>' OnSuccess.").AddLeftPadding(20))
.OnError(error => AddText(string.Format("'<color=green>ObservableCounter(10, 1000)</color>' error: '<color=red>{0}</color>'", error)).AddLeftPadding(20));
// A stream request can be cancelled any time.
var controller = hub.GetDownStreamController <int>("ChannelCounter", 10, 1000);
controller.OnItem(result => AddText(string.Format("'<color=green>ChannelCounter(10, 1000)</color>' OnItem: '<color=yellow>{0}</color>'", result)).AddLeftPadding(20))
.OnSuccess(result => AddText("'<color=green>ChannelCounter(10, 1000)</color>' OnSuccess.").AddLeftPadding(20))
.OnError(error => AddText(string.Format("'<color=green>ChannelCounter(10, 1000)</color>' error: '<color=red>{0}</color>'", error)).AddLeftPadding(20));
// a stream can be cancelled by calling the controller's Cancel method
controller.Cancel();
// This call will stream strongly typed objects
hub.GetDownStreamController <Person>("GetRandomPersons", 20, 2000)
.OnItem(result => AddText(string.Format("'<color=green>GetRandomPersons(20, 1000)</color>' OnItem: '<color=yellow>{0}</color>'", result)).AddLeftPadding(20))
.OnSuccess(result => AddText("'<color=green>GetRandomPersons(20, 1000)</color>' OnSuccess.").AddLeftPadding(20));
#endif
}
