c# - MVC 核心、Web 套接字和线程

Question

我正在开发一种解决方案，当服务器(MVC Core 网络应用程序)上发生某些事件时，使用网络套接字协议(protocol)通知客户端(网络浏览器)。我使用 Microsoft.AspNetCore.WebSockets nuget。

这是我的客户端代码:

  $(function () {
    var socket = new WebSocket("ws://localhost:61019/data/openSocket");

    socket.onopen = function () {
      $(".socket-status").css("color", "green");
    }

    socket.onmessage = function (message) {
      $("body").append(document.createTextNode(message.data));
    }

    socket.onclose = function () {
      $(".socket-status").css("color", "red");
    }
  });

加载此 View 时，套接字请求会立即发送到 MVC 核心应用程序。这是 Controller 操作:

[Route("data")]
public class DataController : Controller
{
    [Route("openSocket")]
    [HttpGet]
    public ActionResult OpenSocket()
    {
        if (HttpContext.WebSockets.IsWebSocketRequest)
        {
            WebSocket socket = HttpContext.WebSockets.AcceptWebSocketAsync().Result;

            if (socket != null && socket.State == WebSocketState.Open)
            {
                while (!HttpContext.RequestAborted.IsCancellationRequested)
                {
                    var response = string.Format("Hello! Time {0}", System.DateTime.Now.ToString());
                    var bytes = System.Text.Encoding.UTF8.GetBytes(response);

                    Task.Run(() => socket.SendAsync(new System.ArraySegment<byte>(bytes),
                        WebSocketMessageType.Text, true, CancellationToken.None));
                    Thread.Sleep(3000);
                }
            }
        }
        return new StatusCodeResult(101);
    }
}

此代码运行良好。这里的 WebSocket 专门用于发送，不接收任何东西。然而，问题是 while 循环一直保持 DataController 线程直到检测到取消请求。

这里的Web socket是绑定(bind)到HttpContext对象上的。一旦 Web 请求的 HttpContext 被销毁，套接字连接就会立即关闭。

问题 1:有什么方法可以在 Controller 线程之外保留套接字？我尝试将它放入一个单例中，该单例位于在主应用程序线程上运行的 MVC Core Startup 类中。有什么方法可以让套接字保持打开状态或从主应用程序线程中再次建立连接，而不是用 while 循环保持 Controller 线程？即使保留套接字连接的 Controller 线程保持打开状态被认为是可以的，我也想不出有什么好的代码可以放在 OpenSocket 的 while 循环中。您如何看待 Controller 中的手动重置事件并等待它在 OpenSocket 操作的 while 循环内设置？

问题2:如果在MVC中不能分离HttpContext和WebSocket对象，还有什么替代技术或开发模式可以实现socket连接重用？如果有人认为 SignalR 或类似的库有一些代码允许套接字独立于 HttpContext，请分享一些示例代码。如果有人认为对于这种特定情况有更好的 MVC 替代方案，请提供示例，如果 MVC 没有处理独立套接字通信的能力，我不介意切换到纯 ASP.NET 或 Web API。

问题 3:要求是保持套接字连接有效或能够重新连接，直到明确超时或用户取消请求。这个想法是一些独立的事件发生在服务器上，触发已建立的套接字发送数据。如果您认为 Web 套接字以外的某些技术对这种情况(例如 HTML/2 或流式传输)更有用，能否请您描述一下您将使用的模式和框架？

附言可能的解决方案是每秒发送一次 AJAX 请求，询问服务器上是否有新数据。这是最后的手段。

Answer 1

经过长时间的研究，我最终选择了自定义中间件解决方案。这是我的中间件类:

        public class SocketMiddleware
    {
        private static ConcurrentDictionary<string, SocketMiddleware> _activeConnections = new ConcurrentDictionary<string, SocketMiddleware>();
        private string _packet;

        private ManualResetEvent _send = new ManualResetEvent(false);
        private ManualResetEvent _exit = new ManualResetEvent(false);
        private readonly RequestDelegate _next;

        public SocketMiddleware(RequestDelegate next)
        {
            _next = next;
        }

        public void Send(string data)
        {
            _packet = data;
            _send.Set();
        }

        public async Task Invoke(HttpContext context)
        {
            if (context.WebSockets.IsWebSocketRequest)
            {    
                string connectionName = context.Request.Query["connectionName"]);
                if (!_activeConnections.Any(ac => ac.Key == connectionName))
                {
                    WebSocket socket = await context.WebSockets.AcceptWebSocketAsync();
                    if (socket == null || socket.State != WebSocketState.Open)
                    {
                        await _next.Invoke(context);
                        return;
                    }
                    Thread sender = new Thread(() => StartSending(socket));
                    sender.Start();

                    if (!_activeConnections.TryAdd(connectionName, this))
                    {
                        _exit.Set();
                        await _next.Invoke(context);
                        return;
                    }

                    while (true)
                    {
                        WebSocketReceiveResult result = socket.ReceiveAsync(new ArraySegment<byte>(new byte[1]), CancellationToken.None).Result;
                        if (result.CloseStatus.HasValue)
                        {
                            _exit.Set();
                            break;
                        }
                    }

                    SocketHandler dummy;
                    _activeConnections.TryRemove(key, out dummy);
                }
            }

            await _next.Invoke(context);

            string data = context.Items["Data"] as string;
            if (!string.IsNullOrEmpty(data))
            {
                string name = context.Items["ConnectionName"] as string;
                SocketMiddleware connection = _activeConnections.Where(ac => ac.Key == name)?.Single().Value;
                if (connection != null)
                {
                    connection.Send(data);
                }
            }
        }

        private void StartSending(WebSocket socket)
        {
            WaitHandle[] events = new WaitHandle[] { _send, _exit };
            while (true)
            {
                if (WaitHandle.WaitAny(events) == 1)
                {
                    break;
                }

                if (!string.IsNullOrEmpty(_packet))
                {
                    SendPacket(socket, _packet);
                }
                _send.Reset();
            }
        }

        private void SendPacket(WebSocket socket, string packet)
        {
            byte[] buffer = Encoding.UTF8.GetBytes(packet);
            ArraySegment<byte> segment = new ArraySegment<byte>(buffer);
            Task.Run(() => socket.SendAsync(segment, WebSocketMessageType.Text, true, CancellationToken.None));
        }
    }

这个中间件将在每个请求上运行。调用 Invoke 时，它​​会检查它是否是 Web 套接字请求。如果是，中间件检查这样的连接是否已经打开，如果没有，则接受握手并将其添加到连接字典中。字典是静态的很重要，这样它在应用程序生命周期内只创建一次。

现在如果我们停在这里并向上移动管道，HttpContext 最终将被销毁，并且由于套接字未正确封装，它也将被关闭。所以我们必须保持中间件线程运行。这是通过要求套接字接收一些数据来完成的。

你可能会问，如果需求只是发送，为什么还要接收？答案是它是可靠检测客户端断开连接的唯一方法。 HttpContext.RequestAborted.IsCancellationRequested 仅当您在 while 循环中不断发送时才有效。如果您需要在 WaitHandle 上等待某些服务器事件，则取消标志永远不会为真。我试图等待 HttpContext.RequestAborted.WaitHandle 作为我的退出事件，但它也从未设置过。所以我们要求套接字接收一些东西，如果那东西将 CloseStatus.HasValue 设置为 true，我们就知道客户端已断开连接。如果我们收到其他东西(客户端代码不安全)，我们将忽略它并重新开始接收。

发送是在一个单独的线程中完成的。原因是一样的，如果我们在主中间件线程上等待，就不可能检测到断开连接。为了通知发送方线程客户端断开连接，我们使用 _exit 同步变量。请记住，这里有私有(private)成员很好，因为 SocketMiddleware 实例保存在静态容器中。

现在，我们如何使用此设置实际发送任何内容？假设服务器上发生了一个事件，一些数据变得可用。为简单起见，我们假设此数据到达某个 Controller 操作的正常 http 请求中。 SocketMiddleware 将为每个请求运行，但由于它不是 web 套接字请求，_next.Invoke(context) 被调用并且请求到达 Controller 操作，它可能看起来像这样:

[Route("ProvideData")]
[HttpGet]
public ActionResult ProvideData(string data, string connectionName)
{
    if (!string.IsNullOrEmpty(data) && !string.IsNullOrEmpty(connectionName))
    {
        HttpContext.Items.Add("ConnectionName", connectionName);
        HttpContext.Items.Add("Data", data);
    }
        return Ok();
}

Controller 填充用于在组件之间共享数据的项目集合。然后管道再次返回到 SocketMiddleware，我们检查 context.Items 中是否有任何有趣的东西。如果存在，我们从字典中选择相应的连接并调用其 Send() 方法，该方法设置数据字符串并设置 _send 事件并允许在发送方线程内单次运行 while 循环。

瞧，我们有发送服务器端事件的套接字连接。这个例子非常原始，只是为了说明这个概念。当然，要使用此中间件，您需要在添加 MVC 之前在 Startup 类中添加以下行:

app.UseWebSockets();
app.UseMiddleware<SocketMiddleware>();

代码非常奇怪，希望当 dotnetcore 的 SignalR 最终出来时，我们能够写出更好的东西。希望这个例子对某人有用。欢迎提出意见和建议。