Change naming convention

cnblogs-dudu · cnblogs-dudu · commit 8ddcef858b5d · 2019-05-06T16:20:47.000+08:00
diff --git a/Enyim.Caching/Memcached/MemcachedNode.cs b/Enyim.Caching/Memcached/MemcachedNode.cs
@@ -120,7 +120,7 @@ public bool Ping()
             //could not reconnect
             catch { return false; }
         }
-        
+
         /// <summary>
         /// Acquires a new item from the pool
         /// </summary>
@@ -275,7 +275,7 @@ internal InternalPoolImpl(
                 _logger = logger;
                 _isDebugEnabled = _logger.IsEnabled(LogLevel.Debug);
             }
-            
+
             internal void InitPool()
             {
                 try
@@ -321,7 +321,7 @@ internal async Task InitPoolAsync()
                     }
 
                     if (_logger.IsEnabled(LogLevel.Debug))
-                        _logger.LogDebug("Pool has been inited for {0} with {1} sockets", this.endPoint, this.minItems);
+                        _logger.LogDebug("Pool has been inited for {0} with {1} sockets", _endPoint, this.minItems);
 
                 }
                 catch (Exception e)
@@ -356,7 +356,7 @@ public DateTime MarkedAsDeadUtc
             {
                 get { return this.markedAsDeadUtc; }
             }
-            
+
             /// <summary>
             /// Acquires a new item from the pool
             /// </summary>
@@ -473,11 +473,11 @@ public async Task<IPooledSocketResult> AcquireAsync()
                 var result = new PooledSocketResult();
                 var message = string.Empty;
 
-                if (_isDebugEnabled) _logger.LogDebug("Acquiring stream from pool. " + this.endPoint);
+                if (_isDebugEnabled) _logger.LogDebug("Acquiring stream from pool. " + _endPoint);
 
                 if (!this.isAlive || this.isDisposed)
                 {
-                    message = "Pool is dead or disposed, returning null. " + this.endPoint;
+                    message = "Pool is dead or disposed, returning null. " + _endPoint;
                     result.Fail(message);
 
                     if (_isDebugEnabled) _logger.LogDebug(message);
@@ -489,7 +489,7 @@ public async Task<IPooledSocketResult> AcquireAsync()
 
                 if (!await this.semaphore.WaitAsync(this.queueTimeout))
                 {
-                    message = "Pool is full, timeouting. " + this.endPoint;
+                    message = "Pool is full, timeouting. " + _endPoint;
                     if (_isDebugEnabled) _logger.LogDebug(message);
                     result.Fail(message, new TimeoutException());
 
@@ -500,7 +500,7 @@ public async Task<IPooledSocketResult> AcquireAsync()
                 // maybe we died while waiting
                 if (!this.isAlive)
                 {
-                    message = "Pool is dead, returning null. " + this.endPoint;
+                    message = "Pool is dead, returning null. " + _endPoint;
                     if (_isDebugEnabled) _logger.LogDebug(message);
                     result.Fail(message);
 
@@ -537,7 +537,7 @@ public async Task<IPooledSocketResult> AcquireAsync()
                 }
 
                 // free item pool is empty
-                message = "Could not get a socket from the pool, Creating a new item. " + this.endPoint;
+                message = "Could not get a socket from the pool, Creating a new item. " + _endPoint;
                 if (_isDebugEnabled) _logger.LogDebug(message);
 
 
@@ -552,7 +552,7 @@ public async Task<IPooledSocketResult> AcquireAsync()
                 }
                 catch (Exception e)
                 {
-                    message = "Failed to create socket. " + this.endPoint;
+                    message = "Failed to create socket. " + _endPoint;
                     _logger.LogError(message, e);
 
                     // eventhough this item failed the failure policy may keep the pool alive
@@ -702,22 +702,22 @@ protected internal virtual PooledSocket CreateSocket()
             try
             {
                 var ps = new PooledSocket(this.endPoint, this.config.ConnectionTimeout, this.config.ReceiveTimeout, _logger);
-                ps.Connect();
+                //ps.Connect();
                 return ps;
             }
             catch (Exception ex)
             {
                 _logger.LogError(ex, $"Create {nameof(PooledSocket)}");
                 throw;
             }
-            
+
         }
         protected internal virtual async Task<PooledSocket> CreateSocketAsync()
         {
             try
             {
                 var ps = new PooledSocket(this.endPoint, this.config.ConnectionTimeout, this.config.ReceiveTimeout, _logger);
-                await ps.ConnectAsync();
+                //await ps.ConnectAsync();
                 return ps;
             }
             catch (Exception ex)
diff --git a/Enyim.Caching/Memcached/PooledSocket.cs b/Enyim.Caching/Memcached/PooledSocket.cs
@@ -17,18 +17,18 @@ public partial class PooledSocket : IDisposable
     {
         private readonly ILogger _logger;
 
-        private bool isAlive;
-        private Socket socket;
-        private EndPoint endpoint;
+        private bool _isAlive;
+        private Socket _socket;
+        private EndPoint _endpoint;
 
-        private Stream inputStream;
-        private AsyncSocketHelper helper;
+        private Stream _inputStream;
+        private AsyncSocketHelper _helper;
 
         public PooledSocket(EndPoint endpoint, TimeSpan connectionTimeout, TimeSpan receiveTimeout, ILogger logger)
         {
             _logger = logger;
 
-            this.isAlive = true;
+            _isAlive = true;
 
             var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
             socket.NoDelay = true;
@@ -49,10 +49,10 @@ public PooledSocket(EndPoint endpoint, TimeSpan connectionTimeout, TimeSpan rece
                 throw new TimeoutException($"Could not connect to {endpoint}.");
             }
 
-            this.socket = socket;
-            this.endpoint = endpoint;
+            _socket = socket;
+            _endpoint = endpoint;
 
-            this.inputStream = new NetworkStream(socket);
+            _inputStream = new NetworkStream(socket);
         }
 
         private bool ConnectWithTimeout(Socket socket, EndPoint endpoint, int timeout)
@@ -89,24 +89,24 @@ void Cancel()
 
         public int Available
         {
-            get { return this.socket.Available; }
+            get { return _socket.Available; }
         }
 
         public void Reset()
         {
             // discard any buffered data
-            this.inputStream.Flush();
+            _inputStream.Flush();
 
-            if (this.helper != null) this.helper.DiscardBuffer();
+            if (_helper != null) _helper.DiscardBuffer();
 
-            int available = this.socket.Available;
+            int available = _socket.Available;
 
             if (available > 0)
             {
                 if (_logger.IsEnabled(LogLevel.Warning))
                     _logger.LogWarning(
                         "Socket bound to {0} has {1} unread data! This is probably a bug in the code. InstanceID was {2}.",
-                        this.socket.RemoteEndPoint, available, this.InstanceId);
+                        _socket.RemoteEndPoint, available, this.InstanceId);
 
                 byte[] data = new byte[available];
 
@@ -127,7 +127,7 @@ public void Reset()
 
         public bool IsAlive
         {
-            get { return this.isAlive; }
+            get { return _isAlive; }
         }
 
         /// <summary>
@@ -158,20 +158,20 @@ protected void Dispose(bool disposing)
 
                 try
                 {
-                    if (socket != null)
+                    if (_socket != null)
                         try
                         {
-                            this.socket.Dispose();
+                            _socket.Dispose();
                         }
                         catch
                         {
                         }
 
-                    if (this.inputStream != null)
-                        this.inputStream.Dispose();
+                    if (_inputStream != null)
+                        _inputStream.Dispose();
 
-                    this.inputStream = null;
-                    this.socket = null;
+                    _inputStream = null;
+                    _socket = null;
                     this.CleanupCallback = null;
                 }
                 catch (Exception e)
@@ -195,7 +195,7 @@ void IDisposable.Dispose()
 
         private void CheckDisposed()
         {
-            if (this.socket == null)
+            if (_socket == null)
                 throw new ObjectDisposedException("PooledSocket");
         }
 
@@ -209,11 +209,11 @@ public int ReadByte()
 
             try
             {
-                return this.inputStream.ReadByte();
+                return _inputStream.ReadByte();
             }
             catch (IOException)
             {
-                this.isAlive = false;
+                _isAlive = false;
 
                 throw;
             }
@@ -225,11 +225,11 @@ public int ReadByteAsync()
 
             try
             {
-                return this.inputStream.ReadByte();
+                return _inputStream.ReadByte();
             }
             catch (IOException)
             {
-                this.isAlive = false;
+                _isAlive = false;
                 throw;
             }
         }
@@ -245,7 +245,7 @@ public async Task ReadAsync(byte[] buffer, int offset, int count)
             {
                 try
                 {
-                    int currentRead = this.inputStream.Read(buffer, offset, shouldRead);
+                    int currentRead = _inputStream.Read(buffer, offset, shouldRead);
                     if (currentRead < 1)
                         continue;
 
@@ -255,7 +255,7 @@ public async Task ReadAsync(byte[] buffer, int offset, int count)
                 }
                 catch (IOException)
                 {
-                    this.isAlive = false;
+                    _isAlive = false;
                     throw;
                 }
             }
@@ -279,7 +279,7 @@ public void Read(byte[] buffer, int offset, int count)
             {
                 try
                 {
-                    int currentRead = this.inputStream.Read(buffer, offset, shouldRead);
+                    int currentRead = _inputStream.Read(buffer, offset, shouldRead);
                     if (currentRead < 1)
                         continue;
 
@@ -289,7 +289,7 @@ public void Read(byte[] buffer, int offset, int count)
                 }
                 catch (IOException)
                 {
-                    this.isAlive = false;
+                    _isAlive = false;
                     throw;
                 }
             }
@@ -301,13 +301,13 @@ public void Write(byte[] data, int offset, int length)
 
             SocketError status;
 
-            this.socket.Send(data, offset, length, SocketFlags.None, out status);
+            _socket.Send(data, offset, length, SocketFlags.None, out status);
 
             if (status != SocketError.Success)
             {
-                this.isAlive = false;
+                _isAlive = false;
 
-                ThrowHelper.ThrowSocketWriteError(this.endpoint, status);
+                ThrowHelper.ThrowSocketWriteError(_endpoint, status);
             }
         }
 
@@ -322,29 +322,29 @@ public void Write(IList<ArraySegment<byte>> buffers)
             for (int i = 0, C = buffers.Count; i < C; i++)
                 total += buffers[i].Count;
 
-            if (this.socket.Send(buffers, SocketFlags.None, out status) != total)
+            if (_socket.Send(buffers, SocketFlags.None, out status) != total)
                 System.Diagnostics.Debugger.Break();
 #else
             this.socket.Send(buffers, SocketFlags.None, out status);
 #endif
 
             if (status != SocketError.Success)
             {
-                this.isAlive = false;
+                _isAlive = false;
 
-                ThrowHelper.ThrowSocketWriteError(this.endpoint, status);
+                ThrowHelper.ThrowSocketWriteError(_endpoint, status);
             }
         }
 
         public async Task WriteSync(IList<ArraySegment<byte>> buffers)
         {
             try
             {
-                await socket.SendAsync(buffers, SocketFlags.None);
+                await _socket.SendAsync(buffers, SocketFlags.None);
             }
             catch (Exception ex)
             {
-                isAlive = false;
+                _isAlive = false;
                 _logger.LogError(ex, nameof(PooledSocket.WriteSync));
             }
         }
@@ -365,10 +365,10 @@ public bool ReceiveAsync(AsyncIOArgs p)
                 return false;
             }
 
-            if (this.helper == null)
-                this.helper = new AsyncSocketHelper(this);
+            if (_helper == null)
+                _helper = new AsyncSocketHelper(this);
 
-            return this.helper.Read(p);
+            return _helper.Read(p);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@ public bool Ping()`
`120`	`120`	`//could not reconnect`
`121`	`121`	`catch { return false; }`
`122`	`122`	`}`
`123`		`-`
	`123`	`+`
`124`	`124`	`/// <summary>`
`125`	`125`	`/// Acquires a new item from the pool`
`126`	`126`	`/// </summary>`
`@@ -275,7 +275,7 @@ internal InternalPoolImpl(`
`275`	`275`	`_logger = logger;`
`276`	`276`	`_isDebugEnabled = _logger.IsEnabled(LogLevel.Debug);`
`277`	`277`	`}`
`278`		`-`
	`278`	`+`
`279`	`279`	`internal void InitPool()`
`280`	`280`	`{`
`281`	`281`	`try`
`@@ -321,7 +321,7 @@ internal async Task InitPoolAsync()`
`321`	`321`	`}`
`322`	`322`
`323`	`323`	`if (_logger.IsEnabled(LogLevel.Debug))`
`324`		`- _logger.LogDebug("Pool has been inited for {0} with {1} sockets", this.endPoint, this.minItems);`
	`324`	`+ _logger.LogDebug("Pool has been inited for {0} with {1} sockets", _endPoint, this.minItems);`
`325`	`325`
`326`	`326`	`}`
`327`	`327`	`catch (Exception e)`
`@@ -356,7 +356,7 @@ public DateTime MarkedAsDeadUtc`
`356`	`356`	`{`
`357`	`357`	`get { return this.markedAsDeadUtc; }`
`358`	`358`	`}`
`359`		`-`
	`359`	`+`
`360`	`360`	`/// <summary>`
`361`	`361`	`/// Acquires a new item from the pool`
`362`	`362`	`/// </summary>`
`@@ -473,11 +473,11 @@ public async Task<IPooledSocketResult> AcquireAsync()`
`473`	`473`	`var result = new PooledSocketResult();`
`474`	`474`	`var message = string.Empty;`
`475`	`475`
`476`		`- if (_isDebugEnabled) _logger.LogDebug("Acquiring stream from pool. " + this.endPoint);`
	`476`	`+ if (_isDebugEnabled) _logger.LogDebug("Acquiring stream from pool. " + _endPoint);`
`477`	`477`
`478`	`478`	`if (!this.isAlive \|\| this.isDisposed)`
`479`	`479`	`{`
`480`		`- message = "Pool is dead or disposed, returning null. " + this.endPoint;`
	`480`	`+ message = "Pool is dead or disposed, returning null. " + _endPoint;`
`481`	`481`	`result.Fail(message);`
`482`	`482`
`483`	`483`	`if (_isDebugEnabled) _logger.LogDebug(message);`
`@@ -489,7 +489,7 @@ public async Task<IPooledSocketResult> AcquireAsync()`
`489`	`489`
`490`	`490`	`if (!await this.semaphore.WaitAsync(this.queueTimeout))`
`491`	`491`	`{`
`492`		`- message = "Pool is full, timeouting. " + this.endPoint;`
	`492`	`+ message = "Pool is full, timeouting. " + _endPoint;`
`493`	`493`	`if (_isDebugEnabled) _logger.LogDebug(message);`
`494`	`494`	`result.Fail(message, new TimeoutException());`
`495`	`495`
`@@ -500,7 +500,7 @@ public async Task<IPooledSocketResult> AcquireAsync()`
`500`	`500`	`// maybe we died while waiting`
`501`	`501`	`if (!this.isAlive)`
`502`	`502`	`{`
`503`		`- message = "Pool is dead, returning null. " + this.endPoint;`
	`503`	`+ message = "Pool is dead, returning null. " + _endPoint;`
`504`	`504`	`if (_isDebugEnabled) _logger.LogDebug(message);`
`505`	`505`	`result.Fail(message);`
`506`	`506`
`@@ -537,7 +537,7 @@ public async Task<IPooledSocketResult> AcquireAsync()`
`537`	`537`	`}`
`538`	`538`
`539`	`539`	`// free item pool is empty`
`540`		`- message = "Could not get a socket from the pool, Creating a new item. " + this.endPoint;`
	`540`	`+ message = "Could not get a socket from the pool, Creating a new item. " + _endPoint;`
`541`	`541`	`if (_isDebugEnabled) _logger.LogDebug(message);`
`542`	`542`
`543`	`543`
`@@ -552,7 +552,7 @@ public async Task<IPooledSocketResult> AcquireAsync()`
`552`	`552`	`}`
`553`	`553`	`catch (Exception e)`
`554`	`554`	`{`
`555`		`- message = "Failed to create socket. " + this.endPoint;`
	`555`	`+ message = "Failed to create socket. " + _endPoint;`
`556`	`556`	`_logger.LogError(message, e);`
`557`	`557`
`558`	`558`	`// eventhough this item failed the failure policy may keep the pool alive`
`@@ -702,22 +702,22 @@ protected internal virtual PooledSocket CreateSocket()`
`702`	`702`	`try`
`703`	`703`	`{`
`704`	`704`	`var ps = new PooledSocket(this.endPoint, this.config.ConnectionTimeout, this.config.ReceiveTimeout, _logger);`
`705`		`- ps.Connect();`
	`705`	`+ //ps.Connect();`
`706`	`706`	`return ps;`
`707`	`707`	`}`
`708`	`708`	`catch (Exception ex)`
`709`	`709`	`{`
`710`	`710`	`_logger.LogError(ex, $"Create {nameof(PooledSocket)}");`
`711`	`711`	`throw;`
`712`	`712`	`}`
`713`		`-`
	`713`	`+`
`714`	`714`	`}`
`715`	`715`	`protected internal virtual async Task<PooledSocket> CreateSocketAsync()`
`716`	`716`	`{`
`717`	`717`	`try`
`718`	`718`	`{`
`719`	`719`	`var ps = new PooledSocket(this.endPoint, this.config.ConnectionTimeout, this.config.ReceiveTimeout, _logger);`
`720`		`- await ps.ConnectAsync();`
	`720`	`+ //await ps.ConnectAsync();`
`721`	`721`	`return ps;`
`722`	`722`	`}`
`723`	`723`	`catch (Exception ex)`
Original file line number	Diff line number	Diff line change
`@@ -17,18 +17,18 @@ public partial class PooledSocket : IDisposable`
`17`	`17`	`{`
`18`	`18`	`private readonly ILogger _logger;`
`19`	`19`
`20`		`- private bool isAlive;`
`21`		`- private Socket socket;`
`22`		`- private EndPoint endpoint;`
	`20`	`+ private bool _isAlive;`
	`21`	`+ private Socket _socket;`
	`22`	`+ private EndPoint _endpoint;`
`23`	`23`
`24`		`- private Stream inputStream;`
`25`		`- private AsyncSocketHelper helper;`
	`24`	`+ private Stream _inputStream;`
	`25`	`+ private AsyncSocketHelper _helper;`
`26`	`26`
`27`	`27`	`public PooledSocket(EndPoint endpoint, TimeSpan connectionTimeout, TimeSpan receiveTimeout, ILogger logger)`
`28`	`28`	`{`
`29`	`29`	`_logger = logger;`
`30`	`30`
`31`		`- this.isAlive = true;`
	`31`	`+ _isAlive = true;`
`32`	`32`
`33`	`33`	`var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);`
`34`	`34`	`socket.NoDelay = true;`
`@@ -49,10 +49,10 @@ public PooledSocket(EndPoint endpoint, TimeSpan connectionTimeout, TimeSpan rece`
`49`	`49`	`throw new TimeoutException($"Could not connect to {endpoint}.");`
`50`	`50`	`}`
`51`	`51`
`52`		`- this.socket = socket;`
`53`		`- this.endpoint = endpoint;`
	`52`	`+ _socket = socket;`
	`53`	`+ _endpoint = endpoint;`
`54`	`54`
`55`		`- this.inputStream = new NetworkStream(socket);`
	`55`	`+ _inputStream = new NetworkStream(socket);`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`private bool ConnectWithTimeout(Socket socket, EndPoint endpoint, int timeout)`
`@@ -89,24 +89,24 @@ void Cancel()`
`89`	`89`
`90`	`90`	`public int Available`
`91`	`91`	`{`
`92`		`- get { return this.socket.Available; }`
	`92`	`+ get { return _socket.Available; }`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`public void Reset()`
`96`	`96`	`{`
`97`	`97`	`// discard any buffered data`
`98`		`- this.inputStream.Flush();`
	`98`	`+ _inputStream.Flush();`
`99`	`99`
`100`		`- if (this.helper != null) this.helper.DiscardBuffer();`
	`100`	`+ if (_helper != null) _helper.DiscardBuffer();`
`101`	`101`
`102`		`- int available = this.socket.Available;`
	`102`	`+ int available = _socket.Available;`
`103`	`103`
`104`	`104`	`if (available > 0)`
`105`	`105`	`{`
`106`	`106`	`if (_logger.IsEnabled(LogLevel.Warning))`
`107`	`107`	`_logger.LogWarning(`
`108`	`108`	`"Socket bound to {0} has {1} unread data! This is probably a bug in the code. InstanceID was {2}.",`
`109`		`- this.socket.RemoteEndPoint, available, this.InstanceId);`
	`109`	`+ _socket.RemoteEndPoint, available, this.InstanceId);`
`110`	`110`
`111`	`111`	`byte[] data = new byte[available];`
`112`	`112`
`@@ -127,7 +127,7 @@ public void Reset()`
`127`	`127`
`128`	`128`	`public bool IsAlive`
`129`	`129`	`{`
`130`		`- get { return this.isAlive; }`
	`130`	`+ get { return _isAlive; }`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`/// <summary>`
`@@ -158,20 +158,20 @@ protected void Dispose(bool disposing)`
`158`	`158`
`159`	`159`	`try`
`160`	`160`	`{`
`161`		`- if (socket != null)`
	`161`	`+ if (_socket != null)`
`162`	`162`	`try`
`163`	`163`	`{`
`164`		`- this.socket.Dispose();`
	`164`	`+ _socket.Dispose();`
`165`	`165`	`}`
`166`	`166`	`catch`
`167`	`167`	`{`
`168`	`168`	`}`
`169`	`169`
`170`		`- if (this.inputStream != null)`
`171`		`- this.inputStream.Dispose();`
	`170`	`+ if (_inputStream != null)`
	`171`	`+ _inputStream.Dispose();`
`172`	`172`
`173`		`- this.inputStream = null;`
`174`		`- this.socket = null;`
	`173`	`+ _inputStream = null;`
	`174`	`+ _socket = null;`
`175`	`175`	`this.CleanupCallback = null;`
`176`	`176`	`}`
`177`	`177`	`catch (Exception e)`
`@@ -195,7 +195,7 @@ void IDisposable.Dispose()`
`195`	`195`
`196`	`196`	`private void CheckDisposed()`
`197`	`197`	`{`
`198`		`- if (this.socket == null)`
	`198`	`+ if (_socket == null)`
`199`	`199`	`throw new ObjectDisposedException("PooledSocket");`
`200`	`200`	`}`
`201`	`201`
`@@ -209,11 +209,11 @@ public int ReadByte()`
`209`	`209`
`210`	`210`	`try`
`211`	`211`	`{`
`212`		`- return this.inputStream.ReadByte();`
	`212`	`+ return _inputStream.ReadByte();`
`213`	`213`	`}`
`214`	`214`	`catch (IOException)`
`215`	`215`	`{`
`216`		`- this.isAlive = false;`
	`216`	`+ _isAlive = false;`
`217`	`217`
`218`	`218`	`throw;`
`219`	`219`	`}`
`@@ -225,11 +225,11 @@ public int ReadByteAsync()`
`225`	`225`
`226`	`226`	`try`
`227`	`227`	`{`
`228`		`- return this.inputStream.ReadByte();`
	`228`	`+ return _inputStream.ReadByte();`
`229`	`229`	`}`
`230`	`230`	`catch (IOException)`
`231`	`231`	`{`
`232`		`- this.isAlive = false;`
	`232`	`+ _isAlive = false;`
`233`	`233`	`throw;`
`234`	`234`	`}`
`235`	`235`	`}`
`@@ -245,7 +245,7 @@ public async Task ReadAsync(byte[] buffer, int offset, int count)`
`245`	`245`	`{`
`246`	`246`	`try`
`247`	`247`	`{`
`248`		`- int currentRead = this.inputStream.Read(buffer, offset, shouldRead);`
	`248`	`+ int currentRead = _inputStream.Read(buffer, offset, shouldRead);`
`249`	`249`	`if (currentRead < 1)`
`250`	`250`	`continue;`
`251`	`251`
`@@ -255,7 +255,7 @@ public async Task ReadAsync(byte[] buffer, int offset, int count)`
`255`	`255`	`}`
`256`	`256`	`catch (IOException)`
`257`	`257`	`{`
`258`		`- this.isAlive = false;`
	`258`	`+ _isAlive = false;`
`259`	`259`	`throw;`
`260`	`260`	`}`
`261`	`261`	`}`
`@@ -279,7 +279,7 @@ public void Read(byte[] buffer, int offset, int count)`
`279`	`279`	`{`
`280`	`280`	`try`
`281`	`281`	`{`
`282`		`- int currentRead = this.inputStream.Read(buffer, offset, shouldRead);`
	`282`	`+ int currentRead = _inputStream.Read(buffer, offset, shouldRead);`
`283`	`283`	`if (currentRead < 1)`
`284`	`284`	`continue;`
`285`	`285`
`@@ -289,7 +289,7 @@ public void Read(byte[] buffer, int offset, int count)`
`289`	`289`	`}`
`290`	`290`	`catch (IOException)`
`291`	`291`	`{`
`292`		`- this.isAlive = false;`
	`292`	`+ _isAlive = false;`
`293`	`293`	`throw;`
`294`	`294`	`}`
`295`	`295`	`}`
`@@ -301,13 +301,13 @@ public void Write(byte[] data, int offset, int length)`
`301`	`301`
`302`	`302`	`SocketError status;`
`303`	`303`
`304`		`- this.socket.Send(data, offset, length, SocketFlags.None, out status);`
	`304`	`+ _socket.Send(data, offset, length, SocketFlags.None, out status);`
`305`	`305`
`306`	`306`	`if (status != SocketError.Success)`
`307`	`307`	`{`
`308`		`- this.isAlive = false;`
	`308`	`+ _isAlive = false;`
`309`	`309`
`310`		`- ThrowHelper.ThrowSocketWriteError(this.endpoint, status);`
	`310`	`+ ThrowHelper.ThrowSocketWriteError(_endpoint, status);`
`311`	`311`	`}`
`312`	`312`	`}`
`313`	`313`
`@@ -322,29 +322,29 @@ public void Write(IList<ArraySegment<byte>> buffers)`
`322`	`322`	`for (int i = 0, C = buffers.Count; i < C; i++)`
`323`	`323`	`total += buffers[i].Count;`
`324`	`324`
`325`		`- if (this.socket.Send(buffers, SocketFlags.None, out status) != total)`
	`325`	`+ if (_socket.Send(buffers, SocketFlags.None, out status) != total)`
`326`	`326`	`System.Diagnostics.Debugger.Break();`
`327`	`327`	`#else`
`328`	`328`	`this.socket.Send(buffers, SocketFlags.None, out status);`
`329`	`329`	`#endif`
`330`	`330`
`331`	`331`	`if (status != SocketError.Success)`
`332`	`332`	`{`
`333`		`- this.isAlive = false;`
	`333`	`+ _isAlive = false;`
`334`	`334`
`335`		`- ThrowHelper.ThrowSocketWriteError(this.endpoint, status);`
	`335`	`+ ThrowHelper.ThrowSocketWriteError(_endpoint, status);`
`336`	`336`	`}`
`337`	`337`	`}`
`338`	`338`
`339`	`339`	`public async Task WriteSync(IList<ArraySegment<byte>> buffers)`
`340`	`340`	`{`
`341`	`341`	`try`
`342`	`342`	`{`
`343`		`- await socket.SendAsync(buffers, SocketFlags.None);`
	`343`	`+ await _socket.SendAsync(buffers, SocketFlags.None);`
`344`	`344`	`}`
`345`	`345`	`catch (Exception ex)`
`346`	`346`	`{`
`347`		`- isAlive = false;`
	`347`	`+ _isAlive = false;`
`348`	`348`	`_logger.LogError(ex, nameof(PooledSocket.WriteSync));`
`349`	`349`	`}`
`350`	`350`	`}`
`@@ -365,10 +365,10 @@ public bool ReceiveAsync(AsyncIOArgs p)`
`365`	`365`	`return false;`
`366`	`366`	`}`
`367`	`367`
`368`		`- if (this.helper == null)`
`369`		`- this.helper = new AsyncSocketHelper(this);`
	`368`	`+ if (_helper == null)`
	`369`	`+ _helper = new AsyncSocketHelper(this);`
`370`	`370`
`371`		`- return this.helper.Read(p);`
	`371`	`+ return _helper.Read(p);`
`372`	`372`	`}`
`373`	`373`	`}`
`374`	`374`	`}`