SignalR for Real-Time Web Applications: Revolutionizing User Experience

In the ever-evolving landscape of web development, user expectations for real-time interactions and dynamic content have skyrocketed. Traditional request-response models fall short when it comes to delivering the instantaneous updates users crave. This is where SignalR, a powerful library for ASP.NET developers, steps in to revolutionize the way we approach real-time web applications. In this blog we will see a clear view of SignalR for Real time web application which is revolutionizing the user experience.

Consider a scenario where multiple users collaborate on a shared document. With a traditional approach, users would need to refresh the page to see updates from others, resulting in a less-than-optimal user experience. Real-time functionality aims to eliminate this lag, providing a seamless and interactive environment for users.

It is a library for ASP.NET developers that simplifies the process of adding real-time web functionality to applications. It abstracts the complexities of handling low-level protocols and allows developers to focus on building engaging and responsive user experiences.

1. Bi-Directional Communication: It enables real-time communication between the client and server, allowing both sides to push content to the other without the need for continuous polling.
   Code Sample

// Server-Side: Send a message from server to client
public async Task SendMessageToClient(string message)
{
    await Clients.All.SendAsync("ReceiveMessage", message);
}

// Client-Side: Receive a message from server
connection.on("ReceiveMessage", function (message) {
    console.log("Received message from server: " + message);
});

2.Multiple Transport Mechanisms: It supports various transport mechanisms, including WebSockets, Server-Sent Events (SSE), and long polling. It dynamically selects the most suitable transport based on the client’s capabilities and network conditions.
Code Sample

// Configuring SignalR with supported transports
public void ConfigureServices(IServiceCollection services)
{
    services.AddSignalR(options =>
    {
        options.Transports = HttpTransportType.WebSockets | HttpTransportType.ServerSentEvents | HttpTransportType.LongPolling;
    });
}

3.Hub-Based Architecture: It uses a hub-based architecture, where the server-side logic resides in hubs. Hubs are persistent connections that handle incoming events from clients and broadcast messages to all connected clients or specific groups.
Code Sample

// Defining a hub method to be called by clients
public async Task SendMessage(string user, string message)
{
    await Clients.All.SendAsync("ReceiveMessage", user, message);
}

4. Automatic Reconnection:It automatically handles connection reestablishment in case of network disruptions or server restarts, ensuring a seamless user experience.
Code Sample

// Configuring automatic reconnection
connection.Closed += async (error) =>
{
    await Task.Delay(new Random().Next(0, 5) * 1000);
    await connection.StartAsync();
};

5.Scalability: It supports scaling out across multiple servers using either a backplane or distributed cache. This allows applications to handle a large number of concurrent connections and maintain real-time responsiveness.
Code Sample

// Configuring SignalR to use Redis as a backplane for scaling out
services.AddSignalR().AddStackExchangeRedis("<connection-string>");

6.Cross-Platform Support: It is not limited to ASP.NET applications. It has client libraries for various platforms, including JavaScript, .NET, Java, and more, enabling cross-platform real-time communication.
Code Sample(javaScript client)

<!-- Include SignalR JavaScript client library -->
<script src="https://cdnjs.cloudflare.com/ajax/libs/microsoft-signalr/5.0.10/signalr.min.js"></script>

<script>
    const connection = new signalR.HubConnectionBuilder()
        .withUrl("/chatHub")
        .configureLogging(signalR.LogLevel.Information)
        .build();

    // Other client-side code...
</script>

Now, let’s demonstrate the power of how to build a simple real-time chat application.

// ChatHub.cs
using Microsoft.AspNetCore.SignalR;
using System.Threading.Tasks;

namespace RealTimeChat.Hubs
{
    public class ChatHub : Hub
    {
        public async Task SendMessage(string user, string message)
        {
            await Clients.All.SendAsync("ReceiveMessage", user, message);
        }
    }
}

Client-Side (JavaScript)

<!-- index.html -->
<!DOCTYPE html>
<html>
<head>
    <title>Real-Time Chat</title>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.0/jquery.min.js"></script>
    <script src="/chatHub"></script>
</head>
<body>
    <input type="text" id="userInput" placeholder="Enter your name">
    <input type="text" id="messageInput" placeholder="Enter your message">
    <button id="sendButton">Send</button>
    <ul id="messagesList"></ul>

    <script>
        const connection = new signalR.HubConnectionBuilder()
            .withUrl("/chatHub")
            .configureLogging(signalR.LogLevel.Information)
            .build();

        connection.start().then(function () {
            console.log("Connection established.");
        }).catch(function (err) {
            return console.error(err.toString());
        });

        connection.on("ReceiveMessage", function (user, message) {
            const encodedUser = $('<div />').text(user).html();
            const encodedMessage = $('<div />').text(message).html();
            $('#messagesList').append(`<li><strong>${encodedUser}</strong>: ${encodedMessage}</li>`);
        });

        $('#sendButton').click(function () {
            const user = $('#userInput').val();
            const message = $('#messageInput').val();
            connection.invoke("SendMessage", user, message).catch(function (err) {
                return console.error(err.toString());
            });
            $('#messageInput').val('').focus();
        });
    </script>
</body>
</html>

It empowers developers to create immersive real-time web applications with ease. By leveraging its bidirectional communication, hub-based architecture, and automatic reconnection features, developers can deliver seamless user experiences that keep users engaged and informed in real time.

• https://www.thetechplatform.com/post/what-is-signalr-and-how-can-it-be-used-to-build-real-time-web-applications-in-asp-net
• https://www.linkedin.com/pulse/building-real-time-web-applications-signalr-adarsh-srivastava

Check out the Athen blogs for more updates on .Net an SharePoint blogs.

• https://athen-tech-909670.hostingersite.com/blogs/

Stay tuned for more updates as we craft a collaborative future.