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

        public void ConfigureServices(IServiceCollection services)
        {
            ......
    
            //注册 SignalR 服务
            services.AddSignalR();
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            ......

            //设置 SignalR 中心路由
            app.UseSignalR(routes => { routes.MapHub<ChatHub>("/chatHub"); });

            app.UseMvc();
        }

"use strict";//不太明白这句话是什么意思...

//创建一个连接到我们创建的 ChatHub 的 connection.
var connection = new signalR.HubConnectionBuilder().withUrl("/chatHub").build();

//定义客户端的方法,方法名: ReceiveMessage ,两个入参.
//注意,这个方法就是服务器要调用的方法,服务器和客户端的名字一定要一样.
connection.on("ReceiveMessage", function (user, message) {
    var msg = message.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
    var encodedMsg = user + " says " + msg;
    var li = document.createElement("li");
    li.textContent = encodedMsg;
    document.getElementById("messagesList").appendChild(li);
});

//开启连接.
connection.start().catch(function (err) {
    return console.error(err.toString());
});

document.getElementById("sendButton").addEventListener("click", function (event) {
    var user = document.getElementById("userInput").value;
    var message = document.getElementById("messageInput").value;

    //调用服务器的 SendMessage 方法,并传入两个入参.这和委托的调用太像了.
    connection.invoke("SendMessage", user, message).catch(function (err) {
        return console.error(err.toString());
    });
    event.preventDefault();
});

    //建议使用下面的强类型方式
    //方法二
    public interface IChatClient
    {
        //就算是这种强类型方式,客户端定义的方法名也必须和这个方法名一样,包括签名.
        Task ReceiveMessage(string user, string message);
    }

    public class StronglyTypedChatHub : Hub<IChatClient>
    {
        //[HubMethodName("hello")] 可以改名,如果改了名,前端也要跟着改,别忘了.
        public async Task SendMessage(string user, string message)
        {
            //调用客户端定义的 ReceiveMessage 方法.
            //throw new HubException("哈哈,出错了!");//可以向客户端发送异常.只会向当前调用的客户端发送,并且只发送 message ,不会发送堆栈信息.

　　　　　　  //Clients.Caller 当前客户端
　　　　　　　//Clients.Others 当前客户端的其他客户端
            await Clients.All.ReceiveMessage($"{GetHashCode()}" + user, message);//传递 hashCode 是为了证明,每次调用都是不同的实例.所以官方说不要在"中心"里面存状态.
        }

        //该方法可以在客户端连接上后,执行操作
        public override async Task OnConnectedAsync()
        {
            await Groups.AddToGroupAsync(Context.ConnectionId, "SignalR Users");
            await base.OnConnectedAsync();
        }

        //同理,当客户端断开连接时执行的操作
        public override async Task OnDisconnectedAsync(Exception exception)
        {
            await Groups.RemoveFromGroupAsync(Context.ConnectionId, "SignalR Users");
            await base.OnDisconnectedAsync(exception);
        }
    }

    [Route("api/[controller]")]
    [ApiController]
    public class TestController
    {
        private IHubContext<StronglyTypedChatHub, IChatClient> _context;

        public TestController(IHubContext<StronglyTypedChatHub, IChatClient> context)
        {
            _context = context;
        }

        public void Get()
        {
            _context.Clients.All.ReceiveMessage("admin", "在座的各位都是垃圾!");
        }
    }

    [Route("api/[controller]")]
    [ApiController]
    public class TestController
    {

        //强类型中心
        //private IHubContext<StronglyTypedChatHub, IChatClient> _context;

        //public TestController(IHubContext<StronglyTypedChatHub, IChatClient> context)
        //{
        //    _context = context;
        //}

        //普通中心
        private IHubContext<ChatHub> _context;

        public TestController(IHubContext<ChatHub> context)
        {
            _context = context;
        }


        public void Get()
        {
           //这种调用客户端方法的方式,好别扭
            _context.Clients.All.SendAsync("ReceiveMessage", "admin", "在座的各位都是垃圾!!!");
        }
    }