SignalR in C#

Introduction:

Modern applications must now include real-time communication. It all comes down to giving users timely updates. In the past, real-time communication was a challenging task, but thanks to SignalR, it has become a lot easier. For .NET applications, the SignalR library offers real-time communication features. In this post, we'll examine SignalR, its features, and how to integrate it into C# applications.

What is SignalR?

For .NET applications, the SignalR library offers real-time communication features.It allows you to add real-time functionality to your applications, which means your users can get updates as soon as they happen without having to refresh the page.

SignalR, which is based on the WebSocket protocol, enables real-time communication between the server and the client. But in addition to these protocols, SignalR also supports Server-Sent Events (SSE) and long polling. This means that if WebSocket is not available, SignalR will automatically switch to one of these other protocols to ensure that the communication is still in real-time.

How does SignalR Work?

By creating a lasting link between the client and the server, SignalR works. Through this connection, data is transmitted between the client and the server. Every time a client connects to a server, a request to connect to the server is sent. The connection ID provided by the server as a response is used to identify the connection.

Once the connection has been established successfully, both the client and the server are able to send and receive messages. The two may now communicate in real time because of this. If the connection is lost, SignalR will automatically try to reconnect. This ensures that the connection is always available, even if the client or the server goes offline for a short period.

SignalR also provides a hub-based API, which makes it easier to work with. A hub is a high-level API that enables you to deliver messages from the server to clients and the other way around. It makes the connection easier to work with by abstracting away the connection's low-level specifics.

Using SignalR in C#:

Now that we understand what SignalR is and how it works let's look at how we can use it in our C# applications.

The first step is to install the SignalR package. You can do this using NuGet. Open the NuGet Package Manager Console and type the below command:

C# Code:

Once the package is installed, we can start using SignalR in our application. The first thing we need to do is to create a hub. A hub is a class that inherits properties from the Hub class. It's responsible for handling incoming messages from the clients and sending messages to the clients.

Here's an example of a simple hub:

C# Code:

using Microsoft.AspNet.SignalR;

public class MyHub : Hub
{
    public void Send(string message)
    {
        Clients.All.broadcastMessage(message);
    }
}

In this example, we've created a hub called MyHub. It has a method named Send, and one of its parameters is a string message. By invoking the broadcastMessage method on the Clients object, the Send method broadcasts the message to all connected clients.

The next step is to set up SignalR in our application.This is done in the Startup class. Here's an example:

C# Code:

using Microsoft.AspNet.SignalR;
using Owin;

public class Startup
{
    public void Configuration(IAppBuilder app)
    {
        app.MapSignalR();
    }
}

In this example, we've created a Configuration method that takes an IAppBuilder parameter. We've called the MapSignalR method on the app object, which sets up SignalR in our application.

Now that we've created a hub and configured SignalR, we can use it in our application. Let's create a simple example demonstrating using SignalR to send the information between the client and the server.

First, we'll create a simple HTML page with a text box and a button in the UI. When the user types a message in the text box and clicks the button, the message will be sent to the server.

HTML Code:

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <title>SignalR Example</title>
    <script src="https://code.jquery.com/jquery-1.10.2.min.js"></script>
    <script src="/signalr/hubs"></script>
    <script>
        $(function () {
            var chat = $.connection.myHub;

            chat.client.broadcastMessage = function (message) {
                $('#messages').append('<li>' + message + '</li>');
            };

            $.connection.hub.start().done(function () {
                $('#sendButton').click(function () {
                    chat.server.send($('#messageInput').val());
                    $('#messageInput').val('').focus();
                });
            });
        });
    </script>
</head>
<body>
    <ul id="messages"></ul>
    <input type="text" id="messageInput" />
    <button id="sendButton">Send</button>
</body>
</html>

In this example, we've included the SignalR JavaScript library and defined a client-side hub called myHub. We've also defined a method called broadcastMessage that will be called when a message is received from the server. This method simply appends the message to an unordered list element.

We've also defined a button click event handler that sends the message to the server using the send method defined in our hub.

Now, let's update our hub to handle incoming messages from the client:

C# Code:

using Microsoft.AspNet.SignalR;
public class MyHub : Hub
{
    public void Send(string message)
    {
        Clients.All.broadcastMessage(message);
    }
}

In this example, we've updated the Send method to call the broadcastMessage method on the Clients object, passing in the message as a parameter. All connected clients will receive the message when you do this.

Finally, we'll update our Startup class to map our hub:

C# Code:

using Microsoft.AspNet.SignalR;
using Owin;
public class Startup
{
    public void Configuration(IAppBuilder app)
    {
        app.MapSignalR();
    }
}

That's it! Now, when we run our application and type a message into the text box and click the Sendbutton, the data or information will be sent to the server, which will then broadcast the message to all connected clients.

Conclusion:

SignalR is a powerful library that provides real-time communication capabilities for .NET applications. It allows you to add real-time functionality to your applications, which means that your users can get updates as soon as they happen without having to refresh the page. We looked at what SignalR is, how it functions, and how to use it in C# applications in this article. We've also provided a simple example demonstrating using SignalR to send messages between the client and the server. With SignalR, you can easily add real-time communication capabilities to your applications, making them more interactive and engaging for your users.

Next Topicthrow vs throw ex

← prev next →