refactor: deal with socket disposed exception

cnblogs-dudu · sanikachavan5 · commit 5eb98faa5657 · 2025-01-17T15:00:19.000+05:30
diff --git a/src/Enyim.Caching/Memcached/MemcachedNode.cs b/src/Enyim.Caching/Memcached/MemcachedNode.cs
@@ -1,9 +1,7 @@
 using AEPLCore.Monitoring;
 using Enyim.Caching.Configuration;
-using Enyim.Caching.Memcached.Protocol.Binary;
 using Enyim.Caching.Memcached.Results;
 using Enyim.Caching.Memcached.Results.Extensions;
-using Enyim.Collections;
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Concurrent;
@@ -13,8 +11,6 @@
 using System.Net;
 using System.Net.Security;
 using System.Net.Sockets;
-using System.Runtime.Serialization;
-using System.Security;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -1014,49 +1010,71 @@ protected internal virtual PooledSocket CreateSocket()
         {
             try
             {
-                var ps = new PooledSocket(_endPoint, _config.ConnectionTimeout, _config.ReceiveTimeout, _logger,
-#if NET5_0_OR_GREATER
-                    _useSslStream, _useIPv6, _sslClientAuthOptions);
-#else
-                    _useSslStream, _useIPv6);
-#endif
-                ps.Connect();
-                return ps;
+                return CreateSocketInternal();
             }
-            catch (Exception ex)
+            catch
             {
-                _logger.LogError(ex, $"Create {nameof(PooledSocket)}");
-                throw;
+                try
+                {
+                    return CreateSocketInternal();
+                }
+                catch (Exception ex)
+                {
+                    LogCreateSocketError(ex, nameof(CreateSocket));
+                    throw;
+                }
             }
         }
 
-        protected internal virtual async Task<PooledSocket> CreateSocketAsync()
+        private PooledSocket CreateSocketInternal()
         {
-            try
-            {
-                var ps = new PooledSocket(_endPoint, _config.ConnectionTimeout, _config.ReceiveTimeout, _logger,
+            var ps = new PooledSocket(_endPoint, _config.ConnectionTimeout, _config.ReceiveTimeout, _logger,
 #if NET5_0_OR_GREATER
-                    _useSslStream, _useIPv6, _sslClientAuthOptions);
+            _useSslStream, _useIPv6, _sslClientAuthOptions);
 #else
-                    _useSslStream, _useIPv6);
+            _useSslStream, _useIPv6);
 #endif
-                await ps.ConnectAsync();
-                return ps;
+            ps.Connect();
+            return ps;
+        }
+
+        protected internal virtual async Task<PooledSocket> CreateSocketAsync()
+        {
+            try
+            {
+                return await CreateSocketInternalAsync();
             }
-            catch (Exception ex)
+            catch
             {
-                var endPointStr = _endPoint.ToString().Replace("Unspecified/", string.Empty);
-                _logger.LogError(ex, $"Failed to {nameof(CreateSocketAsync)} to {endPointStr}");
-                throw;
+                try
+                {
+                    return await CreateSocketInternalAsync();
+                }
+                catch (Exception ex)
+                {
+                    LogCreateSocketError(ex, nameof(CreateSocketAsync));
+                    throw;
+                }
             }
         }
 
-        //protected internal virtual PooledSocket CreateSocket(IPEndPoint endpoint, TimeSpan connectionTimeout, TimeSpan receiveTimeout)
-        //{
-        //    PooledSocket retval = new PooledSocket(endPoint, connectionTimeout, receiveTimeout);
+        private async Task<PooledSocket> CreateSocketInternalAsync()
+        {
+            var ps = new PooledSocket(_endPoint, _config.ConnectionTimeout, _config.ReceiveTimeout, _logger,
+#if NET5_0_OR_GREATER
+            _useSslStream, _useIPv6, _sslClientAuthOptions);
+#else
+                _useSslStream, _useIPv6);
+#endif
+            await ps.ConnectAsync();
+            return ps;
+        }
 
-        //    return retval;
-        //}
+        private void LogCreateSocketError(Exception ex, string operation)
+        {
+            var endPointStr = _endPoint.ToString().Replace("Unspecified/", string.Empty);
+            _logger.LogError(ex, "Failed to {operation} to {EndPoint}", operation, endPointStr);
+        }
 
         protected virtual IPooledSocketResult ExecuteOperation(IOperation op)
         {
diff --git a/src/Enyim.Caching/Memcached/PooledSocket.cs b/src/Enyim.Caching/Memcached/PooledSocket.cs
@@ -18,9 +18,10 @@ public partial class PooledSocket : IDisposable
         private readonly ILogger _logger;
 
         private bool _isAlive;
-        private bool _useSslStream;
-        private bool _useIPv6;
+        private readonly bool _useSslStream;
+        private readonly bool _useIPv6;
         private Socket _socket;
+        private bool _isSocketDisposed;
         private readonly EndPoint _endpoint;
         private readonly int _connectionTimeout;
 
@@ -75,7 +76,7 @@ public PooledSocket(EndPoint endpoint, TimeSpan connectionTimeout, TimeSpan rece
             _socket = socket;
         }
 
-        public void Connect()
+        public bool Connect()
         {
             bool success = false;
 
@@ -87,20 +88,21 @@ void Cancel()
             {
                 if (_socket != null && !_socket.Connected)
                 {
-                    _socket.Dispose();
-                    _socket = null;
+                    DisposeSocket();
                 }
             }
 
             cts.Token.Register(Cancel);
 
             try
             {
+                if (_isSocketDisposed) return false;
                 _socket.Connect(_endpoint);
             }
             catch (PlatformNotSupportedException)
             {
                 var ep = GetIPEndPoint(_endpoint);
+                if (_isSocketDisposed) return false;
                 _socket.Connect(ep.Address, ep.Port);
             }
 
@@ -113,8 +115,7 @@ void Cancel()
                 }
                 else
                 {
-                    _socket.Dispose();
-                    _socket = null;
+                    DisposeSocket();
                 }
             }
 
@@ -135,17 +136,24 @@ void Cancel()
                 {
                     _inputStream = new NetworkStream(_socket);
                 }
+
+                return true;
             }
             else
             {
                 throw new TimeoutException($"Could not connect to {_endpoint}.");
             }
         }
 
-        public async Task ConnectAsync()
+        public async Task<bool> ConnectAsync()
         {
             bool success = false;
 
+            if (_isSocketDisposed)
+            {
+                return false;
+            }
+
             try
             {
                 var connTask = _socket.ConnectAsync(_endpoint);
@@ -158,8 +166,7 @@ public async Task ConnectAsync()
                 {
                     if (_socket != null)
                     {
-                        _socket.Dispose();
-                        _socket = null;
+                        DisposeSocket();
                     }
 
                     throw new TimeoutException($"Timeout to connect to {_endpoint}.");
@@ -168,6 +175,7 @@ public async Task ConnectAsync()
             catch (PlatformNotSupportedException)
             {
                 var ep = GetIPEndPoint(_endpoint);
+                if (_isSocketDisposed) return false;
                 await _socket.ConnectAsync(ep.Address, ep.Port);
             }
 
@@ -180,8 +188,7 @@ public async Task ConnectAsync()
                 }
                 else
                 {
-                    _socket.Dispose();
-                    _socket = null;
+                    DisposeSocket();
                 }
             }
 
@@ -202,6 +209,8 @@ await _sslStream.AuthenticateAsClientAsync(
                 {
                     _inputStream = new NetworkStream(_socket);
                 }
+
+                return true;
             }
             else
             {
@@ -336,7 +345,7 @@ protected void Dispose(bool disposing)
                 }
                 catch (Exception e)
                 {
-                    _logger.LogError(nameof(PooledSocket), e);
+                    _logger.LogError(e, nameof(PooledSocket));
                 }
             }
             else
@@ -355,8 +364,17 @@ void IDisposable.Dispose()
 
         private void CheckDisposed()
         {
-            if (_socket == null)
+            if (_isSocketDisposed || _socket == null)
+            {
                 throw new ObjectDisposedException("PooledSocket");
+            }
+        }
+
+        private void DisposeSocket()
+        {
+            _isSocketDisposed = true;
+            _socket.Dispose();
+            _socket = null;
         }
 
         /// <summary>

Original file line number	Diff line number	Diff line change
`@@ -18,9 +18,10 @@ public partial class PooledSocket : IDisposable`
`18`	`18`	`private readonly ILogger _logger;`
`19`	`19`
`20`	`20`	`private bool _isAlive;`
`21`		`- private bool _useSslStream;`
`22`		`- private bool _useIPv6;`
	`21`	`+ private readonly bool _useSslStream;`
	`22`	`+ private readonly bool _useIPv6;`
`23`	`23`	`private Socket _socket;`
	`24`	`+ private bool _isSocketDisposed;`
`24`	`25`	`private readonly EndPoint _endpoint;`
`25`	`26`	`private readonly int _connectionTimeout;`
`26`	`27`
`@@ -75,7 +76,7 @@ public PooledSocket(EndPoint endpoint, TimeSpan connectionTimeout, TimeSpan rece`
`75`	`76`	`_socket = socket;`
`76`	`77`	`}`
`77`	`78`
`78`		`- public void Connect()`
	`79`	`+ public bool Connect()`
`79`	`80`	`{`
`80`	`81`	`bool success = false;`
`81`	`82`
`@@ -87,20 +88,21 @@ void Cancel()`
`87`	`88`	`{`
`88`	`89`	`if (_socket != null && !_socket.Connected)`
`89`	`90`	`{`
`90`		`- _socket.Dispose();`
`91`		`- _socket = null;`
	`91`	`+ DisposeSocket();`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`cts.Token.Register(Cancel);`
`96`	`96`
`97`	`97`	`try`
`98`	`98`	`{`
	`99`	`+ if (_isSocketDisposed) return false;`
`99`	`100`	`_socket.Connect(_endpoint);`
`100`	`101`	`}`
`101`	`102`	`catch (PlatformNotSupportedException)`
`102`	`103`	`{`
`103`	`104`	`var ep = GetIPEndPoint(_endpoint);`
	`105`	`+ if (_isSocketDisposed) return false;`
`104`	`106`	`_socket.Connect(ep.Address, ep.Port);`
`105`	`107`	`}`
`106`	`108`
`@@ -113,8 +115,7 @@ void Cancel()`
`113`	`115`	`}`
`114`	`116`	`else`
`115`	`117`	`{`
`116`		`- _socket.Dispose();`
`117`		`- _socket = null;`
	`118`	`+ DisposeSocket();`
`118`	`119`	`}`
`119`	`120`	`}`
`120`	`121`
`@@ -135,17 +136,24 @@ void Cancel()`
`135`	`136`	`{`
`136`	`137`	`_inputStream = new NetworkStream(_socket);`
`137`	`138`	`}`
	`139`	`+`
	`140`	`+ return true;`
`138`	`141`	`}`
`139`	`142`	`else`
`140`	`143`	`{`
`141`	`144`	`throw new TimeoutException($"Could not connect to {_endpoint}.");`
`142`	`145`	`}`
`143`	`146`	`}`
`144`	`147`
`145`		`- public async Task ConnectAsync()`
	`148`	`+ public async Task<bool> ConnectAsync()`
`146`	`149`	`{`
`147`	`150`	`bool success = false;`
`148`	`151`
	`152`	`+ if (_isSocketDisposed)`
	`153`	`+ {`
	`154`	`+ return false;`
	`155`	`+ }`
	`156`	`+`
`149`	`157`	`try`
`150`	`158`	`{`
`151`	`159`	`var connTask = _socket.ConnectAsync(_endpoint);`
`@@ -158,8 +166,7 @@ public async Task ConnectAsync()`
`158`	`166`	`{`
`159`	`167`	`if (_socket != null)`
`160`	`168`	`{`
`161`		`- _socket.Dispose();`
`162`		`- _socket = null;`
	`169`	`+ DisposeSocket();`
`163`	`170`	`}`
`164`	`171`
`165`	`172`	`throw new TimeoutException($"Timeout to connect to {_endpoint}.");`
`@@ -168,6 +175,7 @@ public async Task ConnectAsync()`
`168`	`175`	`catch (PlatformNotSupportedException)`
`169`	`176`	`{`
`170`	`177`	`var ep = GetIPEndPoint(_endpoint);`
	`178`	`+ if (_isSocketDisposed) return false;`
`171`	`179`	`await _socket.ConnectAsync(ep.Address, ep.Port);`
`172`	`180`	`}`
`173`	`181`
`@@ -180,8 +188,7 @@ public async Task ConnectAsync()`
`180`	`188`	`}`
`181`	`189`	`else`
`182`	`190`	`{`
`183`		`- _socket.Dispose();`
`184`		`- _socket = null;`
	`191`	`+ DisposeSocket();`
`185`	`192`	`}`
`186`	`193`	`}`
`187`	`194`
`@@ -202,6 +209,8 @@ await _sslStream.AuthenticateAsClientAsync(`
`202`	`209`	`{`
`203`	`210`	`_inputStream = new NetworkStream(_socket);`
`204`	`211`	`}`
	`212`	`+`
	`213`	`+ return true;`
`205`	`214`	`}`
`206`	`215`	`else`
`207`	`216`	`{`
`@@ -336,7 +345,7 @@ protected void Dispose(bool disposing)`
`336`	`345`	`}`
`337`	`346`	`catch (Exception e)`
`338`	`347`	`{`
`339`		`- _logger.LogError(nameof(PooledSocket), e);`
	`348`	`+ _logger.LogError(e, nameof(PooledSocket));`
`340`	`349`	`}`
`341`	`350`	`}`
`342`	`351`	`else`
`@@ -355,8 +364,17 @@ void IDisposable.Dispose()`
`355`	`364`
`356`	`365`	`private void CheckDisposed()`
`357`	`366`	`{`
`358`		`- if (_socket == null)`
	`367`	`+ if (_isSocketDisposed \|\| _socket == null)`
	`368`	`+ {`
`359`	`369`	`throw new ObjectDisposedException("PooledSocket");`
	`370`	`+ }`
	`371`	`+ }`
	`372`	`+`
	`373`	`+ private void DisposeSocket()`
	`374`	`+ {`
	`375`	`+ _isSocketDisposed = true;`
	`376`	`+ _socket.Dispose();`
	`377`	`+ _socket = null;`
`360`	`378`	`}`
`361`	`379`
`362`	`380`	`/// <summary>`