终于解决了这个问题。
在Program.cs中在AddAuthentication中在AddJwtBearer中（因为身份验证是使用JWT），我添加了

config.Events = new JwtBearerEvents
    {
        OnMessageReceived = context =>
        {
            var accessToken = context.Request.Query["access_token"];
            var path = context.HttpContext.Request.Path;
            if (!string.IsNullOrEmpty(accessToken) && (path.StartsWithSegments("/api/chat")))
            {
                context.Token = accessToken;
            }
            return Task.CompletedTask;
        }
    };

字符串
下一个添加builder.Services.AddSingleton<IUserIdProvider, CustomUserIdProvider>();，在Useauthorization之后添加

var idProvider = new CustomUserIdProvider();
GlobalHost.DependencyResolver.Register(typeof(IUserIdProvider), () => idProvider);

型
我还创建了CustomUserIdPrvider

public class CustomUserIdProvider : IUserIdProvider
    {
        public string GetUserId(HubConnectionContext connection)
        {
            var uniqueId = connection.User?.FindFirst(ClaimTypes.NameIdentifier)?.Value;
            return uniqueId;
        }
    }

型
和SendMessage in聊天中心`

public async Task SendMessage(ChatMessage message)
        {
            var httpContext = Context.GetHttpContext();
            var user = httpContext.User.Claims.Where(user => user.Type == ClaimTypes.NameIdentifier).FirstOrDefault()?.Value;
            var token = httpContext.Request.Query["access_token"];
            message.From = user;
            message.Created = DateTime.Now.ToLocalTime();
            await Clients.Users(message.To, user).SendAsync("ReceiveMessage", message);
        }

型
因此，使用Clients.Users(message.To, user)，我可以使用uniqueId（NOT！connectionId！）将消息内容发送给特定用户

当用户（browser或other devices）连接到Hub端点时，生成的connectionId是由signalr本身随机生成的，如果应用程序停止/崩溃，connectionIds将消失，我们不能再使用它。
一个用户只有一个uniqueId，但是他可以打开很多网页，可以和同事一起使用多个移动的设备，所以我们需要自己维护他们之间的关系，更多细节，you can check my answer in this thread。

这是我用于测试的样品。

namespace SignalRMiddleawre.Hubs
{
    /// <summary>
    /// </summary>
    [Authorize]
    public partial class MainHub : Hub
    {
        #region Connection
        /// <summary>
        /// Manage Connected Users
        /// </summary>
        private static ConcurrentDictionary<string?, List<string>>? ConnectedUsers = new ConcurrentDictionary<string?, List<string>>();
        /// <summary>
        /// OnConnect Event
        /// </summary>
        /// <param name="userid"></param>
        /// <returns></returns>
        ///
        public override async Task OnConnectedAsync()
        {
            // Get HttpContext In asp.net core signalr
            //IHttpContextFeature hcf = (IHttpContextFeature)this.Context.Features[typeof(IHttpContextFeature)];
            //HttpContext hc = hcf.HttpContext;
            //string uid = hc.Request.Path.Value.Split(new string[] { "=", "" }, StringSplitOptions.RemoveEmptyEntries)[1].ToString();
            string? userid = Context.User?.Identity?.Name;
            if (userid == null || userid.Equals(string.Empty))
            {
                Trace.TraceInformation("user not loged in, can't connect signalr service");
                return;
            }
            Trace.TraceInformation(userid + "connected");
            // save connection
            List<string>? existUserConnectionIds;
            ConnectedUsers.TryGetValue(userid, out existUserConnectionIds);
            if (existUserConnectionIds == null)
            {
                existUserConnectionIds = new List<string>();
            }
            existUserConnectionIds.Add(Context.ConnectionId);
            ConnectedUsers.TryAdd(userid, existUserConnectionIds);
            await Clients.All.SendAsync("ServerInfo", userid, userid + " connected, connectionId = " + Context.ConnectionId);
            await base.OnConnectedAsync();
        }
        /// <summary>
        /// OnDisconnected event
        /// </summary>
        /// <param name="userid"></param>
        /// <returns></returns>
        public override async Task OnDisconnectedAsync(Exception? exception)
        {
            string? userid = Context.User?.Identity?.Name;
            // save connection
            List<string>? existUserConnectionIds;
            ConnectedUsers.TryGetValue(userid, out existUserConnectionIds);
            existUserConnectionIds.Remove(Context.ConnectionId);
            if (existUserConnectionIds.Count == 0)
            {
                List<string> garbage;
                ConnectedUsers.TryRemove(userid, out garbage);
            }
            await base.OnDisconnectedAsync(exception);
        }
        #endregion
        #region Message
        /// <summary>
        /// Send msg to all user
        /// </summary>
        /// <param name="userid"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public async Task SendMessage(string msgType, string message)
        {
            await Clients.All.SendAsync("ReceiveMessage", msgType, message);
        }
        /// <summary>
        /// Send msg to user by userid
        /// </summary>
        /// <param name="connectionId"></param>
        /// <param name="message">message format : type-message </param>
        /// <returns></returns>
        public async Task SendToSingleUser(string userid, string message)
        {
            List<string>? existUserConnectionIds;
            // find all the connectionids by userid
            ConnectedUsers.TryGetValue(userid, out existUserConnectionIds);
            if (existUserConnectionIds == null)
            {
                existUserConnectionIds = new List<string>();
            }
            existUserConnectionIds.Add(Context.ConnectionId);
            ConnectedUsers.TryAdd(userid, existUserConnectionIds);
            await Clients.Clients(existUserConnectionIds).SendAsync("ReceiveMessage", message);
        }
        #endregion
    }
}

字符串