Eric lippert - Amazon Web Services

Now we can start adding things to the server. Open up MyServer
again and override a method called OnConnected. This method
will be invoked each time a client connects to the server. These
methods will all return Task so you can work with this in an
asynchronous manner.
The first parameter gives us information about the current request
such as the user, data posted and things like that. The second
parameter identifies the connection based on a connection id
(Guid). This id can be used to direct messages to the client.
WriteLine(data); };
myServer.Start();
You might need to change the port for your SignalR server. Once
you’ve done that, fire up a couple of instances of this application.
As you can see, the first one will get as many greetings as the
number of clients. This is because we are using broadcasting to
send the message to all the clients, as you can see below
There’s a property in PersistentConnection called Connection that
we can use to either broadcast or send data to all or one client. If
we want to broadcast to everyone except certain clients, we can
do this as well because Broadcast takes a second parameter which
tells us which clients to exclude.
In order to broadcast a message to each client that connects, we
do the following:
protected override Task OnConnected(IRequest request,
string
connectionId)
{
return Connection.Broadcast(“Hello there!”);
}
The same goes for sending a message to a specific client except
Send takes another parameter that defines what client is
receiving the message. As you might understand, this is quite low
level, and there’s no protocol defined for how the messages will
look or anything like that. You’ll need to figure that out yourself
when using persistent connections. So far, it’s still a lot nicer than
working directly with sockets. It’s time to start the project, as you
might see it will throw an error because your web browser does
not speak the language the server understands, so just ignore this
for now.
Connection to the server
To test if the message really is broadcasted to all clients, we need
to setup a couple of clients. Create a new console application
called MyClient and fire up the package management console
again and write the following:
Install-Package Microsoft.AspNet.SignalR.Client
Now open up Program.cs and add the following to your main
method:
You’ll notice that each message is sent instantly to each client
making it feel very close to real-time. Remember though that this
is on a local system and that we do indeed have some overhead in
a real-world scenario.
Persistent connections give you great power but you’re not getting
much more from the framework other than a nice abstraction on
top of the underlying transportation. As mentioned previously,
SignalR will detect which transportation is most suitable and use
that.
Hubs
If you’re not too comfortable working with something raw as
persistent connection, you really don’t have to worry. With SignalR
comes another abstraction called Hubs. This is an abstraction on
top of Persistent Connections which will make everything a lot
easier. If it wasn’t already easy enough, right
With Persistent Connections and larger applications, you might
imagine that you’d have to create a message loop which
translates the data sent to the server and calls the correct
delegate for that event. With Hubs, this is completely done for you.
You can simply create methods that you register to certain events
and are raised by clients.
To set it up, create a new empty web application project called
HubsServer and install SignalR into it using the package
management console as you saw before.
var myServer = new Connection(“http://localhost:8082/”);
myServer.Received += (string data) => { Console.
Create a new class called MyHubServer and inherit from Hub. This
will let you, pretty much like we saw with Persistent Connection,
DNcmagazine www.dotnetcurry.com | 17