ASP. Net core signalr series hub tutorial

The content of this article is

                      What is? SignalR center

                      To configure SignalR

                    Create and use SignalR

                    Send a message to the client

                    Strong type center

1． SignalR center

utilize SignalR, You can call methods from the server to the linked client . Define the method called by the client on the server ; Define the method to be called for the service on the client side .SignalR Responsible for making real-time client-to-server and server-to-client communication possible .

 

2. To configure SignalR

         SignalR Middleware requires some services , These services call services.AddSignalR In progress Startup Of ConfigureServices Perform registration configuration

public void ConfigureServices(IServiceCollection services)
{
	services.Configure<CookiePolicyOptions>(options =>
	{
		// This lambda determines whether user consent for non-essential cookies is needed for a given request.
		options.CheckConsentNeeded = context => true;
		options.MinimumSameSitePolicy = SameSiteMode.None;
	});


	services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
	services.AddCors(options => options.AddPolicy("CorsPolicy",
   builder =>
   {
	   builder.AllowAnyMethod().AllowAnyHeader()
			  .WithOrigins("http://localhost:51617")
			  .AllowCredentials();
   }));
	services.AddSignalR();// register SignalR service 
}

take SignalR Features added to ASP.NET Core Application time , Please be there.  Startup.Configure  Call in method  app.UseSignalR  To set up SignalR route .

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
	if (env.IsDevelopment())
	{
		app.UseDeveloperExceptionPage();
	}
	else
	{
		app.UseExceptionHandler("/Error");
	}

	app.UseStaticFiles();
	app.UseCookiePolicy();
	app.UseSignalR(routes =>
	{
		routes.MapHub<StronglyTypedChatHub>("/chatHub");
	});
	app.UseCors("CorsPolicy");
	app.UseMvc();
}

3. Create and use SignalR

public class ChatHub : Hub
{
    public Task SendMessage(string user, string message)
    {
        return Clients.All.SendAsync("ReceiveMessage", user, message);
    }
}

You can specify the return type and parameters （ Including complex types and arrays ）, Like in any C# In the same way . SignalR  Handle serialization and deserialization of complex objects and arrays in parameters and return values .

notes ：

       The center is temporary ：

              Do not store state in hub In the properties of class .  Each central method call is executed on a new central instance .

              When calling an asynchronous method that relies on the hub to remain active , Please use  await.  for example , If there is no  await  Called in the case of , Then the method （ Such as  Clients.All.SendAsync(...)） May fail .

for example ： stay ChatHub Add a list to _ ConnectionId, Use and obtain by SignalR The only connection assigned ID.  Each connection has a connection ID.

public class ChatHub : Hub
{

        public static List<string> _connectionId = new List<string>();

        public  Task SendMessage(string user, string message)
        {
           
            _connectionId.Add(Context.ConnectionId);
           return  Clients.All.SendAsync("ReceiveMessage", user, message, string.Join("#",_connectionId));


        }
}

From the picture we find _connectionId There is always only one number stored in the client that is currently clicked ConnectionId This is because   Each central method call is executed on a new central instance

 

If you create a static class ：

public static class staticClass
{
        public static List<string> connectionId = new List<string>();

}

 

public class ChatHub : Hub
{

   

	public  Task SendMessage(string user, string message)
	{
		staticClass.connectionId.Add(Context.ConnectionId);

		if (staticClass.connectionId.Count >1)
		{
			/// Randomly generated index 
			Random r1 = new Random();
			int index = r1.Next(0, staticClass.connectionId.Count);

			return Clients.Client(staticClass.connectionId[index]).SendAsync("ReceiveMessage", user, message, Context.ConnectionId, Context.UserIdentifier);


		}
		else
		{
			return Clients.All.SendAsync("ReceiveMessage", user, message, Context.ConnectionId, Context.UserIdentifier);

		}
	   

	}
}

Rerun program , Get the results ：

4. Strong type center

 

advantage ： Strongly typed Hub You can avoid magic function names , It's easier to maintain and find problems than weak types , Go straight to the code

shortcoming ： More code writing

Specific steps ：

1. Use  Hub<T> Strong typing  Hub Instead of SendAsync  Method  . 

The method called by the server-side link client will be extracted to  IChatClient Interface , It's actually going to be ChatHub Using strings to call client methods , Abstract as an interface .

public interface IChatClient
{
    Task ReceiveMessage(string user, string message);
    
}

2. Implementation interface Refactor the previous  ChatHub  Example

 public class StronglyTypedChatHub: Hub<IChatClient>
    {
        public async Task SendMessage(string user, string message)
        {

            staticClass.connectionId.Add(Context.ConnectionId);

            if (staticClass.connectionId.Count > 1)
            {
                /// Randomly generated index 
                Random r1 = new Random();
                int index = r1.Next(0, staticClass.connectionId.Count);

                await Clients.Client(staticClass.connectionId[index]).ReceiveMessage( user, message, Context.ConnectionId);


            }
            else
            {
                await Clients.All.ReceiveMessage( user, message, Context.ConnectionId);

            }


           
        }
    }

3. take Configur The routing

The original

app.UseSignalR(route =>
{
	route.MapHub<StronglyTypedChatHub>("/chathub");
});

Turn into ：

app.UseSignalR(route =>
{
    route.MapHub<StronglyTypedChatHub>("/chathub");
});

This is my wechat public number , I hope to grow up with you , I will keep it updated once a day or so .