In modern applications, real-time communication has become increasingly important. Whether it is chat applications, online games or real-time data monitoring, real-time communication can significantly improve the user experience. In .NET Core, SignalR is a powerful tool for real-time communication. This article will explain how to implement real-time communication using SignalR in .NET Core and provide a simple example.
1. What is SignalR?
SignalR is a Core library for real-time communication between clients and servers. It simplifies the use of WebSocket and provides multiple transmission methods, such as WebSocket, Server-Sent Events (SSE) and long polling. SignalR allows servers to push messages to clients, suitable for applications that require instant updates.
2. Install SignalR
To use SignalR in a .NET Core project, you first need to install the SignalR package. This process can be done through the NuGet package manager. Open your project and execute the following command to install SignalR:
dotnet add package
3. Configure SignalR
3.1 Configuration Service
In the file, you need to configure the SignalR service. Add SignalR service in the ConfigureServices method:
public void ConfigureServices(IServiceCollection services)
{
();
// Add SignalR service to use SignalR functionality in your application ();
}
3.2 Configuring Middleware
In the Configure method, configure SignalR's middleware. You need to specify the route for SignalR Hub:
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (())
{
();
}
else
{
("/Home/Error");
();
}
();
();
();
();
(endpoints =>
{
();
// Map SignalR Hub to the specified route <ChatHub>("/chathub");
});
}
4. Create SignalR Hub
SignalR Hub is a central point where all clients are connected to this Hub for communication. Create a new class ChatHub inherits from Hub:
using ;
using ;
public class ChatHub : Hub
{
// Define a method to receive messages sent by the client public async Task SendMessage(string user, string message)
{
// Send messages to all connected clients await ("ReceiveMessage", user, message);
}
}
In this example, the SendMessage method sends the message to all connected clients and calls the ReceiveMessage method, which processes the message on the client.
5. Create a client
5.1 Front-end page
In the front-end page, you need to add the SignalR client library. The SignalR client can be loaded via CDN:
<script src="/ajax/libs/microsoft-signalr/6.0.0/"></script>
5.2 Client Script
Create a JavaScript file or write a script directly in an HTML file to connect to SignalR Hub and process messages:
<!DOCTYPE html>
<html>
<head>
<title>SignalR Chat</title>
</head>
<body>
<h1>SignalR Chat</h1>
<div ></div>
<input type="text" placeholder="Enter message" />
<button >Send</button>
<script src="/ajax/libs/microsoft-signalr/6.0.0/"></script>
<script>
// Create a SignalR connection instance and specify the URL of the Hub const connection = new ()
.withUrl("/chathub")
.build();
// Define the processing method of receiving messages ("ReceiveMessage", (user, message) => {
// Create a new div element to display the message const msg = ("div");
= `${user}: ${message}`;
// Add message to the message list of the page ("messagesList").appendChild(msg);
});
// Bind the click event of send button ("sendButton").addEventListener("click", () => {
const user = "User"; // The sender's username const message = ("messageInput").value; // The input message content // Call the SendMessage method of SignalR Hub to send the message to the server ("SendMessage", user, message).catch(err => (()));
});
// Start SignalR connection ().catch(err => (()));
</script>
</body>
</html>
6. Running example
Now you can run your application and open the front-end page. Open the page in a different browser or tab page and you will be able to see real-time message updates. Try sending a message on one client and you will see that other clients receive the message instantly.
Summarize
SignalR is a powerful tool for real-time communication. Using SignalR in .NET Core can significantly simplify real-time communication implementation. This article introduces the basic configuration of SignalR, the creation of Hubs, and how to implement real-time message processing on the client side.
This is the article about the example code of .NET Core using SignalR to implement real-time communication. For more related .NET Core SignalR real-time communication content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!