Code and project cleanup (#61)

* set net6.0 as 'host' for benchmark command
* format csproj files
* remove unused code
* cleanup compiler directives
* update nuget references
* clear up comments about alphabet
* run dotnet format
* remove unnecessary static init, merge into ctor
* improve hash confirmation check
* renames, code style fixes

Author: manigandham

benchmark.sh

@@ -1 +1 @@
-dotnet run --project .\test\Hashids.net.benchmark\Hashids.net.benchmark.csproj -c Release
+dotnet run --framework net6.0 --project .\test\Hashids.net.benchmark\Hashids.net.benchmark.csproj -c Release 

src/Hashids.net/ArrayExtensions.cs

@@ -31,18 +31,5 @@ public static T[] Append<T>(this T[] array, T[] appendArray, int index, int leng
             Array.Copy(appendArray, index, newArray, array.Length, length - index);
             return newArray;
         }
-
-#if NETCOREAPP3_1_OR_GREATER
-        /// <remarks>This method exists because <see cref="ReadOnlySpan{T}"/> does not implement <see cref="IEnumerable{T}"/> and using <c>.AsEnumerable()</c> will cause boxing.</remarks>
-        public static bool Any<T>(this ReadOnlySpan<T> span, Func<T,bool> predicate)
-        {
-            for(int i = 0; i < span.Length; i++)
-            {
-                if(predicate(span[i])) return true;
-            }
-
-            return false;
-        }
-#endif
     }
 }

src/Hashids.net/Hashids.cs

@@ -16,7 +16,6 @@ public partial class Hashids : IHashids
 
         private const double SEP_DIV = 3.5;
         private const double GUARD_DIV = 12.0;
-
         private const int MaxNumberHashLength = 12; // Length of long.MaxValue;
 
         private readonly char[] _alphabet;
@@ -25,11 +24,10 @@ public partial class Hashids : IHashids
         private readonly char[] _salt;
         private readonly int _minHashLength;
 
-        private readonly StringBuilderPool _sbPool = new();
-
         // Creates the Regex in the first usage, speed up first use of non-hex methods
-        private static readonly Lazy<Regex> hexValidator = new(() => new Regex("^[0-9a-fA-F]+$", RegexOptions.Compiled));
-        private static readonly Lazy<Regex> hexSplitter = new(() => new Regex(@"[\w\W]{1,12}", RegexOptions.Compiled));
+        private static readonly Lazy<Regex> HexValidator = new(() => new Regex("^[0-9a-fA-F]+$", RegexOptions.Compiled));
+        private static readonly Lazy<Regex> HexSplitter = new(() => new Regex(@"[\w\W]{1,12}", RegexOptions.Compiled));
+        private readonly StringBuilderPool StringBuilderPool = new();
 
         /// <summary>
         /// Instantiates a new Hashids encoder/decoder with defaults.
@@ -53,101 +51,74 @@ public Hashids(
             string alphabet = DEFAULT_ALPHABET,
             string seps = DEFAULT_SEPS)
         {
-            if (salt == null)
-                throw new ArgumentNullException(nameof(salt));
-            if (string.IsNullOrWhiteSpace(alphabet))
-                throw new ArgumentNullException(nameof(alphabet));
-            if (minHashLength < 0)
-                throw new ArgumentOutOfRangeException(nameof(minHashLength), "Value must be zero or greater.");
-            if (string.IsNullOrWhiteSpace(seps))
-                throw new ArgumentNullException(nameof(seps));
+            if (salt == null) throw new ArgumentNullException(nameof(salt));
+            if (minHashLength < 0) throw new ArgumentOutOfRangeException(nameof(minHashLength), "Value must be zero or greater.");
+            if (string.IsNullOrWhiteSpace(alphabet)) throw new ArgumentNullException(nameof(alphabet));
+            if (string.IsNullOrWhiteSpace(seps)) throw new ArgumentNullException(nameof(seps));
 
             _salt = salt.Trim().ToCharArray();
             _minHashLength = minHashLength;
+            _alphabet = alphabet.ToCharArray().Distinct().ToArray();
+            _seps = seps.ToCharArray();
 
-            InitCharArrays(alphabet: alphabet, seps: seps, salt: _salt, alphabetChars: out _alphabet, sepChars: out _seps, guardChars: out _guards);
-        }
-
-        /// <remarks>This method uses <c>out</c> params instead of returning a ValueTuple so it works with .NET 4.6.1.</remarks>
-        private static void InitCharArrays(string alphabet, string seps, ReadOnlySpan<char> salt, out char[] alphabetChars, out char[] sepChars, out char[] guardChars)
-        {
-            alphabetChars = alphabet.ToCharArray().Distinct().ToArray();
-            sepChars      = seps.ToCharArray();
-
-            if (alphabetChars.Length < MIN_ALPHABET_LENGTH)
-            {
+            if (_alphabet.Length < MIN_ALPHABET_LENGTH)
                 throw new ArgumentException($"Alphabet must contain at least {MIN_ALPHABET_LENGTH:N0} unique characters.", paramName: nameof(alphabet));
-            }
 
-            // SetupGuards():
+            // separator characters can only be chosen from the characters in the alphabet
+            if (_seps.Length > 0)
+                _seps = _seps.Intersect(_alphabet).ToArray();
 
-            // seps should contain only characters present in alphabet:
-            if (sepChars.Length > 0)
-            {
-                sepChars = sepChars.Intersect(alphabetChars).ToArray();
-            }
-            
-            // alphabet should not contain seps // TODO: This comment contradicts the above, it needs rephrasing.
-            if (sepChars.Length > 0 )
-            {
-                alphabetChars = alphabetChars.Except(sepChars).ToArray();
-            }
+            // once separator characters are chosen, they must be removed from the alphabet available for hash generation
+            if (_seps.Length > 0)
+                _alphabet = _alphabet.Except(_seps).ToArray();
 
-            if (alphabetChars.Length < (MIN_ALPHABET_LENGTH - 6))
-            {
+            if (_alphabet.Length < (MIN_ALPHABET_LENGTH - 6))
                 throw new ArgumentException($"Alphabet must contain at least {MIN_ALPHABET_LENGTH:N0} unique characters that are also not present in .", paramName: nameof(alphabet));
-            }
 
-            ConsistentShuffle(alphabet: sepChars, salt: salt);
+            ConsistentShuffle(alphabet: _seps, salt: _salt);
 
-            if (sepChars.Length == 0 || ((float)alphabetChars.Length / sepChars.Length) > SEP_DIV)
+            if (_seps.Length == 0 || ((float)_alphabet.Length / _seps.Length) > SEP_DIV)
             {
-                var sepsLength = (int)Math.Ceiling((float)alphabetChars.Length / SEP_DIV);
+                var sepsLength = (int)Math.Ceiling((float)_alphabet.Length / SEP_DIV);
 
                 if (sepsLength == 1)
-                {
                     sepsLength = 2;
-                }
 
-                if (sepsLength > sepChars.Length)
+                if (sepsLength > _seps.Length)
                 {
-                    var diff = sepsLength - sepChars.Length;
-                    sepChars = sepChars.Append(alphabetChars, 0, diff);
-                    alphabetChars = alphabetChars.SubArray(diff);
+                    var diff = sepsLength - _seps.Length;
+                    _seps = _seps.Append(_alphabet, 0, diff);
+                    _alphabet = _alphabet.SubArray(diff);
                 }
                 else
                 {
-                    sepChars = sepChars.SubArray(0, sepsLength);
+                    _seps = _seps.SubArray(0, sepsLength);
                 }
             }
 
-            ConsistentShuffle(alphabet: alphabetChars, salt: salt);
-            
-            // SetupGuards():
-           
-            var guardCount = (int)Math.Ceiling(alphabetChars.Length / GUARD_DIV);
+            ConsistentShuffle(alphabet: _alphabet, salt: _salt);
 
-            if (alphabetChars.Length < 3)
+            var guardCount = (int)Math.Ceiling(_alphabet.Length / GUARD_DIV);
+
+            if (_alphabet.Length < 3)
             {
-                guardChars = sepChars.SubArray(index: 0, length: guardCount);
-                sepChars   = sepChars.SubArray(index: guardCount);
+                _guards = _seps.SubArray(index: 0, length: guardCount);
+                _seps = _seps.SubArray(index: guardCount);
             }
 
             else
             {
-                guardChars    = alphabetChars.SubArray(index: 0, length: guardCount);
-                alphabetChars = alphabetChars.SubArray(index: guardCount);
+                _guards = _alphabet.SubArray(index: 0, length: guardCount);
+                _alphabet = _alphabet.SubArray(index: guardCount);
             }
         }
 
-#if NETCOREAPP3_1_OR_GREATER
         /// <summary>
         /// Encodes the provided number into a hashed string
         /// </summary>
         /// <param name="number">the number</param>
         /// <returns>the hashed string</returns>
         public string Encode(int number) => EncodeLong(number);
-#endif
 
         /// <summary>
         /// Encodes the provided numbers into a hash string.
@@ -163,19 +134,12 @@ private static void InitCharArrays(string alphabet, string seps, ReadOnlySpan<ch
         /// <returns>Encoded hash string.</returns>
         public virtual string Encode(IEnumerable<int> numbers) => Encode(numbers.ToArray());
 
-#if NETCOREAPP3_1_OR_GREATER
         /// <summary>
         /// Encodes the provided number into a hashed string
         /// </summary>
         /// <param name="number">the number</param>
         /// <returns>the hashed string</returns>
-        public string EncodeLong(long number)
-        {
-            ReadOnlySpan<long> span = stackalloc[] { number };
-
-            return GenerateHashFrom(span);
-        }
-#endif
+        public string EncodeLong(long number) => GenerateHashFrom(stackalloc[] { number });
 
         /// <summary>
         /// Encodes the provided numbers into a hash string.
@@ -230,7 +194,7 @@ public bool TryDecodeSingleLong(string hash, out long id)
                 id = numbers[0];
                 return true;
             }
-            
+
             id = 0L;
             return false;
         }
@@ -259,7 +223,7 @@ public virtual bool TryDecodeSingle(string hash, out int id)
                 id = (int)numbers[0];
                 return true;
             }
-            
+
             id = 0;
             return false;
         }
@@ -271,17 +235,17 @@ public virtual bool TryDecodeSingle(string hash, out int id)
         /// <returns>Encoded hash string.</returns>
         public virtual string EncodeHex(string hex)
         {
-            if (string.IsNullOrWhiteSpace(hex) || !hexValidator.Value.IsMatch(hex))
+            if (string.IsNullOrWhiteSpace(hex) || !HexValidator.Value.IsMatch(hex))
                 return string.Empty;
 
-            var matches = hexSplitter.Value.Matches(hex);
+            var matches = HexSplitter.Value.Matches(hex);
             if (matches.Count == 0) return string.Empty;
 
             var numbers = new long[matches.Count];
             for (int i = 0; i < numbers.Length; i++)
             {
-                Match match = matches[i];
-                string concat = string.Concat("1", match.Value);
+                var match = matches[i];
+                var concat = string.Concat("1", match.Value);
                 var number = Convert.ToInt64(concat, fromBase: 16);
                 numbers[i] = number;
             }
@@ -296,40 +260,35 @@ public virtual string EncodeHex(string hex)
         /// <returns>Decoded hex string.</returns>
         public virtual string DecodeHex(string hash)
         {
-            var builder = _sbPool.Get();
+            var builder = StringBuilderPool.Get();
             var numbers = DecodeLong(hash);
 
             foreach (var number in numbers)
             {
                 var s = number.ToString("X");
-
                 for (var i = 1; i < s.Length; i++)
-                {
                     builder.Append(s[i]);
-                }
             }
 
             var result = builder.ToString();
-            _sbPool.Return(builder);
+            StringBuilderPool.Return(builder);
             return result;
         }
 
         private string GenerateHashFrom(ReadOnlySpan<long> numbers)
         {
-            if (numbers.Length == 0) 
+            if (numbers.Length == 0)
                 return string.Empty;
 
-            foreach (var item in numbers)
-                if (item < 0)
+            foreach (var num in numbers)
+                if (num < 0)
                     return string.Empty;
 
             long numbersHashInt = 0;
             for (var i = 0; i < numbers.Length; i++)
-            {
                 numbersHashInt += numbers[i] % (i + 100);
-            }
 
-            var stringBuilder = _sbPool.Get();
+            var stringBuilder = StringBuilderPool.Get();
 
             Span<char> alphabet = _alphabet.Length < 512 ? stackalloc char[_alphabet.Length] : new char[_alphabet.Length];
             _alphabet.CopyTo(alphabet);
@@ -351,17 +310,13 @@ private string GenerateHashFrom(ReadOnlySpan<long> numbers)
                 var number = numbers[i];
 
                 if (length > 0)
-                {
                     alphabet.Slice(0, length).CopyTo(shuffleBuffer.Slice(startIndex));
-                }
 
                 ConsistentShuffle(alphabet, shuffleBuffer);
                 var hashLength = BuildReversedHash(number, alphabet, hashBuffer);
 
                 for (var j = hashLength - 1; j > -1; j--)
-                {
                     stringBuilder.Append(hashBuffer[j]);
-                }
 
                 if (i + 1 < numbers.Length)
                 {
@@ -412,7 +367,7 @@ private string GenerateHashFrom(ReadOnlySpan<long> numbers)
             }
 
             var result = stringBuilder.ToString();
-            _sbPool.Return(stringBuilder);
+            StringBuilderPool.Return(stringBuilder);
             return result;
         }
 
@@ -453,17 +408,14 @@ private long[] GetNumbersFrom(string hash)
             if (hashArray.Length == 0)
                 return Array.Empty<long>();
 
-            var i = (hashArray.Length is 3 or 2 ) ? 1 : 0;
+            var unguardedIdx = (hashArray.Length is 3 or 2) ? 1 : 0;
+            var hashBreakdown = hashArray[unguardedIdx];
 
-            var hashBreakdown = hashArray[i];
             var lottery = hashBreakdown[0];
-
-            if (lottery == '\0') /* default(char) == '\0' */
+            if (lottery == '\0') // default(char) is '\0'
                 return Array.Empty<long>();
 
-            hashBreakdown = hashBreakdown.Substring(1);
-
-            hashArray = hashBreakdown.Split(_seps, StringSplitOptions.RemoveEmptyEntries);
+            hashArray = hashBreakdown.Substring(1).Split(_seps, StringSplitOptions.RemoveEmptyEntries);
 
             var result = new long[hashArray.Length];
 
@@ -482,31 +434,29 @@ private long[] GetNumbersFrom(string hash)
                 var subHash = hashArray[j];
 
                 if (length > 0)
-                {
                     alphabet.Slice(0, length).CopyTo(buffer.Slice(startIndex));
-                }
 
                 ConsistentShuffle(alphabet, buffer);
                 result[j] = Unhash(subHash, alphabet);
             }
 
-            if (EncodeLong(result) == hash)
-            {
+            // regenerate hash from numbers and compare to given hash to ensure the correct parameters were used
+            if (GenerateHashFrom(result).Equals(hash, StringComparison.Ordinal))
                 return result;
-            }
 
             return Array.Empty<long>();
         }
 
-        /// <summary>NOTE: This method mutates the <paramref name="alphabet"/> argument in-place.</summary>
+        /// <summary>
+        /// NOTE: This method mutates the <paramref name="alphabet"/> argument in-place.
+        /// </summary>
         private static void ConsistentShuffle(Span<char> alphabet, ReadOnlySpan<char> salt)
         {
             if (salt.Length == 0)
                 return;
 
             // TODO: Document or rename these cryptically-named variables: i, v, p, n.
-            int n;
-            for (int i = alphabet.Length - 1, v = 0, p = 0; i > 0; i--, v++)
+            for (int i = alphabet.Length - 1, v = 0, n, p = 0; i > 0; i--, v++)
             {
                 v %= salt.Length;
                 n = salt[v];