Mildomで使用するwebsocketクライアントをSystem.Net.Websocketsのものに置き換えた

Author: ryu-s

MildomSitePlugin/MildomCommentProvider.cs

@@ -89,7 +89,7 @@ private async Task ConnectInternalAsync(string input, IBrowserProfile browserPro
             //TODO:websocketUrlをAPI経由で取得する
             //https://im.mildom.com/?room_id=10045175&type=chat&call=get_server&cluster=aws_japan
             var websocketUrl = "wss://jp-room1.mildom.com/?roomId=" + roomId;
-            var p1 = new MessageProvider(new WebSocket(websocketUrl), _logger);
+            var p1 = new MessageProvider(new SytemNetWebSockets(websocketUrl), _logger);
             p1.MessageReceived += P1_MessageReceived;
             p1.MetadataUpdated += P1_MetadataUpdated;
             //var p2 = new MetadataProvider2(_server, _siteOptions);

MildomSitePlugin/WebSocket.cs

@@ -2,69 +2,82 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Threading.Tasks;
+using System.Net.WebSockets;
+using System.Threading;
+using System.Text;
+using System.IO;
 
 namespace MildomSitePlugin
 {
-    /// <summary>
-    /// 
-    /// </summary>
-    /// <remarks>接続毎にインスタンスを作る</remarks>
-    public class WebSocket : IWebSocket
+    public class SytemNetWebSockets : IWebSocket
     {
-        public event EventHandler Opened;
-
         public event EventHandler<string> Received;
-        WebSocket4Net.WebSocket _ws;
-        TaskCompletionSource<object> _tcs;
-        private readonly string _url;
+        public event EventHandler Opened;
 
-        public Task ReceiveAsync()
+        public void Disconnect()
         {
-            _tcs = new TaskCompletionSource<object>();
-            var cookies = new List<KeyValuePair<string, string>>();
-            _ws = new WebSocket4Net.WebSocket(_url, "", cookies);
-            _ws.MessageReceived += _ws_MessageReceived;
-            //_ws.NoDelay = true;
-            _ws.Opened += _ws_Opened;
-            _ws.Error += _ws_Error;
-            _ws.Closed += _ws_Closed;
-            _ws.Open();
-            return _tcs.Task;
+            _cts?.Cancel();
         }
-
-        private void _ws_Closed(object sender, EventArgs e)
+        ClientWebSocket _ws;
+        private readonly string _url;
+        private CancellationTokenSource _cts;
+        public async Task ReceiveAsync()
         {
-            _tcs.TrySetResult(null);
-        }
+            if (_cts != null) return;
+            _cts = new CancellationTokenSource();
+            _ws = new ClientWebSocket();
+            await _ws.ConnectAsync(new Uri(_url), _cts.Token);
+            Opened?.Invoke(this, EventArgs.Empty);
 
-        private void _ws_Error(object sender, SuperSocket.ClientEngine.ErrorEventArgs e)
-        {
-            _tcs.TrySetException(e.Exception);
-        }
+            var buf = new byte[4096];
+            var arr = new ArraySegment<byte>(buf);
+            int count = 0;
+            MemoryStream ms=new MemoryStream();
+            while (true)
+            {
+                var result = await _ws.ReceiveAsync(arr, _cts.Token);
+                if(result.MessageType == WebSocketMessageType.Close)
+                {
+                    break;
+                }
+                else if(result.MessageType == WebSocketMessageType.Text)
+                {
+                    if (result.EndOfMessage)
+                    {
+                        string s;
+                        if (count == 0)
+                        {
+                            s = Encoding.UTF8.GetString(buf, 0, result.Count);
+                        }
+                        else
+                        {
+                            ms.Write(buf, 0, result.Count);
+                            var k = ms.ToArray();
+                            s = Encoding.UTF8.GetString(k, 0, k.Length);
+                            ms = new MemoryStream();
+                            count = 0;
+                        }
+                        Received?.Invoke(this, s);
+                      
+                    }
+                    else
+                    {
+                        ms.Write(buf, 0, result.Count);
+                        count++;
+                    }
+                }
+            }
 
-        private void _ws_Opened(object sender, EventArgs e)
-        {
-            Opened?.Invoke(this, e);
+            _cts = null;
         }
 
         public async Task SendAsync(string s)
         {
-            Debug.WriteLine("send: " + s);
-            await Task.Yield();
-            _ws.Send(s);
-        }
-
-        private void _ws_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
-        {
-            Received?.Invoke(this, e.Message);
-        }
-
-        public void Disconnect()
-        {
-            _ws?.Close();
-            _ws = null;
+            if (_ws == null || _cts == null) return;
+            var buf = Encoding.UTF8.GetBytes(s);
+            await _ws.SendAsync(new ArraySegment<byte>(buf), WebSocketMessageType.Text, true, _cts.Token);
         }
-        public WebSocket(string url)
+        public SytemNetWebSockets(string url)
         {
             _url = url;
         }

SitePluginCommon/AutoReconnection/ConnectionManager.cs

@@ -85,6 +85,7 @@ private async Task FinishProviderAsync(List<IProvider> providers, IProvider prov
                 provider.Stop();
                 await provider.Work;
             }
+            catch (OperationCanceledException) { }
             catch (Exception ex)
             {
                 _logger.LogException(ex);