Auto-props cleanup

NickCraver · NickCraver · commit e11171dc7416 · 2018-03-21T20:35:20.000-04:00
diff --git a/StackExchange.Redis/StackExchange/Redis/ConnectionMultiplexer.cs b/StackExchange.Redis/StackExchange/Redis/ConnectionMultiplexer.cs
@@ -45,7 +45,7 @@ public ServerCounters GetCounters()
             {
                 counters.Add(snapshot[i].GetCounters());
             }
-            unprocessableCompletionManager.GetCounters(counters.Other);
+            UnprocessableCompletionManager.GetCounters(counters.Other);
             return counters;
         }
 
@@ -123,7 +123,7 @@ internal void OnConnectionFailed(EndPoint endpoint, ConnectionType connectionTyp
             var handler = ConnectionFailed;
             if (handler != null)
             {
-                unprocessableCompletionManager.CompleteSyncOrAsync(
+                UnprocessableCompletionManager.CompleteSyncOrAsync(
                     new ConnectionFailedEventArgs(handler, this, endpoint, connectionType, failureType, exception)
                 );
             }
@@ -142,7 +142,7 @@ internal void OnInternalError(Exception exception, EndPoint endpoint = null, Con
                 var handler = InternalError;
                 if (handler != null)
                 {
-                    unprocessableCompletionManager.CompleteSyncOrAsync(
+                    UnprocessableCompletionManager.CompleteSyncOrAsync(
                         new InternalErrorEventArgs(handler, this, endpoint, connectionType, exception, origin)
                     );
                 }
@@ -158,7 +158,7 @@ internal void OnConnectionRestored(EndPoint endpoint, ConnectionType connectionT
             var handler = ConnectionRestored;
             if (handler != null)
             {
-                unprocessableCompletionManager.CompleteSyncOrAsync(
+                UnprocessableCompletionManager.CompleteSyncOrAsync(
                     new ConnectionFailedEventArgs(handler, this, endpoint, connectionType, ConnectionFailureType.None, null)
                 );
             }
@@ -170,7 +170,7 @@ private void OnEndpointChanged(EndPoint endpoint, EventHandler<EndPointEventArgs
             if (isDisposed) return;
             if (handler != null)
             {
-                unprocessableCompletionManager.CompleteSyncOrAsync(
+                UnprocessableCompletionManager.CompleteSyncOrAsync(
                     new EndPointEventArgs(handler, this, endpoint)
                 );
             }
@@ -189,7 +189,7 @@ internal void OnErrorMessage(EndPoint endpoint, string message)
             var handler = ErrorMessage;
             if (handler != null)
             {
-                unprocessableCompletionManager.CompleteSyncOrAsync(
+                UnprocessableCompletionManager.CompleteSyncOrAsync(
                     new RedisErrorEventArgs(handler, this, endpoint, message)
                 );
             }
@@ -481,7 +481,7 @@ private static void WriteNormalizingLineEndings(string source, StreamWriter writ
         /// <summary>
         /// Gets the timeout associated with the connections
         /// </summary>
-        public int TimeoutMilliseconds => timeoutMilliseconds;
+        public int TimeoutMilliseconds { get; }
 
         /// <summary>
         /// Gets all endpoints defined on the server
@@ -494,13 +494,11 @@ public EndPoint[] GetEndPoints(bool configuredOnly = false)
             return ConvertHelper.ConvertAll(serverSnapshot, x => x.EndPoint);
         }
 
-        private readonly int timeoutMilliseconds;
-
         private readonly ConfigurationOptions configuration;
 
         internal bool TryResend(int hashSlot, Message message, EndPoint endpoint, bool isMoved)
         {
-            return serverSelectionStrategy.TryResend(hashSlot, message, endpoint, isMoved);
+            return ServerSelectionStrategy.TryResend(hashSlot, message, endpoint, isMoved);
         }
 
         /// <summary>
@@ -510,7 +508,7 @@ internal bool TryResend(int hashSlot, Message message, EndPoint endpoint, bool i
         public void Wait(Task task)
         {
             if (task == null) throw new ArgumentNullException(nameof(task));
-            if (!task.Wait(timeoutMilliseconds)) throw new TimeoutException();
+            if (!task.Wait(TimeoutMilliseconds)) throw new TimeoutException();
         }
 
         /// <summary>
@@ -521,7 +519,7 @@ public void Wait(Task task)
         public T Wait<T>(Task<T> task)
         {
             if (task == null) throw new ArgumentNullException(nameof(task));
-            if (!task.Wait(timeoutMilliseconds)) throw new TimeoutException();
+            if (!task.Wait(TimeoutMilliseconds)) throw new TimeoutException();
             return task.Result;
         }
 
@@ -533,10 +531,10 @@ public void WaitAll(params Task[] tasks)
         {
             if (tasks == null) throw new ArgumentNullException(nameof(tasks));
             if (tasks.Length == 0) return;
-            if (!Task.WaitAll(tasks, timeoutMilliseconds)) throw new TimeoutException();
+            if (!Task.WaitAll(tasks, TimeoutMilliseconds)) throw new TimeoutException();
         }
 
-        private bool WaitAllIgnoreErrors(Task[] tasks) => WaitAllIgnoreErrors(tasks, timeoutMilliseconds);
+        private bool WaitAllIgnoreErrors(Task[] tasks) => WaitAllIgnoreErrors(tasks, TimeoutMilliseconds);
 
         private static bool WaitAllIgnoreErrors(Task[] tasks, int timeout)
         {
@@ -677,7 +675,7 @@ internal void OnHashSlotMoved(int hashSlot, EndPoint old, EndPoint @new)
             var handler = HashSlotMoved;
             if (handler != null)
             {
-                unprocessableCompletionManager.CompleteSyncOrAsync(
+                UnprocessableCompletionManager.CompleteSyncOrAsync(
                     new HashSlotMovedEventArgs(handler, this, hashSlot, old, @new)
                 );
             }
@@ -687,7 +685,7 @@ internal void OnHashSlotMoved(int hashSlot, EndPoint old, EndPoint @new)
         /// Compute the hash-slot of a specified key
         /// </summary>
         /// <param name="key">The key to get a hash slot ID for.</param>
-        public int HashSlot(RedisKey key) => serverSelectionStrategy.HashSlot(key);
+        public int HashSlot(RedisKey key) => ServerSelectionStrategy.HashSlot(key);
 
         internal ServerEndPoint AnyConnected(ServerType serverType, uint startOffset, RedisCommand command, CommandFlags flags)
         {
@@ -910,11 +908,11 @@ private ConnectionMultiplexer(ConfigurationOptions configuration)
             }
 
             PreserveAsyncOrder = configuration.PreserveAsyncOrder;
-            timeoutMilliseconds = configuration.SyncTimeout;
+            TimeoutMilliseconds = configuration.SyncTimeout;
 
             OnCreateReaderWriter(configuration);
-            unprocessableCompletionManager = new CompletionManager(this, "multiplexer");
-            serverSelectionStrategy = new ServerSelectionStrategy(this);
+            UnprocessableCompletionManager = new CompletionManager(this, "multiplexer");
+            ServerSelectionStrategy = new ServerSelectionStrategy(this);
 
             var configChannel = configuration.ConfigurationChannel;
             if (!string.IsNullOrWhiteSpace(configChannel))
@@ -975,7 +973,7 @@ internal long LastHeartbeatSecondsAgo
 
         internal static long LastGlobalHeartbeatSecondsAgo => unchecked(Environment.TickCount - VolatileWrapper.Read(ref lastGlobalHeartbeatTicks)) / 1000;
 
-        internal CompletionManager UnprocessableCompletionManager => unprocessableCompletionManager;
+        internal CompletionManager UnprocessableCompletionManager { get; }
 
         /// <summary>
         /// Obtain a pub/sub subscriber connection to the specified server
@@ -1086,8 +1084,6 @@ internal static void TraceWithoutContext(bool condition, string message, [Caller
             if (condition) OnTraceWithoutContext(message, category);
         }
 
-        private readonly CompletionManager unprocessableCompletionManager;
-
         /// <summary>
         /// The number of operations that have been performed on all connections
         /// </summary>
@@ -1234,7 +1230,7 @@ internal async Task<bool> ReconfigureAsync(bool first, bool reconfigureAll, Text
                     if (configuration.ResolveDns && configuration.HasDnsEndPoints())
                     {
                         var dns = configuration.ResolveEndPointsAsync(this, log).ObserveErrors();
-                        if ((await Task.WhenAny(dns, Task.Delay(timeoutMilliseconds)).ForAwait()) != dns)
+                        if ((await Task.WhenAny(dns, Task.Delay(TimeoutMilliseconds)).ForAwait()) != dns)
                         {
                             throw new TimeoutException("Timeout resolving endpoints");
                         }
@@ -1443,15 +1439,15 @@ internal async Task<bool> ReconfigureAsync(bool first, bool reconfigureAll, Text
                         // set the serverSelectionStrategy
                         if (RawConfig.Proxy == Proxy.Twemproxy)
                         {
-                            serverSelectionStrategy.ServerType = ServerType.Twemproxy;
+                            ServerSelectionStrategy.ServerType = ServerType.Twemproxy;
                         }
                         else if (standaloneCount == 0 && sentinelCount > 0)
                         {
-                            serverSelectionStrategy.ServerType = ServerType.Sentinel;
+                            ServerSelectionStrategy.ServerType = ServerType.Sentinel;
                         }
                         else
                         {
-                            serverSelectionStrategy.ServerType = ServerType.Standalone;
+                            ServerSelectionStrategy.ServerType = ServerType.Standalone;
                         }
                         var preferred = await NominatePreferredMaster(log, servers, useTieBreakers, tieBreakers, masters).ObserveErrors().ForAwait();
                         foreach (var master in masters)
@@ -1468,10 +1464,10 @@ internal async Task<bool> ReconfigureAsync(bool first, bool reconfigureAll, Text
                     }
                     else
                     {
-                        serverSelectionStrategy.ServerType = ServerType.Cluster;
-                        long coveredSlots = serverSelectionStrategy.CountCoveredSlots();
+                        ServerSelectionStrategy.ServerType = ServerType.Cluster;
+                        long coveredSlots = ServerSelectionStrategy.CountCoveredSlots();
                         LogLocked(log, "Cluster: {0} of {1} slots covered",
-                            coveredSlots, serverSelectionStrategy.TotalSlots);
+                            coveredSlots, ServerSelectionStrategy.TotalSlots);
                     }
                     if (!first)
                     {
@@ -1724,15 +1720,13 @@ internal void UpdateClusterRange(ClusterConfiguration configuration)
                 foreach (var slot in node.Slots)
                 {
                     var server = GetServerEndPoint(node.EndPoint);
-                    if (server != null) serverSelectionStrategy.UpdateClusterRange(slot.From, slot.To, server);
+                    if (server != null) ServerSelectionStrategy.UpdateClusterRange(slot.From, slot.To, server);
                 }
             }
         }
 
         private Timer pulse;
 
-        private readonly ServerSelectionStrategy serverSelectionStrategy;
-
         internal ServerEndPoint[] GetServerSnapshot()
         {
             var tmp = serverSnapshot;
@@ -1742,12 +1736,12 @@ internal ServerEndPoint[] GetServerSnapshot()
         internal ServerEndPoint SelectServer(Message message)
         {
             if (message == null) return null;
-            return serverSelectionStrategy.Select(message);
+            return ServerSelectionStrategy.Select(message);
         }
 
         internal ServerEndPoint SelectServer(int db, RedisCommand command, CommandFlags flags, RedisKey key)
         {
-            return serverSelectionStrategy.Select(db, command, key, flags);
+            return ServerSelectionStrategy.Select(db, command, key, flags);
         }
 
         private bool TryPushMessageToBridge<T>(Message message, ResultProcessor<T> processor, ResultBox<T> resultBox, ref ServerEndPoint server)
@@ -1855,7 +1849,7 @@ public bool IsConnecting
 
         internal ConfigurationOptions RawConfig => configuration;
 
-        internal ServerSelectionStrategy ServerSelectionStrategy => serverSelectionStrategy;
+        internal ServerSelectionStrategy ServerSelectionStrategy { get; }
 
         /// <summary>
         /// Close all connections and release all resources associated with this object
@@ -2005,7 +1999,7 @@ internal T ExecuteSyncImpl<T>(Message message, ResultProcessor<T> processor, Ser
                         throw ExceptionFactory.NoConnectionAvailable(IncludeDetailInExceptions, IncludePerformanceCountersInExceptions, message.Command, message, server, GetServerSnapshot());
                     }
 
-                    if (Monitor.Wait(source, timeoutMilliseconds))
+                    if (Monitor.Wait(source, TimeoutMilliseconds))
                     {
                         Trace("Timeley response to " + message);
                     }
diff --git a/StackExchange.Redis/StackExchange/Redis/RedisSubscriber.cs b/StackExchange.Redis/StackExchange/Redis/RedisSubscriber.cs
@@ -1,4 +1,4 @@
-using System;
+﻿using System;
 using System.Collections.Generic;
 using System.Net;
 using System.Threading;
@@ -74,7 +74,7 @@ internal void OnMessage(RedisChannel subscription, RedisChannel channel, RedisVa
                     completable = sub.ForInvoke(channel, payload);
                 }
             }
-            if (completable != null) unprocessableCompletionManager.CompleteSyncOrAsync(completable);
+            if (completable != null) UnprocessableCompletionManager.CompleteSyncOrAsync(completable);
         }
 
         internal Task RemoveAllSubscriptions(CommandFlags flags, object asyncState)
@@ -322,4 +322,4 @@ public Task UnsubscribeAsync(RedisChannel channel, Action<RedisChannel, RedisVal
             return multiplexer.RemoveSubscription(channel, handler, flags, asyncState);
         }
     }
-}
+}
diff --git a/StackExchange.Redis/StackExchange/Redis/ServerEndPoint.cs b/StackExchange.Redis/StackExchange/Redis/ServerEndPoint.cs

Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ public ServerCounters GetCounters()`
`45`	`45`	`{`
`46`	`46`	`counters.Add(snapshot[i].GetCounters());`
`47`	`47`	`}`
`48`		`- unprocessableCompletionManager.GetCounters(counters.Other);`
	`48`	`+ UnprocessableCompletionManager.GetCounters(counters.Other);`
`49`	`49`	`return counters;`
`50`	`50`	`}`
`51`	`51`
`@@ -123,7 +123,7 @@ internal void OnConnectionFailed(EndPoint endpoint, ConnectionType connectionTyp`
`123`	`123`	`var handler = ConnectionFailed;`
`124`	`124`	`if (handler != null)`
`125`	`125`	`{`
`126`		`- unprocessableCompletionManager.CompleteSyncOrAsync(`
	`126`	`+ UnprocessableCompletionManager.CompleteSyncOrAsync(`
`127`	`127`	`new ConnectionFailedEventArgs(handler, this, endpoint, connectionType, failureType, exception)`
`128`	`128`	`);`
`129`	`129`	`}`
`@@ -142,7 +142,7 @@ internal void OnInternalError(Exception exception, EndPoint endpoint = null, Con`
`142`	`142`	`var handler = InternalError;`
`143`	`143`	`if (handler != null)`
`144`	`144`	`{`
`145`		`- unprocessableCompletionManager.CompleteSyncOrAsync(`
	`145`	`+ UnprocessableCompletionManager.CompleteSyncOrAsync(`
`146`	`146`	`new InternalErrorEventArgs(handler, this, endpoint, connectionType, exception, origin)`
`147`	`147`	`);`
`148`	`148`	`}`
`@@ -158,7 +158,7 @@ internal void OnConnectionRestored(EndPoint endpoint, ConnectionType connectionT`
`158`	`158`	`var handler = ConnectionRestored;`
`159`	`159`	`if (handler != null)`
`160`	`160`	`{`
`161`		`- unprocessableCompletionManager.CompleteSyncOrAsync(`
	`161`	`+ UnprocessableCompletionManager.CompleteSyncOrAsync(`
`162`	`162`	`new ConnectionFailedEventArgs(handler, this, endpoint, connectionType, ConnectionFailureType.None, null)`
`163`	`163`	`);`
`164`	`164`	`}`
`@@ -170,7 +170,7 @@ private void OnEndpointChanged(EndPoint endpoint, EventHandler<EndPointEventArgs`
`170`	`170`	`if (isDisposed) return;`
`171`	`171`	`if (handler != null)`
`172`	`172`	`{`
`173`		`- unprocessableCompletionManager.CompleteSyncOrAsync(`
	`173`	`+ UnprocessableCompletionManager.CompleteSyncOrAsync(`
`174`	`174`	`new EndPointEventArgs(handler, this, endpoint)`
`175`	`175`	`);`
`176`	`176`	`}`
`@@ -189,7 +189,7 @@ internal void OnErrorMessage(EndPoint endpoint, string message)`
`189`	`189`	`var handler = ErrorMessage;`
`190`	`190`	`if (handler != null)`
`191`	`191`	`{`
`192`		`- unprocessableCompletionManager.CompleteSyncOrAsync(`
	`192`	`+ UnprocessableCompletionManager.CompleteSyncOrAsync(`
`193`	`193`	`new RedisErrorEventArgs(handler, this, endpoint, message)`
`194`	`194`	`);`
`195`	`195`	`}`
`@@ -481,7 +481,7 @@ private static void WriteNormalizingLineEndings(string source, StreamWriter writ`
`481`	`481`	`/// <summary>`
`482`	`482`	`/// Gets the timeout associated with the connections`
`483`	`483`	`/// </summary>`
`484`		`- public int TimeoutMilliseconds => timeoutMilliseconds;`
	`484`	`+ public int TimeoutMilliseconds { get; }`
`485`	`485`
`486`	`486`	`/// <summary>`
`487`	`487`	`/// Gets all endpoints defined on the server`
`@@ -494,13 +494,11 @@ public EndPoint[] GetEndPoints(bool configuredOnly = false)`
`494`	`494`	`return ConvertHelper.ConvertAll(serverSnapshot, x => x.EndPoint);`
`495`	`495`	`}`
`496`	`496`
`497`		`- private readonly int timeoutMilliseconds;`
`498`		`-`
`499`	`497`	`private readonly ConfigurationOptions configuration;`
`500`	`498`
`501`	`499`	`internal bool TryResend(int hashSlot, Message message, EndPoint endpoint, bool isMoved)`
`502`	`500`	`{`
`503`		`- return serverSelectionStrategy.TryResend(hashSlot, message, endpoint, isMoved);`
	`501`	`+ return ServerSelectionStrategy.TryResend(hashSlot, message, endpoint, isMoved);`
`504`	`502`	`}`
`505`	`503`
`506`	`504`	`/// <summary>`
`@@ -510,7 +508,7 @@ internal bool TryResend(int hashSlot, Message message, EndPoint endpoint, bool i`
`510`	`508`	`public void Wait(Task task)`
`511`	`509`	`{`
`512`	`510`	`if (task == null) throw new ArgumentNullException(nameof(task));`
`513`		`- if (!task.Wait(timeoutMilliseconds)) throw new TimeoutException();`
	`511`	`+ if (!task.Wait(TimeoutMilliseconds)) throw new TimeoutException();`
`514`	`512`	`}`
`515`	`513`
`516`	`514`	`/// <summary>`
`@@ -521,7 +519,7 @@ public void Wait(Task task)`
`521`	`519`	`public T Wait<T>(Task<T> task)`
`522`	`520`	`{`
`523`	`521`	`if (task == null) throw new ArgumentNullException(nameof(task));`
`524`		`- if (!task.Wait(timeoutMilliseconds)) throw new TimeoutException();`
	`522`	`+ if (!task.Wait(TimeoutMilliseconds)) throw new TimeoutException();`
`525`	`523`	`return task.Result;`
`526`	`524`	`}`
`527`	`525`
`@@ -533,10 +531,10 @@ public void WaitAll(params Task[] tasks)`
`533`	`531`	`{`
`534`	`532`	`if (tasks == null) throw new ArgumentNullException(nameof(tasks));`
`535`	`533`	`if (tasks.Length == 0) return;`
`536`		`- if (!Task.WaitAll(tasks, timeoutMilliseconds)) throw new TimeoutException();`
	`534`	`+ if (!Task.WaitAll(tasks, TimeoutMilliseconds)) throw new TimeoutException();`
`537`	`535`	`}`
`538`	`536`
`539`		`- private bool WaitAllIgnoreErrors(Task[] tasks) => WaitAllIgnoreErrors(tasks, timeoutMilliseconds);`
	`537`	`+ private bool WaitAllIgnoreErrors(Task[] tasks) => WaitAllIgnoreErrors(tasks, TimeoutMilliseconds);`
`540`	`538`
`541`	`539`	`private static bool WaitAllIgnoreErrors(Task[] tasks, int timeout)`
`542`	`540`	`{`
`@@ -677,7 +675,7 @@ internal void OnHashSlotMoved(int hashSlot, EndPoint old, EndPoint @new)`
`677`	`675`	`var handler = HashSlotMoved;`
`678`	`676`	`if (handler != null)`
`679`	`677`	`{`
`680`		`- unprocessableCompletionManager.CompleteSyncOrAsync(`
	`678`	`+ UnprocessableCompletionManager.CompleteSyncOrAsync(`
`681`	`679`	`new HashSlotMovedEventArgs(handler, this, hashSlot, old, @new)`
`682`	`680`	`);`
`683`	`681`	`}`
`@@ -687,7 +685,7 @@ internal void OnHashSlotMoved(int hashSlot, EndPoint old, EndPoint @new)`
`687`	`685`	`/// Compute the hash-slot of a specified key`
`688`	`686`	`/// </summary>`
`689`	`687`	`/// <param name="key">The key to get a hash slot ID for.</param>`
`690`		`- public int HashSlot(RedisKey key) => serverSelectionStrategy.HashSlot(key);`
	`688`	`+ public int HashSlot(RedisKey key) => ServerSelectionStrategy.HashSlot(key);`
`691`	`689`
`692`	`690`	`internal ServerEndPoint AnyConnected(ServerType serverType, uint startOffset, RedisCommand command, CommandFlags flags)`
`693`	`691`	`{`
`@@ -910,11 +908,11 @@ private ConnectionMultiplexer(ConfigurationOptions configuration)`
`910`	`908`	`}`
`911`	`909`
`912`	`910`	`PreserveAsyncOrder = configuration.PreserveAsyncOrder;`
`913`		`- timeoutMilliseconds = configuration.SyncTimeout;`
	`911`	`+ TimeoutMilliseconds = configuration.SyncTimeout;`
`914`	`912`
`915`	`913`	`OnCreateReaderWriter(configuration);`
`916`		`- unprocessableCompletionManager = new CompletionManager(this, "multiplexer");`
`917`		`- serverSelectionStrategy = new ServerSelectionStrategy(this);`
	`914`	`+ UnprocessableCompletionManager = new CompletionManager(this, "multiplexer");`
	`915`	`+ ServerSelectionStrategy = new ServerSelectionStrategy(this);`
`918`	`916`
`919`	`917`	`var configChannel = configuration.ConfigurationChannel;`
`920`	`918`	`if (!string.IsNullOrWhiteSpace(configChannel))`
`@@ -975,7 +973,7 @@ internal long LastHeartbeatSecondsAgo`
`975`	`973`
`976`	`974`	`internal static long LastGlobalHeartbeatSecondsAgo => unchecked(Environment.TickCount - VolatileWrapper.Read(ref lastGlobalHeartbeatTicks)) / 1000;`
`977`	`975`
`978`		`- internal CompletionManager UnprocessableCompletionManager => unprocessableCompletionManager;`
	`976`	`+ internal CompletionManager UnprocessableCompletionManager { get; }`
`979`	`977`
`980`	`978`	`/// <summary>`
`981`	`979`	`/// Obtain a pub/sub subscriber connection to the specified server`
`@@ -1086,8 +1084,6 @@ internal static void TraceWithoutContext(bool condition, string message, [Caller`
`1086`	`1084`	`if (condition) OnTraceWithoutContext(message, category);`
`1087`	`1085`	`}`
`1088`	`1086`
`1089`		`- private readonly CompletionManager unprocessableCompletionManager;`
`1090`		`-`
`1091`	`1087`	`/// <summary>`
`1092`	`1088`	`/// The number of operations that have been performed on all connections`
`1093`	`1089`	`/// </summary>`
`@@ -1234,7 +1230,7 @@ internal async Task<bool> ReconfigureAsync(bool first, bool reconfigureAll, Text`
`1234`	`1230`	`if (configuration.ResolveDns && configuration.HasDnsEndPoints())`
`1235`	`1231`	`{`
`1236`	`1232`	`var dns = configuration.ResolveEndPointsAsync(this, log).ObserveErrors();`
`1237`		`- if ((await Task.WhenAny(dns, Task.Delay(timeoutMilliseconds)).ForAwait()) != dns)`
	`1233`	`+ if ((await Task.WhenAny(dns, Task.Delay(TimeoutMilliseconds)).ForAwait()) != dns)`
`1238`	`1234`	`{`
`1239`	`1235`	`throw new TimeoutException("Timeout resolving endpoints");`
`1240`	`1236`	`}`
`@@ -1443,15 +1439,15 @@ internal async Task<bool> ReconfigureAsync(bool first, bool reconfigureAll, Text`
`1443`	`1439`	`// set the serverSelectionStrategy`
`1444`	`1440`	`if (RawConfig.Proxy == Proxy.Twemproxy)`
`1445`	`1441`	`{`
`1446`		`- serverSelectionStrategy.ServerType = ServerType.Twemproxy;`
	`1442`	`+ ServerSelectionStrategy.ServerType = ServerType.Twemproxy;`
`1447`	`1443`	`}`
`1448`	`1444`	`else if (standaloneCount == 0 && sentinelCount > 0)`
`1449`	`1445`	`{`
`1450`		`- serverSelectionStrategy.ServerType = ServerType.Sentinel;`
	`1446`	`+ ServerSelectionStrategy.ServerType = ServerType.Sentinel;`
`1451`	`1447`	`}`
`1452`	`1448`	`else`
`1453`	`1449`	`{`
`1454`		`- serverSelectionStrategy.ServerType = ServerType.Standalone;`
	`1450`	`+ ServerSelectionStrategy.ServerType = ServerType.Standalone;`
`1455`	`1451`	`}`
`1456`	`1452`	`var preferred = await NominatePreferredMaster(log, servers, useTieBreakers, tieBreakers, masters).ObserveErrors().ForAwait();`
`1457`	`1453`	`foreach (var master in masters)`
`@@ -1468,10 +1464,10 @@ internal async Task<bool> ReconfigureAsync(bool first, bool reconfigureAll, Text`
`1468`	`1464`	`}`
`1469`	`1465`	`else`
`1470`	`1466`	`{`
`1471`		`- serverSelectionStrategy.ServerType = ServerType.Cluster;`
`1472`		`- long coveredSlots = serverSelectionStrategy.CountCoveredSlots();`
	`1467`	`+ ServerSelectionStrategy.ServerType = ServerType.Cluster;`
	`1468`	`+ long coveredSlots = ServerSelectionStrategy.CountCoveredSlots();`
`1473`	`1469`	`LogLocked(log, "Cluster: {0} of {1} slots covered",`
`1474`		`- coveredSlots, serverSelectionStrategy.TotalSlots);`
	`1470`	`+ coveredSlots, ServerSelectionStrategy.TotalSlots);`
`1475`	`1471`	`}`
`1476`	`1472`	`if (!first)`
`1477`	`1473`	`{`
`@@ -1724,15 +1720,13 @@ internal void UpdateClusterRange(ClusterConfiguration configuration)`
`1724`	`1720`	`foreach (var slot in node.Slots)`
`1725`	`1721`	`{`
`1726`	`1722`	`var server = GetServerEndPoint(node.EndPoint);`
`1727`		`- if (server != null) serverSelectionStrategy.UpdateClusterRange(slot.From, slot.To, server);`
	`1723`	`+ if (server != null) ServerSelectionStrategy.UpdateClusterRange(slot.From, slot.To, server);`
`1728`	`1724`	`}`
`1729`	`1725`	`}`
`1730`	`1726`	`}`
`1731`	`1727`
`1732`	`1728`	`private Timer pulse;`
`1733`	`1729`
`1734`		`- private readonly ServerSelectionStrategy serverSelectionStrategy;`
`1735`		`-`
`1736`	`1730`	`internal ServerEndPoint[] GetServerSnapshot()`
`1737`	`1731`	`{`
`1738`	`1732`	`var tmp = serverSnapshot;`
`@@ -1742,12 +1736,12 @@ internal ServerEndPoint[] GetServerSnapshot()`
`1742`	`1736`	`internal ServerEndPoint SelectServer(Message message)`
`1743`	`1737`	`{`
`1744`	`1738`	`if (message == null) return null;`
`1745`		`- return serverSelectionStrategy.Select(message);`
	`1739`	`+ return ServerSelectionStrategy.Select(message);`
`1746`	`1740`	`}`
`1747`	`1741`
`1748`	`1742`	`internal ServerEndPoint SelectServer(int db, RedisCommand command, CommandFlags flags, RedisKey key)`
`1749`	`1743`	`{`
`1750`		`- return serverSelectionStrategy.Select(db, command, key, flags);`
	`1744`	`+ return ServerSelectionStrategy.Select(db, command, key, flags);`
`1751`	`1745`	`}`
`1752`	`1746`
`1753`	`1747`	`private bool TryPushMessageToBridge<T>(Message message, ResultProcessor<T> processor, ResultBox<T> resultBox, ref ServerEndPoint server)`
`@@ -1855,7 +1849,7 @@ public bool IsConnecting`
`1855`	`1849`
`1856`	`1850`	`internal ConfigurationOptions RawConfig => configuration;`
`1857`	`1851`
`1858`		`- internal ServerSelectionStrategy ServerSelectionStrategy => serverSelectionStrategy;`
	`1852`	`+ internal ServerSelectionStrategy ServerSelectionStrategy { get; }`
`1859`	`1853`
`1860`	`1854`	`/// <summary>`
`1861`	`1855`	`/// Close all connections and release all resources associated with this object`
`@@ -2005,7 +1999,7 @@ internal T ExecuteSyncImpl<T>(Message message, ResultProcessor<T> processor, Ser`
`2005`	`1999`	`throw ExceptionFactory.NoConnectionAvailable(IncludeDetailInExceptions, IncludePerformanceCountersInExceptions, message.Command, message, server, GetServerSnapshot());`
`2006`	`2000`	`}`
`2007`	`2001`
`2008`		`- if (Monitor.Wait(source, timeoutMilliseconds))`
	`2002`	`+ if (Monitor.Wait(source, TimeoutMilliseconds))`
`2009`	`2003`	`{`
`2010`	`2004`	`Trace("Timeley response to " + message);`
`2011`	`2005`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-using System;`
	`1`	`+using System;`
`2`	`2`	`using System.Collections.Generic;`
`3`	`3`	`using System.Net;`
`4`	`4`	`using System.Threading;`
`@@ -74,7 +74,7 @@ internal void OnMessage(RedisChannel subscription, RedisChannel channel, RedisVa`
`74`	`74`	`completable = sub.ForInvoke(channel, payload);`
`75`	`75`	`}`
`76`	`76`	`}`
`77`		`- if (completable != null) unprocessableCompletionManager.CompleteSyncOrAsync(completable);`
	`77`	`+ if (completable != null) UnprocessableCompletionManager.CompleteSyncOrAsync(completable);`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`internal Task RemoveAllSubscriptions(CommandFlags flags, object asyncState)`
`@@ -322,4 +322,4 @@ public Task UnsubscribeAsync(RedisChannel channel, Action<RedisChannel, RedisVal`
`322`	`322`	`return multiplexer.RemoveSubscription(channel, handler, flags, asyncState);`
`323`	`323`	`}`
`324`	`324`	`}`
`325`		`-}`
	`325`	`+}`