Many applications have
the need to stay in-sync with data provided by a service. Although web applications typically rely on standard polling techniques to check if data has changed, Silverlight provides several interesting options for keeping an application in-sync that rely on server “push” technologies. A few years back I wrote several blog posts covering different “push” technologies available in Silverlight that rely on sockets or HTTP Polling Duplex. We recently had a project that looked like it could benefit from pushing data from a server to one or more clients so I thought I’d revisit
the subject
and provide some updates to
the original code posted. If you’ve worked with AJAX before in Web applications then you know that until browsers fully support web sockets or other duplex (bi-directional communication) technologies that it’s difficult to keep applications in-sync with a server without relying on polling.
The problem with polling is that you have to check for changes on
the server on a timed-basis which can often be wasteful
and take up unnecessary resources. With server “push” technologies, data can be pushed from
the server to
the client as it changes. Once
the data is received,
the client can update
the user interface as appropriate. Using “push” technologies allows
the client to listen for changes from
the data but stay 100% focused on client activities as opposed to worrying about polling
and asking
the server if anything has changed. Silverlight provides several options for pushing data from a server to a client including sockets, TCP bindings
and HTTP Polling Duplex. Each has its own strengths
and weaknesses as far as performance
and setup work with HTTP Polling Duplex arguably being
the easiest to setup
and get going. In this article I’ll demonstrate how HTTP Polling Duplex can be used in Silverlight 4 applications to push data
and show how you can create a WCF server that provides an HTTP Polling Duplex binding that a Silverlight client can consume. What is HTTP Polling Duplex? Technologies that allow data to be pushed from a server to a client rely on duplex functionality. Duplex (or bi-directional) communication allows data to be passed in both directions. A client can call a service
and the server can call
the client. HTTP Polling Duplex (as its name implies) allows a server to communicate with a client without forcing
the client to constantly poll
the server. It has
the benefit of being able to run on port 80 making setup a breeze compared to
the other options which require specific ports to be used
and cross-domain policy files to be exposed on port 943 (as with sockets
and TCP bindings). Having said that, if you’re looking for
the best speed possible then sockets
and TCP bindings are
the way to go. But, they’re not
the only game in town when it comes to duplex communication.
The first time I heard about HTTP Polling Duplex (initially available in Silverlight 2) I wasn’t exactly sure how it was any better than standard polling used in AJAX applications. I read
the Silverlight SDK, looked at various resources
and generally found
the following definition unhelpful as far as understanding
the actual benefits that HTTP Polling Duplex provided: "The Silverlight client periodically polls
the service on
the network layer,
and checks for any new messages that
the service wants to send on
the callback channel.
The service queues all messages sent on
the client callback channel
and delivers them to
the client when
the client polls
the service." Although
the previous definition explained
the overall process, it sounded as if standard polling was used. Fortunately, Microsoft’s
Scott Guthrie provided me with a more clear definition several years back that explains
the benefits provided by HTTP Polling Duplex quite well (used with his permission): "The [HTTP Polling Duplex] duplex support does use polling in
the background to implement notifications – although
the way it does it is different than manual polling. It initiates a network request,
and then
the request is effectively “put to sleep” waiting for
the server to respond (it doesn’t come back immediately).
The server then keeps
the connection open but not active until it has something to send back (or
the connection times out after 90 seconds – at which point
the duplex client will connect again
and wait). This way you are avoiding hitting
the server repeatedly – but still get an immediate response when there is data to send." After hearing Scott’s definition
the light bulb went on
and it all made sense. A client makes a request to a server to check for changes, but instead of
the request returning immediately, it parks itself on
the server
and waits for data. It’s kind of like waiting to pick up a pizza at
the store. Instead of calling
the store over
and over to check
the status, you sit in
the store
and wait until
the pizza (the request data) is ready. Once it’s ready you take it back home (to
the client). This technique provides a lot of efficiency gains over standard polling techniques even though it does use some polling of its own as a request is initially made from a client to a server. So how do you implement HTTP Polling Duplex in your Silverlight applications? Let’s take a look at
the process by starting with
the server. Creating an HTTP Polling Duplex WCF Service Creating a WCF service that exposes an HTTP Polling Duplex binding is straightforward as far as coding goes. Add some one way operations into an interface, create a client callback interface
and you’re ready to go.
The most challenging part comes into play when configuring
the service to properly support
the necessary binding
and that’s more of a cut
and paste operation once you know
the configuration code to use. To create an HTTP Polling Duplex service you’ll need to expose server-side
and client-side interfaces
and reference
the System.ServiceModel.PollingDuplex assembly (located at C:\Program Files (x86)\Microsoft SDKs\Silverlight\v4.0\Libraries\Server on my machine) in
the server project. For
the demo application I upgraded a basketball simulation service to support
the latest polling duplex assemblies.
The service simulates a simple basketball game using a Game class
and pushes information about
the game such as score, fouls, shots
and more to
the client as
the game changes over time. Before jumping too far into
the game push service, it’s important to discuss two interfaces used by
the service to communicate in a bi-directional manner.
The first is called IGameStreamService
and defines
the methods/operations that
the client can call on
the server (see Listing 1).
The second is IGameStreamClient which defines
the callback methods that a server can use to communicate with a client (see Listing 2). [ServiceContract(Namespace = "Silverlight", CallbackContract = typeof(IGameStreamClient))]
public interface IGameStreamService
{
[OperationContract(IsOneWay = true)]
void GetTeamData();
}
Listing 1.
The IGameStreamService interface defines server operations that can be called on
the server.
[ServiceContract]
public interface IGameStreamClient
{
[OperationContract(IsOneWay = true)]
void ReceiveTeamData(List<Team> teamData);
[OperationContract(IsOneWay = true, AsyncPattern=true)]
IAsyncResult BeginReceiveGameData(GameData gameData, AsyncCallback callback, object state);
void EndReceiveGameData(IAsyncResult result);
}
Listing 2.
The IGameStreamClient interfaces defines client operations that a server can call.
The IGameStreamService interface is decorated with
the standard ServiceContract attribute but also contains a value for
the CallbackContract property. This property is used to define
the interface that
the client will expose (IGameStreamClient in this example)
and use to receive data pushed from
the service. Notice that each OperationContract attribute in both interfaces sets
the IsOneWay property to true. This means that
the operation can be called
and passed data as appropriate, however, no data will be passed back. Instead, data will be pushed back to
the client as it’s available. Looking through
the IGameStreamService interface you can see that
the client can request
team data whereas
the IGameStreamClient interface allows
team and game data to be received by
the client.
One interesting point about
the IGameStreamClient interface is
the inclusion of
the AsyncPattern property on
the BeginReceiveGameData operation. I initially created this operation as a standard one way operation
and it worked most of
the time. However, as I disconnected clients
and reconnected new ones game data wasn’t being passed properly. After researching
the problem more I realized that because
the service could take up to 7 seconds to return game data, things were getting hung up. By setting
the AsyncPattern property to true on
the BeginReceivedGameData operation
and providing a corresponding EndReceiveGameData operation I was able to get around this problem
and get everything running properly. I’ll provide more details on
the implementation of these two methods later in this post.
Once
the interfaces were created I moved on to
the game service class.
The first order of business was to create a class that implemented
the IGameStreamService interface. Since
the service can be used by multiple clients wanting game data I added
the ServiceBehavior attribute to
the class definition so that I could set its InstanceContextMode to InstanceContextMode.Single (in effect creating a Singleton service object). Listing 3 shows
the game service class as well as its fields
and constructor.
[ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple, InstanceContextMode = InstanceContextMode.Single)]
public class GameStreamService : IGameStreamService
{
object _Key = new object();
Game _Game = null;
Timer _Timer = null;
Random _Random = null;
Dictionary<string, IGameStreamClient> _ClientCallbacks = new Dictionary<string, IGameStreamClient>();
static AsyncCallback _ReceiveGameDataCompleted = new AsyncCallback(ReceiveGameDataCompleted);
public GameStreamService()
{
_Game = new Game();
_Timer = new Timer { Enabled = false, Interval = 2000, AutoReset = true }; _Timer.Elapsed += new ElapsedEventHandler(_Timer_Elapsed);
_Timer.Start();
_Random = new Random();
}}
Listing 3.
The GameStreamService implements
the IGameStreamService interface which defines a callback contract that allows
the service class to push data back to
the client.
By implementing
the IGameStreamService interface, GameStreamService must supply a GetTeamData() method which is responsible for supplying information about
the teams that are playing as well as individual players. GetTeamData() also acts as a client subscription method that tracks clients wanting to receive game data. Listing 4 shows
the GetTeamData() method.
public void GetTeamData()
{
//Get client callback channel
var context = OperationContext.Current;
var sessionID = context.SessionId;
var currClient = context.GetCallbackChannel<IGameStreamClient>();
context.Channel.Faulted += Disconnect;
context.Channel.Closed += Disconnect;
IGameStreamClient client;
if (!_ClientCallbacks.TryGetValue(sessionID, out client))
{
lock (_Key)
{
_ClientCallbacks[sessionID] = currClient;
}
}
currClient.ReceiveTeamData(_Game.GetTeamData());
//Start timer which when fired sends updated score information to client
if (!_Timer.Enabled)
{
_Timer.Enabled = true;
}
}
Listing 4.
The GetTeamData() method subscribes a given client to
the game service
and returns.
The key
the line of code in
the GetTeamData() method is
the call to GetCallbackChannel<IGameStreamClient>(). This method is responsible for accessing
the calling client’s callback channel.
The callback channel is defined by
the IGameStreamClient interface shown earlier in Listing 2
and used by
the server to communicate with
the client. Before passing
team data back to
the client, GetTeamData() grabs
the client’s session ID
and checks if it already exists in
the _ClientCallbacks dictionary object used to track clients wanting callbacks from
the server. If
the client doesn’t exist it adds it into
the collection. It then pushes
team data from
the Game class back to
the client by calling ReceiveTeamData(). Since
the service simulates a basketball game, a timer is then started if it’s not already enabled which is then used to randomly send data to
the client.
When
the timer fires, game data is pushed down to
the client. Listing 5 shows
the _Timer_Elapsed() method that is called when
the timer fires as well as
the SendGameData() method used to send data to
the client.
void _Timer_Elapsed(object sender, ElapsedEventArgs e)
{
int interval = _Random.Next(3000, 7000);
lock (_Key)
{
_Timer.Interval = interval;
_Timer.Enabled = false;
}
SendGameData(_Game.GetGameData());
}
private void SendGameData(GameData gameData)
{
var cbs = _ClientCallbacks.Where(cb => ((IContextChannel)cb.Value).State == CommunicationState.Opened);
for (int i = 0; i < cbs.Count(); i++)
{
var cb = cbs.ElementAt(i).Value;
try
{
cb.BeginReceiveGameData(gameData, _ReceiveGameDataCompleted, cb);
}
catch (TimeoutException texp)
{
//Log timeout error
}
catch (CommunicationException cexp)
{
//Log communication error
}
}
lock (_Key) _Timer.Enabled = true;
}
private static void ReceiveGameDataCompleted(IAsyncResult result)
{
try
{
((IGameStreamClient)(result.AsyncState)).EndReceiveGameData(result);
}
catch (CommunicationException)
{
// empty
}
catch (TimeoutException)
{
// empty
}
}
LIsting 5. _Timer_Elapsed is used to simulate time in a basketball game.
When _Timer_Elapsed() fires
the SendGameData() method is called which iterates through
the clients wanting to be notified of changes. As each client is identified, their respective BeginReceiveGameData() method is called which ultimately pushes game data down to
the client. Recall that this method was defined in
the client callback interface named IGameStreamClient shown earlier in Listing 2. Notice that BeginReceiveGameData() accepts _ReceiveGameDataCompleted as its second parameter (an AsyncCallback delegate defined in
the service class)
and passes
the client callback as
the third parameter.
The initial version of
the sample application had a standard ReceiveGameData() method in
the client callback interface. However, sometimes
the client callbacks would work properly
and sometimes they wouldn’t which was a little baffling at first glance. After some investigation I realized that I needed to implement an asynchronous pattern for client callbacks to work properly since 3 – 7 second delays are occurring as a result of
the timer. Once I added
the BeginReceiveGameData()
and ReceiveGameDataCompleted() methods everything worked properly since each call was handled in an asynchronous manner.
The final task that had to be completed to get
the server working properly with HTTP Polling Duplex was adding configuration code into web.config. In
the interest of brevity I won’t post all of
the code here since
the sample application includes everything you need. However, Listing 6 shows
the key configuration code to handle creating a custom binding named pollingDuplexBinding
and associate it with
the service’s endpoint.
<bindings>
<customBinding>
<binding name="pollingDuplexBinding">
<binaryMessageEncoding />
<pollingDuplex maxPendingSessions="2147483647" maxPendingMessagesPerSession="2147483647" inactivityTimeout="02:00:00" serverPollTimeout="00:05:00"/>
<httpTransport />
</binding>
</customBinding>
</bindings>
<services>
<service name="GameService.GameStreamService" behaviorConfiguration="GameStreamServiceBehavior">
<endpoint address="" binding="customBinding" bindingConfiguration="pollingDuplexBinding" contract="GameService.IGameStreamService"/>
<endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange" />
</service>
</services>
Listing 6. Configuring an HTTP Polling Duplex binding in web.config
and associating an endpoint with it.
Calling
the Service
and Receiving “Pushed” Data
Calling
the service
and handling data that is pushed from
the server is a simple
and straightforward process in Silverlight. Since
the service is configured with a MEX endpoint
and exposes a WSDL file, you can right-click on
the Silverlight project
and select
the standard Add Service Reference item. After
the web service proxy is created you may notice that
the ServiceReferences.ClientConfig file only contains an empty configuration element instead of
the normal configuration elements created when creating a standard WCF proxy. You can certainly update
the file if you want to read from it at runtime but for
the sample application I fed
the service URI directly to
the service proxy as shown next:
var address = new EndpointAddress("http://localhost.:5661/GameStreamService.svc");
var binding = new PollingDuplexHttpBinding();
_Proxy = new GameStreamServiceClient(binding, address);
_Proxy.ReceiveTeamDataReceived += _Proxy_ReceiveTeamDataReceived;
_Proxy.ReceiveGameDataReceived += _Proxy_ReceiveGameDataReceived;
_Proxy.GetTeamDataAsync();
This code creates
the proxy
and passes
the endpoint address
and binding to use to its constructor. It then wires
the different receive events to callback methods
and calls GetTeamDataAsync(). Calling GetTeamDataAsync() causes
the server to store
the client in
the server-side dictionary collection mentioned earlier so that it can receive data that is pushed. As
the server-side timer fires
and game data is pushed to
the client,
the user interface is updated as shown in Listing 7. Listing 8 shows
the _Proxy_ReceiveGameDataReceived() method responsible for handling
the data
and calling UpdateGameData() to process it.
Listing 7.
The Silverlight interface. Game data is pushed from
the server to
the client using HTTP Polling Duplex.
void _Proxy_ReceiveGameDataReceived(object sender, ReceiveGameDataReceivedEventArgs e)
{
UpdateGameData(e.gameData);
}
private void UpdateGameData(GameData gameData)
{
//Update Score
this.tbTeam1Score.Text = gameData.Team1Score.ToString();
this.tbTeam2Score.Text = gameData.Team2Score.ToString();
//Update ball visibility
if (gameData.Action != ActionsEnum.Foul)
{
if (tbTeam1.Text == gameData.TeamOnOffense)
{
AnimateBall(this.BB1, this.BB2);
}
else //Team 2
{
AnimateBall(this.BB2, this.BB1);
}
}
if (this.lbActions.Items.Count > 9) this.lbActions.Items.Clear();
this.lbActions.Items.Add(gameData.LastAction);
if (this.lbActions.Visibility == Visibility.Collapsed) this.lbActions.Visibility = Visibility.Visible;
}
private void AnimateBall(Image onBall, Image offBall)
{
this.FadeIn.Stop();
Storyboard.SetTarget(this.FadeInAnimation, onBall);
Storyboard.SetTarget(this.FadeOutAnimation, offBall);
this.FadeIn.Begin();
}
Listing 8. As
the server pushes game data,
the client’s _Proxy_ReceiveGameDataReceived() method is called to process
the data.
In a real-life application I’d go with a ViewModel class to handle retrieving
team data, setup data bindings
and handle data that is pushed from
the server. However, for
the sample application I wanted to focus on HTTP Polling Duplex
and keep things as simple as possible.
Summary
Silverlight supports three options when duplex communication is required in an application including TCP bindins, sockets
and HTTP Polling Duplex. In this post you’ve seen how HTTP Polling Duplex interfaces can be created
and implemented on
the server as well as how they can be consumed by a Silverlight client. HTTP Polling Duplex provides a nice way to “push” data from a server while still allowing
the data to flow over port 80 or another port of your choice.
Sample Application Download
