Cleanup: ResultProcessor

StackExchange.Redis/StackExchange/Redis/ResultProcessor.cs

@@ -9,7 +9,7 @@
 
 namespace StackExchange.Redis
 {
-    abstract class ResultProcessor
+    internal abstract class ResultProcessor
     {
         public static readonly ResultProcessor<bool>
             Boolean = new BooleanProcessor(),
@@ -107,7 +107,7 @@ public static readonly TimeSpanProcessor
             TimeSpanFromSeconds = new TimeSpanProcessor(false);
         public static readonly HashEntryArrayProcessor
             HashEntryArray = new HashEntryArrayProcessor();
-        static readonly byte[] MOVED = Encoding.UTF8.GetBytes("MOVED "), ASK = Encoding.UTF8.GetBytes("ASK ");
+        private static readonly byte[] MOVED = Encoding.UTF8.GetBytes("MOVED "), ASK = Encoding.UTF8.GetBytes("ASK ");
 
         public void ConnectionFail(Message message, ConnectionFailureType fail, Exception innerException)
         {
@@ -137,8 +137,7 @@ public void SetException(Message message, Exception ex)
         // true if ready to be completed (i.e. false if re-issued to another server)
         public virtual bool SetResult(PhysicalConnection connection, Message message, RawResult result)
         {
-            var logging = message as LoggingMessage;
-            if (logging != null)
+            if (message is LoggingMessage logging)
             {
                 try
                 {
@@ -159,12 +158,10 @@ public virtual bool SetResult(PhysicalConnection connection, Message message, Ra
 
                     log = false;
                     string[] parts = result.GetString().Split(StringSplits.Space, 3);
-                    int hashSlot;
                     EndPoint endpoint;
-                    if (Format.TryParseInt32(parts[1], out hashSlot) &&
-                        (endpoint = Format.TryParseEndPoint(parts[2])) != null)
+                    if (Format.TryParseInt32(parts[1], out int hashSlot)
+                        && (endpoint = Format.TryParseEndPoint(parts[2])) != null)
                     {
-
                         // no point sending back to same server, and no point sending to a dead server
                         if (!Equals(server.EndPoint, endpoint))
                         {
@@ -217,6 +214,7 @@ public virtual bool SetResult(PhysicalConnection connection, Message message, Ra
             }
             return true;
         }
+
         protected abstract bool SetResultCore(PhysicalConnection connection, Message message, RawResult result);
 
         private void UnexpectedResponse(Message message, RawResult result)
@@ -232,6 +230,7 @@ public TimeSpanProcessor(bool isMilliseconds)
             {
                 this.isMilliseconds = isMilliseconds;
             }
+
             public bool TryParse(RawResult result, out TimeSpan? expiry)
             {
                 switch (result.Type)
@@ -259,10 +258,10 @@ public bool TryParse(RawResult result, out TimeSpan? expiry)
                 expiry = null;
                 return false;
             }
+
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
-                TimeSpan? expiry;
-                if (TryParse(result, out expiry))
+                if (TryParse(result, out TimeSpan? expiry))
                 {
                     SetResult(message, expiry);
                     return true;
@@ -277,6 +276,7 @@ public static TimerMessage CreateMessage(int db, CommandFlags flags, RedisComman
             {
                 return new TimerMessage(db, flags, command, value);
             }
+
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
                 if (result.Type == ResultType.Error)
@@ -286,9 +286,8 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                 else
                 {   // don't check the actual reply; there are multiple ways of constructing
                     // a timing message, and we don't actually care about what approach was used
-                    var timingMessage = message as TimerMessage;
                     TimeSpan duration;
-                    if (timingMessage != null)
+                    if (message is TimerMessage timingMessage)
                     {
                         var watch = timingMessage.Watch;
                         watch.Stop();
@@ -313,6 +312,7 @@ public TimerMessage(int db, CommandFlags flags, RedisCommand command, RedisValue
                     this.Watch = Stopwatch.StartNew();
                     this.value = value;
                 }
+
                 internal override void WriteImpl(PhysicalConnection physical)
                 {
                     if (value.IsNull)
@@ -335,8 +335,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                 if (result.Type == ResultType.MultiBulk)
                 {
                     var items = result.GetItems();
-                    long count;
-                    if (items.Length >= 3 && items[2].TryGetInt64(out count))
+                    if (items.Length >= 3 && items[2].TryGetInt64(out long count))
                     {
                         connection.SubscriptionCount = count;
                         return true;
@@ -345,9 +344,10 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                 return false;
             }
         }
+
         internal sealed class DemandZeroOrOneProcessor : ResultProcessor<bool>
         {
-            static readonly byte[] zero = { (byte)'0' }, one = { (byte)'1' };
+            private static readonly byte[] zero = { (byte)'0' }, one = { (byte)'1' };
 
             public static bool TryGet(RawResult result, out bool value)
             {
@@ -363,10 +363,10 @@ public static bool TryGet(RawResult result, out bool value)
                 value = false;
                 return false;
             }
+
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
-                bool value;
-                if (TryGet(result, out value))
+                if (TryGet(result, out bool value))
                 {
                     SetResult(message, value);
                     return true;
@@ -377,15 +377,16 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
 
         internal sealed class ScriptLoadProcessor : ResultProcessor<byte[]>
         {
-            static readonly Regex sha1 = new Regex("^[0-9a-f]{40}$", RegexOptions.Compiled | RegexOptions.IgnoreCase);
+            private static readonly Regex sha1 = new Regex("^[0-9a-f]{40}$", RegexOptions.Compiled | RegexOptions.IgnoreCase);
 
             internal static bool IsSHA1(string script)
             {
                 return script != null && sha1.IsMatch(script);
             }
+
             internal static byte[] ParseSHA1(byte[] value)
             {
-                if (value != null && value.Length == 40)
+                if (value?.Length == 40)
                 {
                     var tmp = new byte[20];
                     int charIndex = 0;
@@ -399,9 +400,10 @@ internal static byte[] ParseSHA1(byte[] value)
                 }
                 return null;
             }
+
             internal static byte[] ParseSHA1(string value)
             {
-                if (value != null && value.Length == 40 && sha1.IsMatch(value))
+                if (value?.Length == 40 && sha1.IsMatch(value))
                 {
                     var tmp = new byte[20];
                     int charIndex = 0;
@@ -415,6 +417,7 @@ internal static byte[] ParseSHA1(string value)
                 }
                 return null;
             }
+
             private static int FromHex(char c)
             {
                 if (c >= '0' && c <= '9') return c - '0';
@@ -453,8 +456,7 @@ internal sealed class SortedSetEntryArrayProcessor : ValuePairInterleavedProcess
         {
             protected override SortedSetEntry Parse(RawResult first, RawResult second)
             {
-                double val;
-                return new SortedSetEntry(first.AsRedisValue(), second.TryGetDouble(out val) ? val : double.NaN);
+                return new SortedSetEntry(first.AsRedisValue(), second.TryGetDouble(out double val) ? val : double.NaN);
             }
         }
 
@@ -468,7 +470,7 @@ protected override HashEntry Parse(RawResult first, RawResult second)
 
         internal abstract class ValuePairInterleavedProcessorBase<T> : ResultProcessor<T[]>
         {
-            static readonly T[] nix = new T[0];
+            private static readonly T[] nix = new T[0];
 
             public bool TryParse(RawResult result, out T[] pairs)
             {
@@ -503,11 +505,11 @@ public bool TryParse(RawResult result, out T[] pairs)
                         return false;
                 }
             }
+
             protected abstract T Parse(RawResult first, RawResult second);
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
-                T[] arr;
-                if (TryParse(result, out arr))
+                if (TryParse(result, out T[] arr))
                 {
                     SetResult(message, arr);
                     return true;
@@ -516,9 +518,9 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
             }
         }
 
-        sealed class AutoConfigureProcessor : ResultProcessor<bool>
+        private sealed class AutoConfigureProcessor : ResultProcessor<bool>
         {
-            static readonly byte[] READONLY = Encoding.UTF8.GetBytes("READONLY ");
+            private static readonly byte[] READONLY = Encoding.UTF8.GetBytes("READONLY ");
             public override bool SetResult(PhysicalConnection connection, Message message, RawResult result)
             {
                 if (result.IsError && result.AssertStarts(READONLY))
@@ -529,13 +531,14 @@ public override bool SetResult(PhysicalConnection connection, Message message, R
                 }
                 return base.SetResult(connection, message, result);
             }
+
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
                 var server = connection.Bridge.ServerEndPoint;
                 switch (result.Type)
                 {
                     case ResultType.BulkString:
-                        if (message != null && message.Command == RedisCommand.INFO)
+                        if (message?.Command == RedisCommand.INFO)
                         {
                             string info = result.GetString(), line;
                             if (string.IsNullOrWhiteSpace(info))
@@ -577,8 +580,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                                     }
                                     else if ((val = Extract(line, "redis_version:")) != null)
                                     {
-                                        Version version;
-                                        if (Version.TryParse(val, out version))
+                                        if (Version.TryParse(val, out Version version))
                                         {
                                             server.Version = version;
                                             server.Multiplexer.Trace("Auto-configured version: " + version);
@@ -616,7 +618,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                         SetResult(message, true);
                         return true;
                     case ResultType.MultiBulk:
-                        if (message != null && message.Command == RedisCommand.CONFIG)
+                        if (message?.Command == RedisCommand.CONFIG)
                         {
                             var arr = result.GetItems();
                             int count = arr.Length / 2;
@@ -627,11 +629,10 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                                 yes = (byte[])RedisLiterals.yes,
                                 no = (byte[])RedisLiterals.no;
 
-                            long i64;
                             for (int i = 0; i < count; i++)
                             {
                                 var key = arr[i * 2];
-                                if (key.IsEqual(timeout) && arr[(i * 2) + 1].TryGetInt64(out i64))
+                                if (key.IsEqual(timeout) && arr[(i * 2) + 1].TryGetInt64(out long i64))
                                 {
                                     // note the configuration is in seconds
                                     int timeoutSeconds = checked((int)i64), targetSeconds;
@@ -668,7 +669,6 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                                         server.SlaveReadOnly = false;
                                         server.Multiplexer.Trace("Auto-configured slave-read-only: false");
                                     }
-
                                 }
                             }
                         }
@@ -678,13 +678,14 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                 return false;
             }
 
-            static string Extract(string line, string prefix)
+            private static string Extract(string line, string prefix)
             {
                 if (line.StartsWith(prefix)) return line.Substring(prefix.Length).Trim();
                 return null;
             }
         }
-        sealed class BooleanProcessor : ResultProcessor<bool>
+
+        private sealed class BooleanProcessor : ResultProcessor<bool>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
@@ -722,7 +723,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
             }
         }
 
-        sealed class ByteArrayProcessor : ResultProcessor<byte[]>
+        private sealed class ByteArrayProcessor : ResultProcessor<byte[]>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
@@ -736,7 +737,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
             }
         }
 
-        sealed class ClusterNodesProcessor : ResultProcessor<ClusterConfiguration>
+        private sealed class ClusterNodesProcessor : ResultProcessor<ClusterConfiguration>
         {
             internal static ClusterConfiguration Parse(PhysicalConnection connection, string nodes)
             {
@@ -761,7 +762,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
             }
         }
 
-        sealed class ClusterNodesRawProcessor : ResultProcessor<string>
+        private sealed class ClusterNodesRawProcessor : ResultProcessor<string>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
@@ -791,11 +792,11 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
             }
         }
 
-        sealed class DateTimeProcessor : ResultProcessor<DateTime>
+        private sealed class DateTimeProcessor : ResultProcessor<DateTime>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
-                long unixTime, micros;
+                long unixTime;
                 switch (result.Type)
                 {
                     case ResultType.Integer:
@@ -819,7 +820,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                                 }
                                 break;
                             case 2:
-                                if (arr[0].TryGetInt64(out unixTime) && arr[1].TryGetInt64(out micros))
+                                if (arr[0].TryGetInt64(out unixTime) && arr[1].TryGetInt64(out long micros))
                                 {
                                     var time = RedisBase.UnixEpoch.AddSeconds(unixTime).AddTicks(micros * 10); // datetime ticks are 100ns
                                     SetResult(message, time);
@@ -833,7 +834,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
             }
         }
 
-        sealed class DoubleProcessor : ResultProcessor<double>
+        private sealed class DoubleProcessor : ResultProcessor<double>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
@@ -860,17 +861,20 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                 return false;
             }
         }
-        sealed class ExpectBasicStringProcessor : ResultProcessor<bool>
+
+        private sealed class ExpectBasicStringProcessor : ResultProcessor<bool>
         {
             private readonly byte[] expected;
             public ExpectBasicStringProcessor(string value)
             {
                 expected = Encoding.UTF8.GetBytes(value);
             }
+
             public ExpectBasicStringProcessor(byte[] value)
             {
                 expected = value;
             }
+
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
                 if (result.IsEqual(expected))
@@ -882,7 +886,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
             }
         }
 
-        sealed class InfoProcessor : ResultProcessor<IGrouping<string, KeyValuePair<string, string>>[]>
+        private sealed class InfoProcessor : ResultProcessor<IGrouping<string, KeyValuePair<string, string>>[]>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
@@ -915,13 +919,13 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                 return false;
             }
 
-            static string Normalize(string category)
+            private static string Normalize(string category)
             {
                 return string.IsNullOrWhiteSpace(category) ? "miscellaneous" : category.Trim();
             }
         }
 
-        class Int64Processor : ResultProcessor<long>
+        private class Int64Processor : ResultProcessor<long>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
@@ -941,15 +945,15 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                 return false;
             }
         }
-        class PubSubNumSubProcessor : Int64Processor
+
+        private class PubSubNumSubProcessor : Int64Processor
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
                 if (result.Type == ResultType.MultiBulk)
                 {
                     var arr = result.GetItems();
-                    long val;
-                    if (arr != null && arr.Length == 2 && arr[1].TryGetInt64(out val))
+                    if (arr?.Length == 2 && arr[1].TryGetInt64(out long val))
                     {
                         SetResult(message, val);
                         return true;
@@ -959,7 +963,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
             }
         }
 
-        sealed class NullableDoubleProcessor : ResultProcessor<double?>
+        private sealed class NullableDoubleProcessor : ResultProcessor<double?>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
@@ -984,7 +988,8 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                 return false;
             }
         }
-        sealed class NullableInt64Processor : ResultProcessor<long?>
+
+        private sealed class NullableInt64Processor : ResultProcessor<long?>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
@@ -1010,13 +1015,14 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
             }
         }
 
-        sealed class RedisChannelArrayProcessor : ResultProcessor<RedisChannel[]>
+        private sealed class RedisChannelArrayProcessor : ResultProcessor<RedisChannel[]>
         {
             private readonly RedisChannel.PatternMode mode;
             public RedisChannelArrayProcessor(RedisChannel.PatternMode mode)
             {
                 this.mode = mode;
             }
+
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
                 switch (result.Type)
@@ -1044,7 +1050,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
             }
         }
 
-        sealed class RedisKeyArrayProcessor : ResultProcessor<RedisKey[]>
+        private sealed class RedisKeyArrayProcessor : ResultProcessor<RedisKey[]>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
@@ -1059,7 +1065,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
             }
         }
 
-        sealed class RedisKeyProcessor : ResultProcessor<RedisKey>
+        private sealed class RedisKeyProcessor : ResultProcessor<RedisKey>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
@@ -1075,7 +1081,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
             }
         }
 
-        sealed class RedisTypeProcessor : ResultProcessor<RedisType>
+        private sealed class RedisTypeProcessor : ResultProcessor<RedisType>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
@@ -1094,7 +1100,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
             }
         }
 
-        sealed class RedisValueArrayProcessor : ResultProcessor<RedisValue[]>
+        private sealed class RedisValueArrayProcessor : ResultProcessor<RedisValue[]>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
@@ -1109,7 +1115,8 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                 return false;
             }
         }
-        sealed class StringArrayProcessor : ResultProcessor<string[]>
+
+        private sealed class StringArrayProcessor : ResultProcessor<string[]>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
@@ -1125,7 +1132,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
             }
         }
 
-        sealed class RedisValueGeoPositionProcessor : ResultProcessor<GeoPosition?>
+        private sealed class RedisValueGeoPositionProcessor : ResultProcessor<GeoPosition?>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
@@ -1140,7 +1147,8 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                 return false;
             }
         }
-        sealed class RedisValueGeoPositionArrayProcessor : ResultProcessor<GeoPosition?[]>
+
+        private sealed class RedisValueGeoPositionArrayProcessor : ResultProcessor<GeoPosition?[]>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
@@ -1156,7 +1164,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
             }
         }
 
-        sealed class GeoRadiusResultArrayProcessor : ResultProcessor<GeoRadiusResult[]>
+        private sealed class GeoRadiusResultArrayProcessor : ResultProcessor<GeoRadiusResult[]>
         {
             private static readonly GeoRadiusResultArrayProcessor[] instances;
             private readonly GeoRadiusOptions options;
@@ -1166,6 +1174,7 @@ static GeoRadiusResultArrayProcessor()
                 instances = new GeoRadiusResultArrayProcessor[8];
                 for (int i = 0; i < 8; i++) instances[i] = new GeoRadiusResultArrayProcessor((GeoRadiusOptions)i);
             }
+
             public static GeoRadiusResultArrayProcessor Get(GeoRadiusOptions options)
             {
                 int i = (int)options;
@@ -1177,6 +1186,7 @@ private GeoRadiusResultArrayProcessor(GeoRadiusOptions options)
             {
                 this.options = options;
             }
+
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
                 switch (result.Type)
@@ -1238,7 +1248,7 @@ private static GeoRadiusResult Parse(GeoRadiusOptions options, RawResult item)
             }
         }
 
-        sealed class RedisValueProcessor : ResultProcessor<RedisValue>
+        private sealed class RedisValueProcessor : ResultProcessor<RedisValue>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
@@ -1253,9 +1263,10 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                 return false;
             }
         }
+
         private class ScriptResultProcessor : ResultProcessor<RedisResult>
         {
-            static readonly byte[] NOSCRIPT = Encoding.UTF8.GetBytes("NOSCRIPT ");
+            private static readonly byte[] NOSCRIPT = Encoding.UTF8.GetBytes("NOSCRIPT ");
             public override bool SetResult(PhysicalConnection connection, Message message, RawResult result)
             {
                 if (result.Type == ResultType.Error && result.AssertStarts(NOSCRIPT))
@@ -1281,7 +1292,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
             }
         }
 
-        sealed class StringPairInterleavedProcessor : ValuePairInterleavedProcessorBase<KeyValuePair<string, string>>
+        private sealed class StringPairInterleavedProcessor : ValuePairInterleavedProcessorBase<KeyValuePair<string, string>>
         {
             protected override KeyValuePair<string, string> Parse(RawResult first, RawResult second)
             {
@@ -1289,7 +1300,7 @@ sealed class StringPairInterleavedProcessor : ValuePairInterleavedProcessorBase<
             }
         }
 
-        sealed class StringProcessor : ResultProcessor<string>
+        private sealed class StringProcessor : ResultProcessor<string>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
@@ -1312,9 +1323,10 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                 return false;
             }
         }
+
         private class TracerProcessor : ResultProcessor<bool>
         {
-            static readonly byte[]
+            private static readonly byte[]
                 authRequired = Encoding.UTF8.GetBytes("NOAUTH Authentication required."),
                 authFail = Encoding.UTF8.GetBytes("ERR operation not permitted"),
                 loading = Encoding.UTF8.GetBytes("LOADING ");
@@ -1325,6 +1337,7 @@ public TracerProcessor(bool establishConnection)
             {
                 this.establishConnection = establishConnection;
             }
+
             public override bool SetResult(PhysicalConnection connection, Message message, RawResult result)
             {
                 var final = base.SetResult(connection, message, result);
@@ -1383,7 +1396,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
 
         #region Sentinel
 
-        sealed class SentinelGetMasterAddressByNameProcessor : ResultProcessor<EndPoint>
+        private sealed class SentinelGetMasterAddressByNameProcessor : ResultProcessor<EndPoint>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
@@ -1414,7 +1427,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
             }
         }
 
-        sealed class SentinelArrayOfArraysProcessor : ResultProcessor<KeyValuePair<string, string>[][]>
+        private sealed class SentinelArrayOfArraysProcessor : ResultProcessor<KeyValuePair<string, string>[][]>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
@@ -1434,8 +1447,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                         for (int i = 0; i < arrayOfArrays.Length; i++)
                         {
                             var rawInnerArray = arrayOfArrays[i];
-                            KeyValuePair<string, string>[] kvpArray;
-                            innerProcessor.TryParse(rawInnerArray, out kvpArray);
+                            innerProcessor.TryParse(rawInnerArray, out KeyValuePair<string, string>[] kvpArray);
                             returnArray[i] = kvpArray;
                         }
 
@@ -1448,9 +1460,9 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
 
         #endregion
     }
+
     internal abstract class ResultProcessor<T> : ResultProcessor
     {
-
         protected void SetResult(Message message, T value)
         {
             if (message == null) return;