(#14) Perform solution-wide code cleanup

X10D/src/ByteExtensions/SByteExtensions.cs

@@ -60,13 +60,13 @@ namespace X10D
         /// <code lang="csharp">
         /// byte[] bytes = { byte.MinValue, 100, 200, byte.MaxValue };
         /// bool result;
-        ///
+        /// 
         /// foreach (byte value in bytes)
         /// {
         ///     result = value.ToBoolean();
         ///     Console.WriteLine("{0, -5}  -->  {1}", value, result);
         /// }
-        ///
+        /// 
         /// // The example displays the following output:
         /// //       0      -->  False
         /// //       100    -->  True

X10D/src/ComparableExtensions/ComparableExtensions.cs

@@ -18,8 +18,8 @@ namespace X10D
         /// <param name="lower">The exclusive lower bound.</param>
         /// <param name="upper">The exclusive upper bound.</param>
         /// <returns>
-        ///     <see langword="true" /> if <paramref name="value" /> is between the <paramref name="lower"/> and
+        ///     <see langword="true" /> if <paramref name="value" /> is between the <paramref name="lower" /> and
-        ///     <paramref name="upper"/>
+        ///     <paramref name="upper" />
         ///     -or-
         ///     <see langword="false" /> otherwise.
         /// </returns>
@@ -30,13 +30,13 @@ namespace X10D
         /// 
         /// int lower = 0;
         /// int upper = 20;
-        ///
+        /// 
         /// Console.WriteLine($"{firstValue} between {lower} and {upper}?");
         /// Console.WriteLine(firstValue.Between(lower, upper));
         /// 
         /// Console.WriteLine($"{secondValue} between {lower} and {upper}?");
         /// Console.WriteLine(secondValue.Between(lower, upper));
-        ///
+        /// 
         /// // This will output the following:
         /// //      42 between 0 and 20?
         /// //      False
@@ -84,7 +84,7 @@ namespace X10D
         /// int value = 42;
         /// int lower = 0;
         /// int upper = 20;
-        ///
+        /// 
         /// int clamped = value.Clamp(lower, upper);
         /// // clamped will be 20
         /// </code>
@@ -112,13 +112,13 @@ namespace X10D
         /// <returns>
         ///     <see langword="true" /> if <paramref name="value" /> is greater than <paramref name="other" />
         ///     -or-
-        ///     <see langword="false"/> otherwise.
+        ///     <see langword="false" /> otherwise.
         /// </returns>
         /// <example>
         /// <code lang="csharp">
         /// int first = 5;
         /// int second = 10;
-        ///
+        /// 
         /// bool result = first.GreaterThan(second);
         /// // result will be False
         /// </code>
@@ -144,13 +144,13 @@ namespace X10D
         /// <returns>
         ///     <see langword="true" /> if <paramref name="value" /> is greater than or equal to <paramref name="other" />
         ///     -or-
-        ///     <see langword="false"/> otherwise.
+        ///     <see langword="false" /> otherwise.
         /// </returns>
         /// <example>
         /// <code lang="csharp">
         /// int first = 5;
         /// int second = 10;
-        ///
+        /// 
         /// bool result = first.GreaterThanOrEqualTo(second);
         /// // result will be False
         /// </code>
@@ -176,13 +176,13 @@ namespace X10D
         /// <returns>
         ///     <see langword="true" /> if <paramref name="value" /> is less than <paramref name="other" />
         ///     -or-
-        ///     <see langword="false"/> otherwise.
+        ///     <see langword="false" /> otherwise.
         /// </returns>
         /// <example>
         /// <code lang="csharp">
         /// int first = 5;
         /// int second = 10;
-        ///
+        /// 
         /// bool result = first.LessThan(second);
         /// // result will be True
         /// </code>
@@ -208,13 +208,13 @@ namespace X10D
         /// <returns>
         ///     <see langword="true" /> if <paramref name="value" /> is less than or equal to <paramref name="other" />
         ///     -or-
-        ///     <see langword="false"/> otherwise.
+        ///     <see langword="false" /> otherwise.
         /// </returns>
         /// <example>
         /// <code lang="csharp">
         /// int first = 5;
         /// int second = 10;
-        ///
+        /// 
         /// bool result = first.LessThanOrEqualTo(second);
         /// // result will be True
         /// </code>
@@ -245,7 +245,7 @@ namespace X10D
         /// <code lang="csharp">
         /// int first = 5;
         /// int second = 10;
-        ///
+        /// 
         /// int max = first.Max(second);
         /// // max will be 10
         /// </code>
@@ -276,7 +276,7 @@ namespace X10D
         /// <code lang="csharp">
         /// int first = 5;
         /// int second = 10;
-        ///
+        /// 
         /// int min = first.Min(second);
         /// // min will be 5
         /// </code>

X10D/src/DictionaryExtensions/DictionaryExtensions.cs

@@ -54,9 +54,6 @@ namespace X10D
             return string.Join(";", list);
         }
 
-        /// <returns>A <see cref="string" /> representing the dictionary as a <c>key=value;</c> set.</returns>
-        ///
-        /// 
         /// <summary>
         ///     Converts an <see cref="IEnumerable{T}" /> of <see cref="KeyValuePair{TKey, TValue}" /> to a HTTP GET parameter
         ///     string.
@@ -64,7 +61,7 @@ namespace X10D
         /// <typeparam name="TKey">The key type.</typeparam>
         /// <typeparam name="TValue">The value type.</typeparam>
         /// <param name="value">The source dictionary.</param>
-        /// <returns>Returns a <see cref="string" /> representing the dictionary as a key=value& set.</returns>
+        /// <returns>Returns a <see cref="string" /> representing the dictionary as a key=value&amp; set.</returns>
         public static string ToGetParameters<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> value)
         {
             if (value is null)

X10D/src/DoubleExtensions/DoubleExtensions.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Runtime.CompilerServices;
 
 namespace X10D
@@ -124,7 +124,7 @@ namespace X10D
         /// </summary>
         /// <param name="value">The value to round.</param>
         /// <param name="nearest">The nearest multiple to which <paramref name="value" /> should be rounded.</param>
-        /// <returns><paramref name="value" /> rounded to the nearest multiple of <paramref name="nearest"/>.</returns>
+        /// <returns><paramref name="value" /> rounded to the nearest multiple of <paramref name="nearest" />.</returns>
         public static double Round(this double value, double nearest)
         {
             return Math.Round(value / nearest) * nearest;

X10D/src/EnumerableExtensions/EnumerableExtensions.cs

@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 
 namespace X10D
@@ -29,7 +29,7 @@ namespace X10D
         /// <param name="chunkSize">The maximum length of the nested collection.</param>
         /// <returns>
         ///     An <see cref="IEnumerable{T}" /> containing an <see cref="IEnumerable{T}" /> of <typeparamref name="T" />
-        ///     whose lengths are no greater than <paramref name="chunkSize" />. 
+        ///     whose lengths are no greater than <paramref name="chunkSize" />.
         /// </returns>
         public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> value, int chunkSize)
         {

X10D/src/Int64Extensions/Int64Extensions.cs

@@ -21,7 +21,7 @@ namespace X10D
         {
             return DateTimeOffset.FromUnixTimeMilliseconds(value);
         }
-        
+
         /// <summary>
         ///     Converts a Unix time expressed as the number of seconds that have elapsed since 1970-01-01T00:00:00Z to a
         ///     <see cref="DateTimeOffset" /> value.
@@ -35,7 +35,7 @@ namespace X10D
         {
             return DateTimeOffset.FromUnixTimeSeconds(value);
         }
-        
+
         /// <summary>
         ///     Returns the current 64-bit signed integer value as an array of bytes.
         /// </summary>
@@ -45,6 +45,7 @@ namespace X10D
         {
             return BitConverter.GetBytes(value);
         }
+
         /// <summary>
         ///     Returns a value indicating whether the current value is evenly divisible by 2.
         /// </summary>

X10D/src/RandomExtensions/RandomExtensions.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Drawing;
 using System.Globalization;
@@ -58,7 +58,7 @@ namespace X10D
         }
 
         /// <summary>
-        ///     Returns a random color
+        ///     Returns a random color.
         /// </summary>
         /// <param name="random"></param>
         /// <returns></returns>
@@ -212,7 +212,7 @@ namespace X10D
         /// <returns>
         ///     A 64-bit signed integer that is greater than or equal to 0, and less than <paramref name="maxValue" />; that is,
         ///     the range of return values ordinarily includes 0 but not <paramref name="maxValue" />. However, if
-        ///     <paramref name="maxValue" /> equals 0, <paramref name="maxValue"/> is returned.
+        ///     <paramref name="maxValue" /> equals 0, <paramref name="maxValue" /> is returned.
         /// </returns>
         /// <remarks><paramref name="maxValue" /> must be greater than or equal to 0.</remarks>
         /// <exception cref="ArgumentNullException"><paramref name="random" /> is <see langword="null" />.</exception>

X10D/src/ReflectionExtensions/MemberInfoExtensions.cs

@@ -77,8 +77,9 @@ namespace X10D
         ///     -or-
         ///     <paramref name="selector" /> is <see langword="null" />.
         /// </exception>
-        public static TReturn? SelectFromCustomAttribute<TAttribute, TReturn>(this MemberInfo member,
+        public static TReturn? SelectFromCustomAttribute<TAttribute, TReturn>(
-                                                                              Func<TAttribute, TReturn> selector)
+            this MemberInfo member,
+            Func<TAttribute, TReturn> selector)
             where TAttribute : Attribute
         {
             if (member is null)

X10D/src/SingleExtensions/SingleExtensions.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Runtime.CompilerServices;
 
 namespace X10D
@@ -124,7 +124,7 @@ namespace X10D
         /// </summary>
         /// <param name="value">The value to round.</param>
         /// <param name="nearest">The nearest multiple to which <paramref name="value" /> should be rounded.</param>
-        /// <returns><paramref name="value" /> rounded to the nearest multiple of <paramref name="nearest"/>.</returns>
+        /// <returns><paramref name="value" /> rounded to the nearest multiple of <paramref name="nearest" />.</returns>
         public static float Round(this float value, float nearest)
         {
             return (float)((double)value).Round(nearest);

X10D/src/StreamExtensions/StreamExtensions.cs

@@ -1,9 +1,9 @@
 using System;
+using System.IO;
+using System.Security.Cryptography;
 #if NET5_0
 using System.Buffers.Binary;
 #endif
-using System.IO;
-using System.Security.Cryptography;
 
 namespace X10D
 {

X10D/src/StringExtensions/StringExtensions.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -134,14 +134,14 @@ namespace X10D
                 throw new ArgumentException(Resource.EnumParseEmptyStringException, nameof(value));
             }
 
-            var t = typeof(T);
+            var type = typeof(T);
 
-            if (!t.IsEnum)
+            if (!type.IsEnum)
             {
                 throw new ArgumentException(Resource.EnumParseNotEnumException);
             }
 
-            return (T)Enum.Parse(t, value, ignoreCase);
+            return (T)Enum.Parse(type, value, ignoreCase);
         }
 
         /// <summary>

X10D/src/TimeSpanParser.cs

@@ -45,8 +45,8 @@ namespace X10D
             {
                 parsedResult = 0;
 
-                return match.Groups[@group].Success
+                return match.Groups[group].Success
-                    && double.TryParse(match.Groups[@group].Value, NumberStyles.Number, provider, out parsedResult);
+                    && double.TryParse(match.Groups[group].Value, NumberStyles.Number, provider, out parsedResult);
             }
 
             if (!TryParseAt(1, out var years))