expose the shutdown method to close the connection gracefully

bright2hu · May 31, 2017 · 7362c08 · 7362c08
1 parent e62d8d4
commit 7362c08
Show file tree

Hide file tree

Showing 10 changed files with 45 additions and 48 deletions.
diff --git a/Cowboy/Cowboy.Sockets.Experimental/Tcp/Server/RIO/TcpSocketRioSession.cs b/Cowboy/Cowboy.Sockets.Experimental/Tcp/Server/RIO/TcpSocketRioSession.cs
@@ -229,7 +229,8 @@ private async Task Process()
             }
             catch (ObjectDisposedException)
             {
-                // looking forward to a graceful quit from the ReadAsync, but the EndRead doesn't make it happen
+                // looking forward to a graceful quit from the ReadAsync but the inside EndRead will raise the ObjectDisposedException,
+                // so a gracefully close for the socket should be a Shutdown, but we cannot avoid the Close triggers this happen.
             }
             catch (Exception ex)
             {

diff --git a/Cowboy/Cowboy.Sockets/Tcp/Client/APM/TcpSocketClient.cs b/Cowboy/Cowboy.Sockets/Tcp/Client/APM/TcpSocketClient.cs
@@ -170,17 +170,16 @@ private void Close(bool shallNotifyUserSide)
             Clean();
         }
 
-        private void Shutdown()
+        public void Shutdown()
         {
-            try
+            // The correct way to shut down the connection (especially if you are in a full-duplex conversation) 
+            // is to call socket.Shutdown(SocketShutdown.Send) and give the remote party some time to close 
+            // their send channel. This ensures that you receive any pending data instead of slamming the 
+            // connection shut. ObjectDisposedException should never be part of the normal application flow.
+            if (_tcpClient != null && _tcpClient.Connected)
             {
-                // The correct way to shut down the connection (especially if you are in a full-duplex conversation) 
-                // is to call socket.Shutdown(SocketShutdown.Send) and give the remote party some time to close 
-                // their send channel. This ensures that you receive any pending data instead of slamming the 
-                // connection shut. ObjectDisposedException should never be part of the normal application flow.
                 _tcpClient.Client.Shutdown(SocketShutdown.Send);
             }
-            catch { }
         }
 
         private void Clean()

diff --git a/Cowboy/Cowboy.Sockets/Tcp/Client/SAEA/TcpSocketSaeaClient.cs b/Cowboy/Cowboy.Sockets/Tcp/Client/SAEA/TcpSocketSaeaClient.cs
@@ -394,17 +394,16 @@ private async Task Close(bool shallNotifyUserSide)
             Clean();
         }
 
-        private void Shutdown()
+        public void Shutdown()
         {
-            try
+            // The correct way to shut down the connection (especially if you are in a full-duplex conversation) 
+            // is to call socket.Shutdown(SocketShutdown.Send) and give the remote party some time to close 
+            // their send channel. This ensures that you receive any pending data instead of slamming the 
+            // connection shut. ObjectDisposedException should never be part of the normal application flow.
+            if (_socket != null && _socket.Connected)
             {
-                // The correct way to shut down the connection (especially if you are in a full-duplex conversation) 
-                // is to call socket.Shutdown(SocketShutdown.Send) and give the remote party some time to close 
-                // their send channel. This ensures that you receive any pending data instead of slamming the 
-                // connection shut. ObjectDisposedException should never be part of the normal application flow.
                 _socket.Shutdown(SocketShutdown.Send);
             }
-            catch { }
         }
 
         private void Clean()

diff --git a/Cowboy/Cowboy.Sockets/Tcp/Client/TAP/AsyncTcpSocketClient.cs b/Cowboy/Cowboy.Sockets/Tcp/Client/TAP/AsyncTcpSocketClient.cs
@@ -308,7 +308,8 @@ private async Task Process()
             }
             catch (ObjectDisposedException)
             {
-                // looking forward to a graceful quit from the ReadAsync, but the EndRead doesn't make it happen
+                // looking forward to a graceful quit from the ReadAsync but the inside EndRead will raise the ObjectDisposedException,
+                // so a gracefully close for the socket should be a Shutdown, but we cannot avoid the Close triggers this happen.
             }
             catch (Exception ex)
             {
@@ -444,17 +445,16 @@ private async Task Close(bool shallNotifyUserSide)
             Clean();
         }
 
-        private void Shutdown()
+        public void Shutdown()
         {
-            try
+            // The correct way to shut down the connection (especially if you are in a full-duplex conversation) 
+            // is to call socket.Shutdown(SocketShutdown.Send) and give the remote party some time to close 
+            // their send channel. This ensures that you receive any pending data instead of slamming the 
+            // connection shut. ObjectDisposedException should never be part of the normal application flow.
+            if (_tcpClient != null && _tcpClient.Connected)
             {
-                // The correct way to shut down the connection (especially if you are in a full-duplex conversation) 
-                // is to call socket.Shutdown(SocketShutdown.Send) and give the remote party some time to close 
-                // their send channel. This ensures that you receive any pending data instead of slamming the 
-                // connection shut. ObjectDisposedException should never be part of the normal application flow.
                 _tcpClient.Client.Shutdown(SocketShutdown.Send);
             }
-            catch { }
         }
 
         private void Clean()

diff --git a/Cowboy/Cowboy.Sockets/Tcp/Server/APM/TcpSocketSession.cs b/Cowboy/Cowboy.Sockets/Tcp/Server/APM/TcpSocketSession.cs
@@ -194,17 +194,16 @@ private void Close(bool shallNotifyUserSide)
             Clean();
         }
 
-        private void Shutdown()
+        public void Shutdown()
         {
-            try
+            // The correct way to shut down the connection (especially if you are in a full-duplex conversation) 
+            // is to call socket.Shutdown(SocketShutdown.Send) and give the remote party some time to close 
+            // their send channel. This ensures that you receive any pending data instead of slamming the 
+            // connection shut. ObjectDisposedException should never be part of the normal application flow.
+            if (_tcpClient != null && _tcpClient.Connected)
             {
-                // The correct way to shut down the connection (especially if you are in a full-duplex conversation) 
-                // is to call socket.Shutdown(SocketShutdown.Send) and give the remote party some time to close 
-                // their send channel. This ensures that you receive any pending data instead of slamming the 
-                // connection shut. ObjectDisposedException should never be part of the normal application flow.
                 _tcpClient.Client.Shutdown(SocketShutdown.Send);
             }
-            catch { }
         }
 
         private void Clean()

diff --git a/Cowboy/Cowboy.Sockets/Tcp/Server/SAEA/TcpSocketSaeaSession.cs b/Cowboy/Cowboy.Sockets/Tcp/Server/SAEA/TcpSocketSaeaSession.cs
@@ -329,17 +329,16 @@ private async Task Close(bool shallNotifyUserSide)
             Clean();
         }
 
-        private void Shutdown()
+        public void Shutdown()
         {
-            try
+            // The correct way to shut down the connection (especially if you are in a full-duplex conversation) 
+            // is to call socket.Shutdown(SocketShutdown.Send) and give the remote party some time to close 
+            // their send channel. This ensures that you receive any pending data instead of slamming the 
+            // connection shut. ObjectDisposedException should never be part of the normal application flow.
+            if (_socket != null && _socket.Connected)
             {
-                // The correct way to shut down the connection (especially if you are in a full-duplex conversation) 
-                // is to call socket.Shutdown(SocketShutdown.Send) and give the remote party some time to close 
-                // their send channel. This ensures that you receive any pending data instead of slamming the 
-                // connection shut. ObjectDisposedException should never be part of the normal application flow.
                 _socket.Shutdown(SocketShutdown.Send);
             }
-            catch { }
         }
 
         private void Clean()

diff --git a/Cowboy/Cowboy.Sockets/Tcp/Server/TAP/AsyncTcpSocketSession.cs b/Cowboy/Cowboy.Sockets/Tcp/Server/TAP/AsyncTcpSocketSession.cs
@@ -245,7 +245,8 @@ private async Task Process()
             }
             catch (ObjectDisposedException)
             {
-                // looking forward to a graceful quit from the ReadAsync, but the EndRead doesn't make it happen
+                // looking forward to a graceful quit from the ReadAsync but the inside EndRead will raise the ObjectDisposedException,
+                // so a gracefully close for the socket should be a Shutdown, but we cannot avoid the Close triggers this happen.
             }
             catch (Exception ex)
             {
@@ -382,17 +383,16 @@ private async Task Close(bool shallNotifyUserSide)
             Clean();
         }
 
-        private void Shutdown()
+        public void Shutdown()
         {
-            try
+            // The correct way to shut down the connection (especially if you are in a full-duplex conversation) 
+            // is to call socket.Shutdown(SocketShutdown.Send) and give the remote party some time to close 
+            // their send channel. This ensures that you receive any pending data instead of slamming the 
+            // connection shut. ObjectDisposedException should never be part of the normal application flow.
+            if (_tcpClient != null && _tcpClient.Connected)
             {
-                // The correct way to shut down the connection (especially if you are in a full-duplex conversation) 
-                // is to call socket.Shutdown(SocketShutdown.Send) and give the remote party some time to close 
-                // their send channel. This ensures that you receive any pending data instead of slamming the 
-                // connection shut. ObjectDisposedException should never be part of the normal application flow.
                 _tcpClient.Client.Shutdown(SocketShutdown.Send);
             }
-            catch { }
         }
 
         private void Clean()

diff --git a/Cowboy/Tests/Cowboy.Sockets.TestAsyncTcpSocketClient/Program.cs b/Cowboy/Tests/Cowboy.Sockets.TestAsyncTcpSocketClient/Program.cs
@@ -108,7 +108,7 @@ static void Main(string[] args)
                     }
                 }
 
-                _client.Close().Wait();
+                _client.Shutdown();
                 Console.WriteLine("TCP client has disconnected from server [{0}].", remoteEP);
             }
             catch (Exception ex)

diff --git a/Cowboy/Tests/Cowboy.Sockets.TestTcpSocketClient/Program.cs b/Cowboy/Tests/Cowboy.Sockets.TestTcpSocketClient/Program.cs
@@ -100,7 +100,7 @@ static void Main(string[] args)
                 }
             }
 
-            _client.Close();
+            _client.Shutdown();
             Console.WriteLine("TCP client has disconnected from server.");
 
             Console.ReadKey();

diff --git a/Cowboy/Tests/Cowboy.Sockets.TestTcpSocketSaeaClient/Program.cs b/Cowboy/Tests/Cowboy.Sockets.TestTcpSocketSaeaClient/Program.cs
@@ -104,7 +104,7 @@ static void Main(string[] args)
                     }
                 }
 
-                _client.Close().Wait();
+                _client.Shutdown();
                 Console.WriteLine("TCP client has disconnected from server [{0}].", remoteEP);
             }
             catch (Exception ex)