Merge branch 'dev' into dependabot/npm_and_yarn/docs/npm_and_yarn-dec7325368

alec1o · web-flow · commit 3c8d32e118ee · 2025-05-04T21:55:03.000+02:00
diff --git a/FUNDING.yml b/FUNDING.yml
@@ -0,0 +1 @@
+buy_me_a_coffee: alec1o
diff --git a/README.md b/README.md
@@ -59,9 +59,19 @@ powered by <a href="https://github.com/alec1o">ALEC1O</a><sub/>
 <td>
 <br>
 <div>
-    <a href="https://www.kezero.com/?invite_user='Netly'"><img alt="KeZero sponsor notice" src="/static/KeZero%20sponsor.png" height="35px" /></a>
-    <br>
-    <a href="https://www.jetbrains.com/community/opensource/"><img alt="JetBrains sponsor notice" src="/static/JetBrains%20sponsor.png" height="35px" /></a>
+    <a href="https://www.buymeacoffee.com/alec1o">
+      <img src="https://img.buymeacoffee.com/button-api/?text=Buy me a coffee&emoji=☕&slug=alec1o&button_colour=FFDD00&font_colour=000000&font_family=Cookie&outline_colour=000000&coffee_colour=ffffff" />&nbsp;&nbsp;
+      <sup>Keep Netly alive – sponsor it on Buy Me a Coffee.</sup>
+    </a>
+    <br><hr>
+    <a href="https://www.kezero.com/?invite=netly" justify="start" align="start">
+        <img src="https://raw.githubusercontent.com/kezerocom/BrandAsset/refs/heads/main/logo/v2/blue.png" alt="KeZero logo." height="45px">&nbsp;&nbsp;
+        <sup>KeZero sponsor Netly with hosting infrastructure and website domain.</sup>
+    </a><hr>
+    <a href="https://www.jetbrains.com/community/opensource/">
+        <img src="https://resources.jetbrains.com/storage/products/company/brand/logos/jetbrains.png" alt="JetBrains logo." height="30px">&nbsp;&nbsp;
+        <sup>Netly receives JetBrains' IDE for free, Thanks to their generous  sponsorship.</sup>
+    </a><br>
 </div>
 <br>
 </td>
@@ -169,7 +179,12 @@ powered by <a href="https://github.com/alec1o">ALEC1O</a><sub/>
 -   <sub>[.NET](https://dotnet.microsoft.com) (SDK)</sub>
 -   <sub>[Mono](https://mono-project.com) (SDK)</sub>
 -   <sub>[Unity](https://unity.com) (Engine)</sub>
--   <sub>[Operating system](https://en.wikipedia.org/wiki/Operating_system) (OS)</sub> - <sub>Linux</sub> - <sub>Windows</sub> - <sub>Android</sub> - <sub>iOS</sub> - <sub>macOS</sub><br><br>
+-   <sub>[Operating system](https://en.wikipedia.org/wiki/Operating_system) (OS)</sub>
+    - <sub>Android</sub>
+    - <sub>iOS</sub>
+    - <sub>Windows</sub>
+    - <sub>Linux</sub>
+    - <sub>macOS</sub><br><br>
     <sub><strong>Notice</strong>: <i>This library might run on all devices. If it doesn't work on any device, it
     should be considered a bug and reported.<i><sub>
 
diff --git a/src/http/partials/Server/HTTP.ServerTo.cs b/src/http/partials/Server/HTTP.ServerTo.cs
@@ -70,6 +70,7 @@ public Task Open(Uri host)
                     }
                     catch (Exception e)
                     {
+                        NetlyEnvironment.Logger.Create(e);
                         _server.MyServerOn.OnError?.Invoke(null, e);
                     }
                     finally
@@ -101,9 +102,9 @@ public Task Close()
                             foreach (var socket in _websocketList) socket.To.Close();
                         }
                     }
-                    catch
+                    catch (Exception e)
                     {
-                        // Ignored
+                        NetlyEnvironment.Logger.Create(e);
                     }
                     finally
                     {
@@ -170,14 +171,21 @@ private void InitAccept()
 
                 void AcceptCallback(IAsyncResult result)
                 {
-                    if (IsOpened)
+                    try
                     {
-                        HandleContext(_listener.EndGetContext(result));
-                        InitAccept();
+                        if (IsOpened)
+                        {
+                            HandleContext(_listener.EndGetContext(result));
+                            InitAccept();
+                        }
+                        else
+                        {
+                            Close();
+                        }
                     }
-                    else
+                    catch (Exception e)
                     {
-                        Close();
+                        NetlyEnvironment.Logger.Create(e);
                     }
                 }
 
@@ -196,15 +204,14 @@ void HandleContext(HttpListenerContext context)
                         }
                         catch (Exception e)
                         {
+                            NetlyEnvironment.Logger.Create($"{this}: {e}");
                             if (socket?.WebSocket != null)
                                 await socket.WebSocket.CloseAsync
                                 (
                                     WebSocketCloseStatus.InternalServerError,
                                     string.Empty,
                                     CancellationToken.None
                                 );
-
-                            NetlyEnvironment.Logger.Create($"{this}: {e}");
                         }
                     });
                 }
@@ -276,8 +283,9 @@ private void HandleConnection(HttpListenerContext context, HttpListenerWebSocket
                     {
                         descriptor.Next = descriptors[i + 1];
                     }
-                    catch
+                    catch (Exception e)
                     {
+                        NetlyEnvironment.Logger.Create(e);
                         descriptor.Next = null;
                     }
                 }
diff --git a/src/http/partials/Websocket/HTTP.WebSocketTo.cs b/src/http/partials/Websocket/HTTP.WebSocketTo.cs
@@ -80,7 +80,7 @@ public Task Open(Uri host)
                             Thread.Sleep(TimeSpan.FromMilliseconds(byte.MaxValue)); // (Only client side)
                             ws = new ClientWebSocket();
                         }
-                        
+
                         foreach (var header in Headers) ws.Options.SetRequestHeader(header.Key, header.Value);
 
                         _socket._on.OnModify?.Invoke(null, ws);
@@ -99,14 +99,16 @@ public Task Open(Uri host)
                     }
                     catch (Exception e)
                     {
+                        NetlyEnvironment.Logger.Create(e);
+
                         try
                         {
                             await _websocket.CloseAsync(WebSocketCloseStatus.EndpointUnavailable, string.Empty,
                                 CancellationToken.None);
                         }
-                        catch
+                        catch(Exception e2)
                         {
-                            // ignored
+                            NetlyEnvironment.Logger.Create(e2);
                         }
                         finally
                         {
@@ -176,7 +178,7 @@ public Task Close(WebSocketCloseStatus status)
                     catch (Exception e)
                     {
                         // HACK: FIX IT
-                        Console.WriteLine(e);
+                        NetlyEnvironment.Logger.Create(e);
                     }
                     finally
                     {
@@ -298,8 +300,9 @@ private async void ReceiveJob(object _)
                             _socket._on.OnData?.Invoke(null, (data, messageType));
                     }
                 }
-                catch
+                catch(Exception e)
                 {
+                    NetlyEnvironment.Logger.Create(e);
                     closeStatus = WebSocketCloseStatus.EndpointUnavailable;
                 }
                 finally
diff --git a/src/rudp/partials/RUDP.ClientTo.cs b/src/rudp/partials/RUDP.ClientTo.cs
@@ -83,11 +83,11 @@ public Task Open(Host host)
                     }
                     catch (Exception e)
                     {
+                        // logger
+                        NetlyEnvironment.Logger.Create(e);
                         // error on open connection
                         On.OnError?.Invoke(null, e);
                         _connection = null;
-                        // logger
-                        NetlyEnvironment.Logger.Create(e);
                     }
                     finally
                     {
diff --git a/src/rudp/partials/RUDP.ServerTo.cs b/src/rudp/partials/RUDP.ServerTo.cs
@@ -69,6 +69,7 @@ public Task Open(Host host)
                     }
                     catch (Exception e)
                     {
+                        NetlyEnvironment.Logger.Create(e);
                         _isClosed = true;
                         On.OnError?.Invoke(null, e);
                     }
@@ -373,7 +374,7 @@ private void ContentUpdate()
 
                                 // invoke new client
                                 On.OnAccept?.Invoke(null, client);
-                                
+
                                 // start client connection callback
                                 client._on?.OnModify(null, _socket);
                                 client._on?.OnOpen(null, null);
diff --git a/src/tcp/partials/TCP.ClientTo.cs b/src/tcp/partials/TCP.ClientTo.cs
@@ -119,6 +119,7 @@ public Task Open(Host host)
                         }
                         catch (Exception e)
                         {
+                            NetlyEnvironment.Logger.Create(e);
                             On.OnError?.Invoke(null, e);
                         }
                         finally
@@ -221,7 +222,7 @@ public void Event(string name, string data)
 
                 public void Event(string name, string data, Encoding encoding)
                 {
-                    if (CanSend == false || string.IsNullOrEmpty(name) || string.IsNullOrEmpty(data))return;
+                    if (CanSend == false || string.IsNullOrEmpty(name) || string.IsNullOrEmpty(data)) return;
 
                     SendDispatch(NetlyEnvironment.EventManager.Create(name, data.GetBytes(encoding)));
                 }
@@ -242,8 +243,9 @@ void Callback()
                                 InitEncryption();
                                 _serverValidatorCallback?.Invoke(_client, true);
                             }
-                            catch
+                            catch (Exception e)
                             {
+                                NetlyEnvironment.Logger.Create(e);
                                 _serverValidatorCallback?.Invoke(_client, false);
                             }
                         }
@@ -386,9 +388,9 @@ private void SendDispatch(byte[] bytes)
                         else
                             _netStream?.BeginWrite(bytes, 0, bytes.Length, null, null);
                     }
-                    catch
+                    catch(Exception e)
                     {
-                        // Ignored
+                        NetlyEnvironment.Logger.Create(e);
                     }
                 }
 
diff --git a/src/tcp/partials/TCP.ServerTo.cs b/src/tcp/partials/TCP.ServerTo.cs
@@ -103,6 +103,7 @@ public Task Open(Host host, int backlog)
                         }
                         catch (Exception e)
                         {
+                            NetlyEnvironment.Logger.Create(e);
                             On.OnError?.Invoke(null, e);
                         }
 
@@ -126,9 +127,9 @@ public Task Close()
 
                             _socket.Dispose();
                         }
-                        catch
+                        catch (Exception e)
                         {
-                            // Ignored
+                            NetlyEnvironment.Logger.Create(e);
                         }
                         finally
                         {
diff --git a/src/udp/partials/UDP.ClientTo.cs b/src/udp/partials/UDP.ClientTo.cs
@@ -72,8 +72,8 @@ public Task Open(Host host)
                         }
                         catch (Exception e)
                         {
-                            _isClosed = true;
                             NetlyEnvironment.Logger.Create(e);
+                            _isClosed = true;
                             On.OnError?.Invoke(null, e);
                         }
                         finally
diff --git a/src/udp/partials/UDP.ServerTo.cs b/src/udp/partials/UDP.ServerTo.cs
@@ -68,6 +68,7 @@ public Task Open(Host host)
                         }
                         catch (Exception e)
                         {
+                            NetlyEnvironment.Logger.Create(e);
                             _isClosed = true;
                             On.OnError?.Invoke(null, e);
                         }
@@ -110,9 +111,9 @@ public Task Close()
                             _socket?.Close();
                             _socket?.Dispose();
                         }
-                        catch
+                        catch (Exception e)
                         {
-                            // Ignored
+                            NetlyEnvironment.Logger.Create(e);
                         }
                         finally
                         {
diff --git a/test/src/HTTP.xunit.cs b/test/src/HTTP.xunit.cs
@@ -259,22 +259,22 @@ public async Task BodyParser()
         Assert.True(server.IsOpened);
 
         var client = new HTTP.Client();
-        client.Timeout = 2000;
+        client.Timeout = 3000;
         client.On.Error(e => throw e);
 
         client.Headers["content-type"] = "application/json";
         await client.To.Open("GET", url);
-        await Task.Delay(1000);
+        await Task.Delay(1500);
         Assert.Equal("is json", data);
 
         client.Headers["content-type"] = "application/xml";
         await client.To.Open("GET", url);
-        await Task.Delay(1000);
+        await Task.Delay(1500);
         Assert.Equal("is xml", data);
 
         client.Headers["content-type"] = "text/html";
         await client.To.Open("GET", url);
-        await Task.Delay(1000);
+        await Task.Delay(1500);
         Assert.Equal("is empty", data);
     }
 }
diff --git a/test/src/RUDP.xunit.cs b/test/src/RUDP.xunit.cs
@@ -73,7 +73,7 @@ public async Task RudpConnection()
         await client.To.Open(server.Host);
         Assert.True(client.IsOpened);
         Assert.NotEmpty(client.Id);
-        await Task.Delay(500);
+        await Task.Delay(2000);
         Assert.NotNull(session);
         Assert.NotEmpty(session.Id);
         Assert.Equal(3, index);
@@ -96,7 +96,7 @@ public async Task RudpConnection()
         client.To.Data("Hello World, by To.Data", RUDP.Reliable);
         client.To.Event("Welcome to event", "Hello!", RUDP.Unreliable);
 
-        await Task.Delay(250);
+        await Task.Delay(2000);
 
         Assert.NotEmpty(sessionData.data);
         Assert.NotEmpty(clientData.data);
@@ -120,10 +120,10 @@ public async Task RudpConnection()
         Assert.Equal(8, index);
         index = 0;
 
-        await Task.Delay(7000);
+        await Task.Delay(10000);
         Assert.False(session.IsOpened);
         await client.To.Open(new("127.0.0.1", 7002));
-        await Task.Delay(200);
+        await Task.Delay(2000);
         Assert.False(client.IsOpened);
         Assert.Equal(2 + 4, index); // open and close (NEVER OPENED).
     }
diff --git a/test/src/WebSocket.xunit.cs b/test/src/WebSocket.xunit.cs
@@ -82,7 +82,7 @@ public async Task WebSocketConnection()
         client.To.Data("Hello World, by To.Data", HTTP.MessageType.Text);
         client.To.Event("Welcome to event", "Hello!", HTTP.MessageType.Binary);
 
-        await Task.Delay(250);
+        await Task.Delay(2500);
 
         Assert.NotEmpty(sessionData.data);
         Assert.NotEmpty(clientData.data);
@@ -106,18 +106,18 @@ public async Task WebSocketConnection()
         Assert.Equal(8, index);
         index = 0;
 
-        await Task.Delay(100);
+        await Task.Delay(2000);
         Assert.False(session.IsOpened);
 
 
         await client.To.Open(new("ws://127.0.0.1:6001/empty"));
-        await Task.Delay(6000);
+        await Task.Delay(10000);
         Assert.False(client.IsOpened);
         Assert.Equal(1 + 2 + 8, index); // open and close: because path;
         index = 0;
 
         await client.To.Open(new("ws://127.0.0.1:112/"));
-        await Task.Delay(500);
+        await Task.Delay(2000);
         Assert.False(client.IsOpened);
         Assert.Equal(2 + 4, index); // open and close (NEVER OPENED).
     }

Original file line number	Diff line number	Diff line change
`@@ -70,6 +70,7 @@ public Task Open(Uri host)`
`70`	`70`	`}`
`71`	`71`	`catch (Exception e)`
`72`	`72`	`{`
	`73`	`+ NetlyEnvironment.Logger.Create(e);`
`73`	`74`	`_server.MyServerOn.OnError?.Invoke(null, e);`
`74`	`75`	`}`
`75`	`76`	`finally`
`@@ -101,9 +102,9 @@ public Task Close()`
`101`	`102`	`foreach (var socket in _websocketList) socket.To.Close();`
`102`	`103`	`}`
`103`	`104`	`}`
`104`		`- catch`
	`105`	`+ catch (Exception e)`
`105`	`106`	`{`
`106`		`- // Ignored`
	`107`	`+ NetlyEnvironment.Logger.Create(e);`
`107`	`108`	`}`
`108`	`109`	`finally`
`109`	`110`	`{`
`@@ -170,14 +171,21 @@ private void InitAccept()`
`170`	`171`
`171`	`172`	`void AcceptCallback(IAsyncResult result)`
`172`	`173`	`{`
`173`		`- if (IsOpened)`
	`174`	`+ try`
`174`	`175`	`{`
`175`		`- HandleContext(_listener.EndGetContext(result));`
`176`		`- InitAccept();`
	`176`	`+ if (IsOpened)`
	`177`	`+ {`
	`178`	`+ HandleContext(_listener.EndGetContext(result));`
	`179`	`+ InitAccept();`
	`180`	`+ }`
	`181`	`+ else`
	`182`	`+ {`
	`183`	`+ Close();`
	`184`	`+ }`
`177`	`185`	`}`
`178`		`- else`
	`186`	`+ catch (Exception e)`
`179`	`187`	`{`
`180`		`- Close();`
	`188`	`+ NetlyEnvironment.Logger.Create(e);`
`181`	`189`	`}`
`182`	`190`	`}`
`183`	`191`
`@@ -196,15 +204,14 @@ void HandleContext(HttpListenerContext context)`
`196`	`204`	`}`
`197`	`205`	`catch (Exception e)`
`198`	`206`	`{`
	`207`	`+ NetlyEnvironment.Logger.Create($"{this}: {e}");`
`199`	`208`	`if (socket?.WebSocket != null)`
`200`	`209`	`await socket.WebSocket.CloseAsync`
`201`	`210`	`(`
`202`	`211`	`WebSocketCloseStatus.InternalServerError,`
`203`	`212`	`string.Empty,`
`204`	`213`	`CancellationToken.None`
`205`	`214`	`);`
`206`		`-`
`207`		`- NetlyEnvironment.Logger.Create($"{this}: {e}");`
`208`	`215`	`}`
`209`	`216`	`});`
`210`	`217`	`}`
`@@ -276,8 +283,9 @@ private void HandleConnection(HttpListenerContext context, HttpListenerWebSocket`
`276`	`283`	`{`
`277`	`284`	`descriptor.Next = descriptors[i + 1];`
`278`	`285`	`}`
`279`		`- catch`
	`286`	`+ catch (Exception e)`
`280`	`287`	`{`
	`288`	`+ NetlyEnvironment.Logger.Create(e);`
`281`	`289`	`descriptor.Next = null;`
`282`	`290`	`}`
`283`	`291`	`}`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ public Task Open(Uri host)`
`80`	`80`	`Thread.Sleep(TimeSpan.FromMilliseconds(byte.MaxValue)); // (Only client side)`
`81`	`81`	`ws = new ClientWebSocket();`
`82`	`82`	`}`
`83`		`-`
	`83`	`+`
`84`	`84`	`foreach (var header in Headers) ws.Options.SetRequestHeader(header.Key, header.Value);`
`85`	`85`
`86`	`86`	`_socket._on.OnModify?.Invoke(null, ws);`
`@@ -99,14 +99,16 @@ public Task Open(Uri host)`
`99`	`99`	`}`
`100`	`100`	`catch (Exception e)`
`101`	`101`	`{`
	`102`	`+ NetlyEnvironment.Logger.Create(e);`
	`103`	`+`
`102`	`104`	`try`
`103`	`105`	`{`
`104`	`106`	`await _websocket.CloseAsync(WebSocketCloseStatus.EndpointUnavailable, string.Empty,`
`105`	`107`	`CancellationToken.None);`
`106`	`108`	`}`
`107`		`- catch`
	`109`	`+ catch(Exception e2)`
`108`	`110`	`{`
`109`		`- // ignored`
	`111`	`+ NetlyEnvironment.Logger.Create(e2);`
`110`	`112`	`}`
`111`	`113`	`finally`
`112`	`114`	`{`
`@@ -176,7 +178,7 @@ public Task Close(WebSocketCloseStatus status)`
`176`	`178`	`catch (Exception e)`
`177`	`179`	`{`
`178`	`180`	`// HACK: FIX IT`
`179`		`- Console.WriteLine(e);`
	`181`	`+ NetlyEnvironment.Logger.Create(e);`
`180`	`182`	`}`
`181`	`183`	`finally`
`182`	`184`	`{`
`@@ -298,8 +300,9 @@ private async void ReceiveJob(object _)`
`298`	`300`	`_socket._on.OnData?.Invoke(null, (data, messageType));`
`299`	`301`	`}`
`300`	`302`	`}`
`301`		`- catch`
	`303`	`+ catch(Exception e)`
`302`	`304`	`{`
	`305`	`+ NetlyEnvironment.Logger.Create(e);`
`303`	`306`	`closeStatus = WebSocketCloseStatus.EndpointUnavailable;`
`304`	`307`	`}`
`305`	`308`	`finally`
Original file line number	Diff line number	Diff line change
`@@ -83,11 +83,11 @@ public Task Open(Host host)`
`83`	`83`	`}`
`84`	`84`	`catch (Exception e)`
`85`	`85`	`{`
	`86`	`+ // logger`
	`87`	`+ NetlyEnvironment.Logger.Create(e);`
`86`	`88`	`// error on open connection`
`87`	`89`	`On.OnError?.Invoke(null, e);`
`88`	`90`	`_connection = null;`
`89`		`- // logger`
`90`		`- NetlyEnvironment.Logger.Create(e);`
`91`	`91`	`}`
`92`	`92`	`finally`
`93`	`93`	`{`
Original file line number	Diff line number	Diff line change
`@@ -69,6 +69,7 @@ public Task Open(Host host)`
`69`	`69`	`}`
`70`	`70`	`catch (Exception e)`
`71`	`71`	`{`
	`72`	`+ NetlyEnvironment.Logger.Create(e);`
`72`	`73`	`_isClosed = true;`
`73`	`74`	`On.OnError?.Invoke(null, e);`
`74`	`75`	`}`
`@@ -373,7 +374,7 @@ private void ContentUpdate()`
`373`	`374`
`374`	`375`	`// invoke new client`
`375`	`376`	`On.OnAccept?.Invoke(null, client);`
`376`		`-`
	`377`	`+`
`377`	`378`	`// start client connection callback`
`378`	`379`	`client._on?.OnModify(null, _socket);`
`379`	`380`	`client._on?.OnOpen(null, null);`
Original file line number	Diff line number	Diff line change
`@@ -119,6 +119,7 @@ public Task Open(Host host)`
`119`	`119`	`}`
`120`	`120`	`catch (Exception e)`
`121`	`121`	`{`
	`122`	`+ NetlyEnvironment.Logger.Create(e);`
`122`	`123`	`On.OnError?.Invoke(null, e);`
`123`	`124`	`}`
`124`	`125`	`finally`
`@@ -221,7 +222,7 @@ public void Event(string name, string data)`
`221`	`222`
`222`	`223`	`public void Event(string name, string data, Encoding encoding)`
`223`	`224`	`{`
`224`		`- if (CanSend == false \|\| string.IsNullOrEmpty(name) \|\| string.IsNullOrEmpty(data))return;`
	`225`	`+ if (CanSend == false \|\| string.IsNullOrEmpty(name) \|\| string.IsNullOrEmpty(data)) return;`
`225`	`226`
`226`	`227`	`SendDispatch(NetlyEnvironment.EventManager.Create(name, data.GetBytes(encoding)));`
`227`	`228`	`}`
`@@ -242,8 +243,9 @@ void Callback()`
`242`	`243`	`InitEncryption();`
`243`	`244`	`_serverValidatorCallback?.Invoke(_client, true);`
`244`	`245`	`}`
`245`		`- catch`
	`246`	`+ catch (Exception e)`
`246`	`247`	`{`
	`248`	`+ NetlyEnvironment.Logger.Create(e);`
`247`	`249`	`_serverValidatorCallback?.Invoke(_client, false);`
`248`	`250`	`}`
`249`	`251`	`}`
`@@ -386,9 +388,9 @@ private void SendDispatch(byte[] bytes)`
`386`	`388`	`else`
`387`	`389`	`_netStream?.BeginWrite(bytes, 0, bytes.Length, null, null);`
`388`	`390`	`}`
`389`		`- catch`
	`391`	`+ catch(Exception e)`
`390`	`392`	`{`
`391`		`- // Ignored`
	`393`	`+ NetlyEnvironment.Logger.Create(e);`
`392`	`394`	`}`
`393`	`395`	`}`
`394`	`396`
Original file line number	Diff line number	Diff line change
`@@ -103,6 +103,7 @@ public Task Open(Host host, int backlog)`
`103`	`103`	`}`
`104`	`104`	`catch (Exception e)`
`105`	`105`	`{`
	`106`	`+ NetlyEnvironment.Logger.Create(e);`
`106`	`107`	`On.OnError?.Invoke(null, e);`
`107`	`108`	`}`
`108`	`109`
`@@ -126,9 +127,9 @@ public Task Close()`
`126`	`127`
`127`	`128`	`_socket.Dispose();`
`128`	`129`	`}`
`129`		`- catch`
	`130`	`+ catch (Exception e)`
`130`	`131`	`{`
`131`		`- // Ignored`
	`132`	`+ NetlyEnvironment.Logger.Create(e);`
`132`	`133`	`}`
`133`	`134`	`finally`
`134`	`135`	`{`
Original file line number	Diff line number	Diff line change
`@@ -72,8 +72,8 @@ public Task Open(Host host)`
`72`	`72`	`}`
`73`	`73`	`catch (Exception e)`
`74`	`74`	`{`
`75`		`- _isClosed = true;`
`76`	`75`	`NetlyEnvironment.Logger.Create(e);`
	`76`	`+ _isClosed = true;`
`77`	`77`	`On.OnError?.Invoke(null, e);`
`78`	`78`	`}`
`79`	`79`	`finally`
Original file line number	Diff line number	Diff line change
`@@ -68,6 +68,7 @@ public Task Open(Host host)`
`68`	`68`	`}`
`69`	`69`	`catch (Exception e)`
`70`	`70`	`{`
	`71`	`+ NetlyEnvironment.Logger.Create(e);`
`71`	`72`	`_isClosed = true;`
`72`	`73`	`On.OnError?.Invoke(null, e);`
`73`	`74`	`}`
`@@ -110,9 +111,9 @@ public Task Close()`
`110`	`111`	`_socket?.Close();`
`111`	`112`	`_socket?.Dispose();`
`112`	`113`	`}`
`113`		`- catch`
	`114`	`+ catch (Exception e)`
`114`	`115`	`{`
`115`		`- // Ignored`
	`116`	`+ NetlyEnvironment.Logger.Create(e);`
`116`	`117`	`}`
`117`	`118`	`finally`
`118`	`119`	`{`