ASP.Net SignalR: Building a Simple Real-Time Chat Application


SignalR is a pretty new and very exciting feature in ASP.NET. It offers a simple and clean API that allows you to create real-time web applications where the server needs to continuously push data to clients. Common applications are chat, news feeds, notifications and multi-player games.

For this exercise we're going to build a simple chat application in ASP.NET MVC 4 using the power of SignalR. I presume that you already have the basic knowledge on ASP.NET MVC and how stuff works (for example Model, View and Controller) in the MVC development approach because the details of them will not be covered in this exercise.

Step 1: Setting up your ASP.NET MVC Project

To get started, let's proceed and fire up Visual Studio 2012 and create a new project by selecting File > New Project. Under the templates panel, select Visual C# > Web > ASP.NET MVC 4 Web Application. Name your project and click on the OK button.

In the ASP.NET MVC 4 Project Template window, just select ”Basic” since we don't really want to use the built-in forms authentication in this exercise. Then click OK to generate the necessary files for you.

Step 2: Adding SignalR to your Project

SignalR is available in Visual Studio 2010 (.NET 4.0) and later versions of Visual Studio and can be referenced from Nuget.

Under the Visual Studio Tools tab, select Library Package Manager > Manage Nuget Package for the solution. In the search bar type “Microsoft.Aspnet.SignalR” and hit Enter. The result should provide you something as in the following.

Now click the Install button to add the SignalR library and its dependencies into your project. Just follow the procedure specified in the wizard until all the necessary files are successfully installed. After the installation you should be able to see the newly added DLLs in your project references folder. See the following:

Okay, we’re now all set and ready to get our hands dirty. ;)

Step 3: Adding a Controller

To add a new controller, just right-click on the Controller’s folder and then select Add > Controller. Name the controller ChatRoomController and then click Add.

Here’s the code of the Controller class:

  1. namespace MvcDemo.Controllers  
  2. {  
  3.     public class ChatRoomController : Controller  
  4.     {  
  5.         // GET: /ChatRoom/  
  6.         public ActionResult SignalRChat()  
  7.         {  
  8.             return View();  
  9.         }  
  11.     }  
  12. }  
As you can see, there’s nothing really fancy in the Controller. It just contains the SignalRChat action method that returns a View.

Now let’s proceed and create the SignalRChat view.

Step 4: Adding a View

The first thing we need here is to add a ChatRoom folder within the View folder. The reason for this is that the folder name should match the name of the Controller you’ve created in Step 3. That’s one of the MVC conventions. So for example if you have a “HomeController”, then you should have a “Home” folder within your View.

Alright, let’s proceed. In your ChatRoom folder add a new view by right-clicking on it and then select Add > View. Be sure to name the view “SignaRChat” since that’s the name of the view that the controller must expect. Then click Add to generate the View.

Just for the simplicity of this exercise, I just set it up like this:
  1. div id="container">  
  2.     <input type="hidden" id="nickname" />  
  3.     <div id="chatlog"></div>  
  4.     <div id="onlineusers">  
  5.         <b>Online Users</b>  
  6.     </div>  
  7.     <div id="chatarea">  
  8.         <div class="messagelog">  
  9.             <textarea spellcheck="true" id="message" class="messagebox"></textarea>  
  10.         </div>  
  11.         <div class="actionpane">  
  12.             <input type="button" id="btnsend" value="Send" />  
  13.         </div>  
  14.         <div class="actionpane">  
  15.             <select id="users">  
  16.                 <option value="All">All</option>  
  17.             </select>  
  18.         </div>  
  19.     </div>  
  20.     <div id="dialog" title="Enter your name to start a chat.">  
  21.         <input type="text" id="nick" />  
  22.     </div>  
  23. </div>  
Step 5: Adding a Hub

To provide you a quick overview, the Hub is the center piece of the SignalR. Similar to the Controller in ASP.NET MVC, a Hub is responsible for receiving input and generating the output to the client.

Before we create a Hub, let’s add a new folder first within the root of the project. In this exercise I named the folder Hubs. Right-click on that folder and select Add > ASP.NET SignalR Hub class. Name the class “ChatHub” and then click OK to generate the file.

Here’s the code block of the Hub class:
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using Microsoft.AspNet.SignalR;  
  5. using System.Collections.Concurrent;  
  6. using System.Threading.Tasks;  
  8. namespace MvcDemo.Hubs  
  9. {  
  10.     public class ChatHub : Hub  
  11.     {  
  12.         static ConcurrentDictionary<stringstring> dic = new ConcurrentDictionary<stringstring>();  
  13.          public void Send(string name, string message) {  
  14.             Clients.All.broadcastMessage(name, message);  
  15.         }  
  17.         public void SendToSpecific(string name, string message, string to) {  
  18.             Clients.Caller.broadcastMessage(name, message);  
  19.             Clients.Client(dic[to]).broadcastMessage(name, message);  
  20.         }  
  22.         public void Notify(string name, string id) {  
  23.             if (dic.ContainsKey(name)) {  
  24.                 Clients.Caller.differentName();  
  25.             }  
  26.             else{  
  27.                 dic.TryAdd(name, id);  
  28.                 foreach (KeyValuePair<String, String> entry in dic) {  
  29.           ;  
  30.                 }  
  31.                 Clients.Others.enters(name);  
  32.             }  
  33.         }  
  35.         public override Task OnDisconnected(){  
  36.             var name = dic.FirstOrDefault(x => x.Value == Context.ConnectionId.ToString());  
  37.             string s;  
  38.             dic.TryRemove(name.Key, out s);  
  39.             return Clients.All.disconnected(name.Key);  
  40.         }  
  41. }
  42. }
As you may have noticed, the ChatHub class inherits from Microsoft.Aspnet.SignalR.Hubs.Hub. Keep in mind that public methods defined within the Hub class are intended to be called from the client code (JavaScript). They actually result in a response being sent to the client.

At runtime, a JavaScript file is generated dynamically that contains the client-side implementations of the public methods defined in the Hub. These client-side methods will act as a proxy to the server-side methods. You write an implementation of public methods from the Hub in your client-side code so that the Hub can call it and thereby provide the response.

The dictionary is where we store the list of available users that have joined the chat room. I used dictionary so we can easily add and remove items from it using key/value pairs.

The Send() method broadcasts the message to the users by passing the name and the message as the parameters. The SendToSpecific() method on the other hand broadcasts the message to a specific user. The Notify() method tells the client when someone enters the chat room and then adds them to the list of the available users. The OnDisconnected() method handles the removing of users if someone leaves the chat room. This method is asynchronous and will be called whenever the connection from the client is closed (for example closing the browser).

Step 6: Implementing the Client-Side code

Now that we already have our Hub setup we can now proceed with the client-side implementation of our chat application.

Add the following code block below in your View (.cshtml/.aspx):
  1. @section scripts{  
  2.            @Scripts.Render("~/Scripts/jquery-ui-1.9.2.min.js")  
  3.            @Scripts.Render("~/Scripts/jquery.signalR-1.0.1.min.js")  
  4.            @Scripts.Render("/signalr/hubs")  
  6.         <script type="text/javascript">  
  8.             $(function () {  
  9.                 showModalUserNickName();  
  10.             });  
  12.             function showModalUserNickName() {  
  13.                 $("#dialog").dialog({  
  14.                     modal: true,  
  15.                     buttons: {  
  16.                         Ok: function () {  
  17.                             $(this).dialog("close");  
  18.                             startChatHub();  
  19.                         }  
  20.                     }  
  21.                 });  
  22.             }  
  24.             function startChatHub() {  
  25.                 var chat = $.connection.chatHub;  
  27.                 // Get the user name.  
  28.                 $('#nickname').val($('#nick').val());  
  29.                 chat.client.differentName = function (name) {  
  30.                     showModalUserNickName();  
  31.                     return false;  
  32.                     // Prompts for different user name  
  33.                     $('#nickname').val($('#nick').val());  
  34.                     chat.server.notify($('#nickname').val(), $;  
  35.                 };  
  37.        = function (name) {  
  38.                     // Update list of users  
  39.                     if (name == $('#nickname').val())  
  40.                         $('#onlineusers').append('<div class="border" style="color:green">You: ' + name + '</div>');  
  41.                     else {  
  42.                         $('#onlineusers').append('<div class="border">' + name + '</div>');  
  43.                         $("#users").append('<option value="' + name + '">' + name + '</option>');  
  44.                     }  
  45.                 };  
  47.                 chat.client.enters = function (name) {  
  48.                     $('#chatlog').append('<div ><i>' + name + ' joins the conversation</i></div>');  
  49.                     $("#users").append('<option value="' + name + '">' + name + '</option>');  
  50.                     $('#onlineusers').append('<div class="border">' + name + '</div>');  
  51.                 };  
  52.                 // Create a function that the hub can call to broadcast chat messages.  
  53.                 chat.client.broadcastMessage = function (name, message) {  
  54.                     //Interpret smileys  
  55.                     message = message.replace(":)""<img src=\"/images/smile.gif\" class=\"smileys\" />");  
  56.                     message = message.replace(":D""<img src=\"/images/laugh.gif\" class=\"smileys\" />");  
  57.                     message = message.replace(":o""<img src=\"/images/cool.gif\" class=\"smileys\" />");  
  59.                     //display the message  
  60.                     $('#chatlog').append('<div class="border"><span style="color:orange">' + name + '</span>: ' + message + '</div>');  
  61.                 };  
  63.                 chat.client.disconnected = function (name) {  
  64.                     //Calls when someone leaves the page  
  65.                     $('#chatlog').append('<div ><i>' + name + ' leaves the conversation</i></div>');  
  66.                     $('#onlineusers div').remove(":contains('" + name + "')");  
  67.                     $("#users option").remove(":contains('" + name + "')");  
  68.                 }  
  70.                 // Start the connection.  
  71.                 $.connection.hub.start().done(function () {  
  72.                     //Calls the notify method of the server  
  73.                     chat.server.notify($('#nickname').val(), $;  
  75.                     $('#btnsend').click(function () {  
  76.                         if ($("#users").val() == "All") {  
  77.                             // Call the Send method on the hub.   
  78.                             chat.server.send($('#nickname').val(), $('#message').val());  
  79.                         }  
  80.                         else {  
  81.                             chat.server.sendToSpecific($('#nickname').val(), $('#message').val(), $("#users").val());  
  82.                         }  
  83.                         // Clear text box and reset focus for next comment.   
  84.                         $('#message').val('').focus();  
  85.                     });  
  87.                 });  
  88.             }  
  90.           </script>  
  91.    }  
At the very top within the @RenderSection you need to define a reference to jQueryUI and SignalR scripts. Please note that the script reference should be in the following order:
  • jQuery script
  • jQueryUI
  • SignalR script
  • SignalR/Hubs
  • Your custom defined script

You might be wondering why we haven’t included a reference to the jQuery script in the code above. The reason for this is that when you created the Template, the engine automatically added a reference to the jQuery script within your _Layout.cshml before the closing tag of the <body> element and automatically bundled it for you for page performance.

Note: Adding a reference to the jQuery script within your View will cause an error when running your application that uses SignalR. This is because the reference to the jQuery script will be duplicated and the order of the script references will be changed and that can cause the SignalR script to throw an exception.

The showModalUserNickName() function calls the jQueryUI dialog. This function will be called when the browser is loaded to prompt the user to enter their name before joining the chat room. After entering their name the startChatHub() function will be called. This function is where the actual implementation of the chat is defined. The logic is that it first creates a proxy connection to the Hub (ChatHub). Once connected, we then have access to the public methods defined in our Hub class. The next step is to get the name of the user. If the user already exists in the dictionary then they will be prompted to enter another name. Then it will call the Notify() method to add the new user to the dictionary and notify other users that someone has joined the chat room. The next function updates the message logs, available users and the online user’s panel when someone joins the room. Then it calls the broadcastMessage() function to display the messages among users in the message logs. You will also see that I’ve added some code within that function that will interpret smileys. The client.disconnected() function is responsible for updating the UI and the list of users when someone leaves the chat room. And finally call the hub.start() function to start the connection between the client and the hub (server). This method contains the implementation of sending the message to other users or specific users.

Step 7: Wrapping Up

Adding a new CSS file

Create a new CSS file under the Content folder. Name it “chat.css”. Then add the following style definitions to the CSS file:

  1. #container {  
  2.   width400px ;  
  3.   margin-leftauto ;  
  4.   margin-rightauto ;   
  5. }  
  6. #chatlog {  
  7.   width:250px;  
  8.   background-color:aliceblue;  
  9.   floatleft;  
  10. }  
  11. #onlineusers {  
  12.   floatright;  
  13.   width100px;  
  14.   background-color:#D4D4D4;  
  15. }  
  16. #chatarea {  
  17.   clear:both;   
  18.   width:200px;  
  19. }  
  20. #chatarea .messagelog {  
  21.   float:left;   
  22.   height90%;   
  23.   top: 10%;   
  24.   positionrelative;  
  25. }  
  26. #chatarea .messagelog .messagebox {  
  27.   width:400px;   
  28.   height80%;  
  29. }  
  30. #chatarea .actionpane {  
  31.   position:relative;   
  32.   floatleft;  
  33. }  
  34. .smileys {  
  35.   width:14px;  
  36.   height:14px;  
  37. }  
Adding Smiley images

Create a new folder within the root project and name it “Images”. Then add your smileys within that folder.

Referencing CSS files

Then add the following references at the <head> section in your _Layout.cshtml:
  1. <link href="~/Content/chat.css" rel="stylesheet" />  
  2. <link href="~/Content/themes/base/jquery-ui.css" rel="stylesheet" />  
Modifying the default Route

Update the default route under App_Start > RouteConfig so that it will automatically display the SignalRChat page when you run the application. Here’s the updated code:
  1. routes.MapRoute(  
  2.                 name: "Default",  
  3.                 url: "{controller}/{action}/{id}",  
  4.                 defaults: new { controller = "ChatRoom", action = "SignalRChat", id = UrlParameter.Optional }  
  5.             );         
Registering the MapHubs Route

And finally, the most important thing is to make things work. Add the following line below in your Global.asax.cs under the Application_Start event:


Note: Be sure to define the MapHubs() route before the RegisterRoutes() call.

Step 8: Run the Page

Here’s the output below:

That’s it! I hope someone find this article useful!