Docs: Global cleanup

.editorconfig

@@ -89,5 +89,8 @@ csharp_space_after_keywords_in_control_flow_statements = true:suggestion
 # Language settings
 csharp_prefer_simple_default_expression = false:none
 
+# RCS1194: Implement exception constructors.
+dotnet_diagnostic.RCS1194.severity = none
+
 # RCS1229: Use async/await when necessary.
 dotnet_diagnostic.RCS1229.severity = none

docs/Configuration.md

@@ -165,10 +165,10 @@ The above is equivalent to (in the connection string):
 $INFO=,$SELECT=use
 ```
 
-Twemproxy
+twemproxy
 ---
 
-[Twemproxy](https://github.com/twitter/twemproxy) is a tool that allows multiple redis instances to be used as though it were a single server, with inbuilt sharding and fault tolerance (much like redis cluster, but implemented separately). The feature-set available to Twemproxy is reduced. To avoid having to configure this manually, the `Proxy` option can be used:
+[twemproxy](https://github.com/twitter/twemproxy) is a tool that allows multiple redis instances to be used as though it were a single server, with inbuilt sharding and fault tolerance (much like redis cluster, but implemented separately). The feature-set available to Twemproxy is reduced. To avoid having to configure this manually, the `Proxy` option can be used:
 
 ```csharp
 var options = new ConfigurationOptions

docs/Timeouts.md

@@ -71,13 +71,15 @@ How to configure this setting:
 
 > **Important Note:** the value specified in this configuration element is a *per-core* setting.  For example, if you have a 4 core machine and want your minIOThreads setting to be 200 at runtime, you would use `<processModel minIoThreads="50"/>`.
 
- - Outside of ASP.NET, use the [ThreadPool.SetMinThreads(…)](https://docs.microsoft.com/en-us/dotnet/api/system.threading.threadpool.setminthreads?view=netcore-2.0#System_Threading_ThreadPool_SetMinThreads_System_Int32_System_Int32_) API.
-
-- In .Net Core, add Environment Variable COMPlus_ThreadPool_ForceMinWorkerThreads to overwrite default MinThreads setting, according to [Environment/Registry Configuration Knobs](https://github.com/dotnet/coreclr/blob/master/Documentation/project-docs/clr-configuration-knobs.md) - You can also use the same ThreadPool.SetMinThreads() Method as described above.
+ - Outside of ASP.NET, use one of the methods described in [Run-time configuration options for threading
+](https://docs.microsoft.com/dotnet/core/run-time-config/threading#minimum-threads):
+   - [ThreadPool.SetMinThreads(…)](https://docs.microsoft.com/dotnet/api/system.threading.threadpool.setminthreads)
+   - The `ThreadPoolMinThreads` MSBuild property
+   - The `System.Threading.ThreadPool.MinThreads` setting in your `runtimeconfig.json`
 
 Explanation for abbreviations appearing in exception messages
 ---
-By default Redis Timeout exception(s) includes useful information, which can help in uderstanding & diagnosing the timeouts. Some of the abbrivations are as follows:
+By default Redis Timeout exception(s) includes useful information, which can help in understanding & diagnosing the timeouts. Some of the abbreviations are as follows:
 
 | Abbreviation   | Long Name | Meaning |
 | ------------- | ---------------------- | ---------------------------- | 

src/StackExchange.Redis/AssemblyInfoHack.cs

@@ -1,4 +1,4 @@
-// Yes, this is embarassing. However, in .NET Core the including AssemblyInfo (ifdef'd or not) will screw with
+// Yes, this is embarrassing. However, in .NET Core the including AssemblyInfo (ifdef'd or not) will screw with
 // your version numbers. Therefore, we need to move the attribute out into another file...this file.
 // When .csproj merges in, this should be able to return to Properties/AssemblyInfo.cs
 using System;

src/StackExchange.Redis/BacklogPolicy.cs

@@ -31,7 +31,7 @@ public sealed class BacklogPolicy
         /// <summary>
         /// Whether to queue commands while disconnected.
         /// True means queue for attempts up until their timeout.
-        /// False means to fail ASAP and queue nothing.
+        /// <see langword="false"/> means to fail ASAP and queue nothing.
         /// </summary>
         public bool QueueWhileDisconnected { get; init; }
 

src/StackExchange.Redis/BufferReader.cs

@@ -10,6 +10,7 @@ internal enum ConsumeResult
         Success,
         NeedMoreData,
     }
+
     internal ref struct BufferReader
     {
         private long _totalConsumed;
@@ -209,6 +210,7 @@ public int ConsumeByte()
             Consume(1);
             return value;
         }
+
         public int PeekByte() => IsEmpty ? -1 : _current[OffsetThisSpan];
 
         public ReadOnlySequence<byte> SliceFromCurrent()

src/StackExchange.Redis/ChannelMessageQueue.cs

@@ -7,25 +7,22 @@
 namespace StackExchange.Redis
 {
     /// <summary>
-    /// Represents a message that is broadcast via pub/sub
+    /// Represents a message that is broadcast via publish/subscribe.
     /// </summary>
     public readonly struct ChannelMessage
     {
-        private readonly ChannelMessageQueue _queue; // this is *smaller* than storing a RedisChannel for the subscribed channel
+        // this is *smaller* than storing a RedisChannel for the subscribed channel
+        private readonly ChannelMessageQueue _queue;
+
         /// <summary>
-        /// See Object.ToString
+        /// The Channel:Message string representation.
         /// </summary>
         public override string ToString() => ((string)Channel) + ":" + ((string)Message);
 
-        /// <summary>
-        /// See Object.GetHashCode
-        /// </summary>
+        /// <inheritdoc/>
         public override int GetHashCode() => Channel.GetHashCode() ^ Message.GetHashCode();
 
-        /// <summary>
-        /// See Object.Equals
-        /// </summary>
-        /// <param name="obj">The <see cref="object"/> to compare.</param>
+        /// <inheritdoc/>
         public override bool Equals(object obj) => obj is ChannelMessage cm
             && cm.Channel == Channel && cm.Message == Message;
         internal ChannelMessage(ChannelMessageQueue queue, in RedisChannel channel, in RedisValue value)
@@ -36,16 +33,17 @@ internal ChannelMessage(ChannelMessageQueue queue, in RedisChannel channel, in R
         }
 
         /// <summary>
-        /// The channel that the subscription was created from
+        /// The channel that the subscription was created from.
         /// </summary>
         public RedisChannel SubscriptionChannel => _queue.Channel;
 
         /// <summary>
-        /// The channel that the message was broadcast to
+        /// The channel that the message was broadcast to.
         /// </summary>
         public RedisChannel Channel { get; }
+
         /// <summary>
-        /// The value that was broadcast
+        /// The value that was broadcast.
         /// </summary>
         public RedisValue Message { get; }
 
@@ -61,25 +59,28 @@ internal ChannelMessage(ChannelMessageQueue queue, in RedisChannel channel, in R
     }
 
     /// <summary>
-    /// Represents a message queue of ordered pub/sub notifications
+    /// Represents a message queue of ordered pub/sub notifications.
     /// </summary>
-    /// <remarks>To create a ChannelMessageQueue, use ISubscriber.Subscribe[Async](RedisKey)</remarks>
+    /// <remarks>
+    /// To create a ChannelMessageQueue, use <see cref="ISubscriber.Subscribe(RedisChannel, CommandFlags)"/>
+    /// or <see cref="ISubscriber.SubscribeAsync(RedisChannel, CommandFlags)"/>.
+    /// </remarks>
     public sealed class ChannelMessageQueue
     {
         private readonly Channel<ChannelMessage> _queue;
         /// <summary>
-        /// The Channel that was subscribed for this queue
+        /// The Channel that was subscribed for this queue.
         /// </summary>
         public RedisChannel Channel { get; }
         private RedisSubscriber _parent;
 
         /// <summary>
-        /// See Object.ToString
+        /// The string representation of this channel.
         /// </summary>
         public override string ToString() => (string)Channel;
 
         /// <summary>
-        /// An awaitable task the indicates completion of the queue (including drain of data)
+        /// An awaitable task the indicates completion of the queue (including drain of data).
         /// </summary>
         public Task Completion => _queue.Reader.Completion;
 
@@ -97,9 +98,7 @@ internal ChannelMessageQueue(in RedisChannel redisChannel, RedisSubscriber paren
             AllowSynchronousContinuations = false,
         };
 
-#pragma warning disable RCS1231 // Make parameter ref read-only. - uses as a delegate for Action<RedisChannel, RedisValue>
         private void Write(in RedisChannel channel, in RedisValue value)
-#pragma warning restore RCS1231 // Make parameter ref read-only.
         {
             var writer = _queue.Writer;
             writer.TryWrite(new ChannelMessage(this, channel, value));

src/StackExchange.Redis/ClientInfo.cs

@@ -5,106 +5,160 @@
 namespace StackExchange.Redis
 {
     /// <summary>
-    /// Represents the state of an individual client connection to redis
+    /// Represents the state of an individual client connection to redis.
     /// </summary>
     public sealed class ClientInfo
     {
         internal static readonly ResultProcessor<ClientInfo[]> Processor = new ClientInfoProcessor();
 
         /// <summary>
-        /// Address (host and port) of the client
+        /// Address (host and port) of the client.
         /// </summary>
         public EndPoint Address { get; private set; }
 
         /// <summary>
-        /// total duration of the connection in seconds
+        /// Total duration of the connection in seconds.
         /// </summary>
         public int AgeSeconds { get; private set; }
 
         /// <summary>
-        /// current database ID
+        /// Current database ID.
         /// </summary>
         public int Database { get; private set; }
 
         /// <summary>
-        /// The flags associated with this connection
+        /// The flags associated with this connection.
         /// </summary>
         public ClientFlags Flags { get; private set; }
 
         /// <summary>
         /// The client flags can be a combination of:
-        ///
-        /// A: connection to be closed ASAP
-        /// b: the client is waiting in a blocking operation
-        /// c: connection to be closed after writing entire reply
-        /// d: a watched keys has been modified - EXEC will fail
-        /// i: the client is waiting for a VM I/O (deprecated)
-        /// M: the client is a master
-        /// N: no specific flag set
-        /// O: the client is a replica in MONITOR mode
-        /// P: the client is a Pub/Sub subscriber
-        /// r: the client is in readonly mode against a cluster node
-        /// S: the client is a normal replica server
-        /// U: the client is connected via a Unix domain socket
-        /// x: the client is in a MULTI/EXEC context
-        /// t: the client enabled keys tracking in order to perform client side caching
-        /// R: the client tracking target client is invalid
-        /// B: the client enabled broadcast tracking mode
+        /// <list type="table">
+        ///     <item>
+        ///         <term>A</term>
+        ///         <description>Connection to be closed ASAP.</description>
+        ///     </item>
+        ///     <item>
+        ///         <term>b</term>
+        ///         <description>The client is waiting in a blocking operation.</description>
+        ///     </item>
+        ///     <item>
+        ///         <term>c</term>
+        ///         <description>Connection to be closed after writing entire reply.</description>
+        ///     </item>
+        ///     <item>
+        ///         <term>d</term>
+        ///         <description>A watched keys has been modified - EXEC will fail.</description>
+        ///     </item>
+        ///     <item>
+        ///         <term>i</term>
+        ///         <description>The client is waiting for a VM I/O (deprecated).</description>
+        ///     </item>
+        ///     <item>
+        ///         <term>M</term>
+        ///         <description>The client is a primary.</description>
+        ///     </item>
+        ///     <item>
+        ///         <term>N</term>
+        ///         <description>No specific flag set.</description>
+        ///     </item>
+        ///     <item>
+        ///         <term>O</term>
+        ///         <description>The client is a replica in MONITOR mode.</description>
+        ///     </item>
+        ///     <item>
+        ///         <term>P</term>
+        ///         <description>The client is a Pub/Sub subscriber.</description>
+        ///     </item>
+        ///     <item>
+        ///         <term>r</term>
+        ///         <description>The client is in readonly mode against a cluster node.</description>
+        ///     </item>
+        ///     <item>
+        ///         <term>S</term>
+        ///         <description>The client is a normal replica server.</description>
+        ///     </item>
+        ///     <item>
+        ///         <term>u</term>
+        ///         <description>The client is unblocked.</description>
+        ///     </item>
+        ///     <item>
+        ///         <term>U</term>
+        ///         <description>The client is unblocked.</description>
+        ///     </item>
+        ///     <item>
+        ///         <term>x</term>
+        ///         <description>The client is in a MULTI/EXEC context.</description>
+        ///     </item>
+        ///     <item>
+        ///         <term>t</term>
+        ///         <description>The client enabled keys tracking in order to perform client side caching.</description>
+        ///     </item>
+        ///     <item>
+        ///         <term>R</term>
+        ///         <description>The client tracking target client is invalid.</description>
+        ///     </item>
+        ///     <item>
+        ///         <term>B</term>
+        ///         <description>The client enabled broadcast tracking mode.</description>
+        ///     </item>
+        /// </list>
         /// </summary>
+        /// <remarks>https://redis.io/commands/client-list</remarks>
         public string FlagsRaw { get; private set; }
 
         /// <summary>
-        /// The host of the client (typically an IP address)
+        /// The host of the client (typically an IP address).
         /// </summary>
         public string Host => Format.TryGetHostPort(Address, out string host, out _) ? host : null;
 
         /// <summary>
-        /// idle time of the connection in seconds
+        /// Idle time of the connection in seconds.
         /// </summary>
         public int IdleSeconds { get; private set; }
 
         /// <summary>
-        ///  last command played
+        /// Last command played.
         /// </summary>
         public string LastCommand { get; private set; }
 
         /// <summary>
-        /// The name allocated to this connection, if any
+        /// The name allocated to this connection, if any.
         /// </summary>
         public string Name { get; private set; }
 
         /// <summary>
-        /// number of pattern matching subscriptions
+        /// Number of pattern matching subscriptions.
         /// </summary>
         public int PatternSubscriptionCount { get; private set; }
 
         /// <summary>
-        /// The port of the client
+        /// The port of the client.
         /// </summary>
         public int Port => Format.TryGetHostPort(Address, out _, out int port) ? port : 0;
 
         /// <summary>
-        /// The raw content from redis
+        /// The raw content from redis.
         /// </summary>
         public string Raw { get; private set; }
 
         /// <summary>
-        /// number of channel subscriptions
+        /// Number of channel subscriptions.
         /// </summary>
         public int SubscriptionCount { get; private set; }
 
         /// <summary>
-        /// number of commands in a MULTI/EXEC context
+        /// Number of commands in a MULTI/EXEC context.
         /// </summary>
         public int TransactionCommandLength { get; private set; }
 
         /// <summary>
-        /// an unique 64-bit client ID (introduced in Redis 2.8.12).
+        /// A unique 64-bit client ID (introduced in Redis 2.8.12).
         /// </summary>
         public long Id { get;private set; }
 
         /// <summary>
-        /// Format the object as a string
+        /// Format the object as a string.
         /// </summary>
         public override string ToString()
         {
@@ -113,7 +167,7 @@ public override string ToString()
         }
 
         /// <summary>
-        /// The class of the connection
+        /// The class of the connection.
         /// </summary>
         public ClientType ClientType
         {