SignalR – Real-time application development

Introduction

Real-time applications for the web are none other than usual client-server applications with one distinct feature, that being they accomplish functionality with very little (near real-time) or zero latency (real-time). There have been a number of traditional approaches in the past that were employed in order to achieve such functionality suing a variety of methodologies. One such mechanism is Comet, which is an umbrella term that provides a variety of models/solutions in order to achieve real-time application development over HTTP (Hyper Text Transfer Protocol) (e.g. Streaming, Hidden iframe, Ajax with long polling, etc.).

 

There are a number of third-party frameworks available today, until recent Microsoft had no streamlined mechanism that enabled a straightforward approach in the implementation of real-time applications. Although frameworks such as WCF (Windows Communication Foundation) did support a similar functionality using a couple of bindings, wsDualHttpBinding for web services and httpPollingDuplex Silverlight based applications, they had limited features in terms of scale and functionality. Apart from that, you were pretty much on your own if you needed to develop an application that required real-time functionally using ASP.NET.

 

Limitations of a typical Request-Response oriented Application

HTTP functions on the request-response principle, where the client makes a request and the server responds. This is the case with any application web application that runs on HTTP. This is illustrated below,

 

 

 

This mechanism does not provide us the means to achieve real-time data transfer, mainly due to the reason that the server is not able to provide any updated unless the client specifically requests for it. One typical way that developers utilized to overcome this limitation is by performing periodic polling, where the client keeps on requesting until the server has an update to provide the client with as illustrated below,

 

 

Although the above mechanism tries to eliminate the afore mentioned drawback of implementing real-time web application using HTTP, it still could not be considered as an appropriate solution.

 

ASP.NET SignalR

ASP.NET SignalR is a framework maintained and developed by Microsoft that provides just the right functionality that helps you achieve seamless development of real-time applications using ASP.NET. SignalR incorporates a variety of mechanisms/modes that help handle failover during failure to negotiate on a specific transport mechanism to perform real-time message exchange. The framework also supports a straight forward development approach by exposing an API over the core functionality enabling you to develop applications in a breeze. SignalR is written so that it is scalable as you application grows and perform well even when the application requires handling many concurrent users at a given time.

 

SignalR provided four mechanisms in order to overcome the limitations associated with the traditional HTTP request-response principal during development of real-time web applications. Two of these mechanisms use new features introduced with HTML5 version, which are WS (Web-Sockets) and SSE (Server-Sent-Events). As of writing these two features are currently as draft within the HTML5 specification, although most modern browsers do support these features and will continue to evolve in future. The other two mechanisms SignalR supports are Forever Frame and Long Polling.

 

Upon SignalR framework being integrated to an application the framework will choose one of the best mechanisms based on the browser/server capabilities and agree on the transport negotiate accordingly. From a developer standpoint all that you will do is code against the high-level API that will encapsulate the negotiation of which mechanism to use. The key point to understand is that the code you write using framework is the “SAME” regardless of which transport mode you use. Listed below is more information on each of the transport modes supported by SignalR.

 

WS (Web-Sockets)

WS is a new protocol (i.e. ws:// or wss://) introduced with HTML5 and is the most appropriate technology for building real-time applications. That is due to the fact that WS enables creation of a Full-Duplex Bidirectional channel over HTTP enabling the client or the server to send messages independently.

 

 

As illustrated above upon the client creating a WS connection between the servers both server and client will utilize a full-duplex channel over HTTP enabling the server to send event data and the client to send data via the same connection. WS is the preferred over the other options below, due to the fact that it is very preformant and less resource intensive in its essence.

 

This feature is a new addition to HTML and hence requires alterations on an architectural level. Hence it requires that WS be supported in the web server, client browser and all intermediate associates (e.g. proxies, firewalls and server, client, public network infrastructures).In order to enable WS with ASP.NET the prerequisites are that the application must be running on ASP.NET 4.5 or MVC 4, IIS8 (or IIS8 express within Windows Server 2012) with a WS compatible browser.

 

SSE (Server-Sent-Events)

SSE is again an HTML5 feature which enables event based streaming over HTTP. On the contrary to WS, SSE is a mere addition to the JS API (i.e. EventSource object), hence requiring no major change architecturally. This feature is supported by most browsers available today.

 

 

SSE is not a duplex connection like WS. As illustrated above it is a one way connection so that the server can send updates to the client. SSE is achieved by the client creating an EventSource object via JS and the server flushing event data as and when there is an update triggered without terminating the stream. Should there be any client update to be sent, this will be sent via a separate request to the server and not using the event source created between the server and the client which can be considered somewhat of a limitation.

 

Forever Frame

This mechanism is a way of using existing HTML functionality to utilize real-time functionality. It is achieved by creating a hidden iframe within the client to connect to the server and use scriptlets sent by the server to trigger update within the client page. The functionality is similar to using SSE, although in this case this technique uses available HTML iframe element in order to achieve the similar functionality.

 

 

As illustrated the scirptlets sent by the server are appended to the iframe body and a mechanism of reading the script and executing it will be handled by the client accordingly.

 

Long Polling

This is technique that works across all browsers. Long polling is a last resort used by SignalR when determining a transport mechanism to use. Long polling functions in a manner that it sends Ajax based requests to the server where the server holds on to the request for a definite period of time and terminates the request with an empty response. However in cases where there is an server event that needs to be sent across to the client the server immediately sends the response for the client to use, and the client initiates another request to server that will again listen to any server update available.

 

 

Long Polling is considered more resource intensive compared to the other methods supported by SignalR. This is mainly due to the continuous connection initiated and terminated between he server and the client.

 

SignalR transport precedence

The above four mechanisms are supported by the SignalR framework and it will utilize the most effective based on the capabilities of the client/server and fallback to another mechanism if failed. The order of fallback within the framework is as follows,

1. Web-Sockets: SignalR will try to determine if the server/client or intermediate channels support Web-Sockets and use it.

2. Server-Sent-Events: Falls back from Web-Sockets if the browser supports Server-Sent-Events.

3. Forever Frame: Falls back from Server-Sent-Events if the browser supports this mechanism.

4. Long-Polling: Is the fail safe mechanism utilized by SignalR in cases where none of the above technologies are supported.

 

Summary

SignalR is a framework maintained by Microsoft and provides features and means of how real-time messaging can be achieve between the client and the server over HTTP. SignalR supports four main mechanisms of transport (i.e. Web-Sockets, Server-Sent-Events, Forever Frame and Long Polling). SignalR also provides and intuitive API and exposes multiple programing models that aids ease of development which will be looked at in a future post and demos.

Continue Reading

Service Reference Generation using svcutil.exe

Duplicate objects being generated.

When working with generating a single service reference code file for multiple services I encountered an issue where one of the services being used exposes a System.Data.Dataset as the return datatype. The issue i had was that the generated objects seemed to get duplicated and generated in two different ways as shown and below,

 

The code below is gerated via the DataContracSerializer as you can clearly say based on some of the attributes used in the class and properties (i.e. line 3 and 23).

[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Runtime.Serialization", "4.0.0.0")]
[System.Runtime.Serialization.DataContractAttribute(Name="Person", Namespace="http://tempuri.org/")]
public partial class Person : object, System.Runtime.Serialization.IExtensibleDataObject
{
 
 private System.Runtime.Serialization.ExtensionDataObject extensionDataField;
 
 private string NameField;
 
 public System.Runtime.Serialization.ExtensionDataObject ExtensionData
 {
  get
  {
   return this.extensionDataField;
  }
  set
  {
   this.extensionDataField = value;
  }
 }
 
 [System.Runtime.Serialization.DataMemberAttribute(EmitDefaultValue=false)]
 public string Name
 {
  get
  {
   return this.NameField;
  }
  set
  {
   this.NameField = value;
  }
 }
}

 

The code below is gerated via the XMLSerializer as you can clearly say based on some of the attributes used in the class and properties (i.e. line 5 and 12).

[System.CodeDom.Compiler.GeneratedCodeAttribute("svcutil", "4.0.30319.1")]
[System.SerializableAttribute()]
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://tempuri.org/")]
public partial class Person
{
    
    private string nameField;
    
    /// 
    [System.Xml.Serialization.XmlElementAttribute(Order=0)]
    public string Name
    {
        get
        {
            return this.nameField;
        }
        set
        {
            this.nameField = value;
        }
    }
}

 

The reason for this duplication is that one of the services I was interfacing with had the type System.Data.Dataset being returned from a service method. Hence the svcutil tries to use the DataContractSerilizer schema importer tries to infer the System.Data.Dataset and fails to use the XML schema associated with it and resolves to XMLSerializer to serialize the objects for this service.

Overcoming the problem

It is clear that the DataContractSerializer cannot infer XML schema defined types. Hence in order to overcome this problem the alternative is to force svcutil to use the XMLSerializer for all the services being referenced like so,

 

svcutil /r:C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\System.Data.dll /serializer:XmlSerializer /out:MyService.cs /namespace:http://tempuri.org/,MyService.MyServiceReference https://www.mydomain.com/service1.asmx https://www.mydomain.com/service2.asmx

 

With the above command you should be able to generate the service code that will solve the duplicate objects being generated. However there is another minor issue, which is that the proxy objects generated do not fall/associate into the above provided namespace MyService.MyServiceReference instead is placed in the global namespace and will cause issues if you have similar names defined elsewhere in your solution.

 

To fix this is just a minor hack, if you analyze the generated MyService.cs file, you will notice that the namespace only wraps the service functions, where all you need to do is move the namespace definition to the beginning of the file so that it covers the proxy object definitions. This should give you a complete service reference when referring to multiple services that are required to be XMLSerialized due to the afore mentioned reason.

Continue Reading