Refactor service registration and add hex conversion

Refactored service registration logic in ServiceRegistrar.cs for improved clarity and maintainability. Added ToHexStringLower extension to ByteArrayExtensions.cs for efficient lowercase hex conversion. Updated StreamExtensions.cs to use the new method for SHA-256 and SHA-512 hash outputs and enhanced XML docs. Removed redundant tests from StringHelperTests.cs.

Author: bvdcode

Sources/EasyExtensions.Mediator/Registration/ServiceRegistrar.cs

@@ -135,10 +135,29 @@ private static void ConnectImplementationsToTypesClosing(Type openRequestInterfa
             MediatorServiceConfiguration configuration,
             CancellationToken cancellationToken = default)
         {
-            var concretions = new List<Type>();
-            var interfaces = new HashSet<Type>();
-            var genericConcretions = new List<Type>();
-            var genericInterfaces = new HashSet<Type>();
+            GatherTypesClosing(openRequestInterface, assembliesToScan, configuration,
+                out var concretions,
+                out var interfaces,
+                out var genericConcretions,
+                out var genericInterfaces);
+
+            RegisterClosedMatches(services, concretions, interfaces, addIfAlreadyExists);
+            RegisterGenericMatches(services, assembliesToScan, genericConcretions, genericInterfaces, cancellationToken);
+        }
+
+        private static void GatherTypesClosing(
+            Type openRequestInterface,
+            IEnumerable<Assembly> assembliesToScan,
+            MediatorServiceConfiguration configuration,
+            out List<Type> concretions,
+            out HashSet<Type> interfaces,
+            out List<Type> genericConcretions,
+            out HashSet<Type> genericInterfaces)
+        {
+            concretions = new List<Type>();
+            interfaces = new HashSet<Type>();
+            genericConcretions = new List<Type>();
+            genericInterfaces = new HashSet<Type>();
 
             var types = assembliesToScan
                 .SelectMany(a => a.DefinedTypes)
@@ -150,48 +169,65 @@ private static void ConnectImplementationsToTypesClosing(Type openRequestInterfa
             foreach (var type in types)
             {
                 var interfaceTypes = type.FindInterfacesThatClose(openRequestInterface).ToArray();
-
-                if (!type.IsOpenGeneric())
-                {
-                    concretions.Add(type);
-                    AddRangeDistinct(interfaces, interfaceTypes);
-                }
-                else
+                if (type.IsOpenGeneric())
                 {
                     genericConcretions.Add(type);
                     AddRangeDistinct(genericInterfaces, interfaceTypes);
+                    continue;
                 }
+
+                concretions.Add(type);
+                AddRangeDistinct(interfaces, interfaceTypes);
             }
+        }
 
+        private static void RegisterClosedMatches(
+            IServiceCollection services,
+            List<Type> concretions,
+            IEnumerable<Type> interfaces,
+            bool addIfAlreadyExists)
+        {
             foreach (var iface in interfaces)
             {
                 var exactMatches = concretions.Where(x => x.CanBeCastTo(iface)).ToList();
-                if (addIfAlreadyExists)
-                {
-                    foreach (var type in exactMatches)
-                    {
-                        services.AddTransient(iface, type);
-                    }
-                }
-                else
-                {
-                    if (exactMatches.Count > 1)
-                    {
-                        exactMatches.RemoveAll(m => !IsMatchingWithInterface(m, iface));
-                    }
-
-                    foreach (var type in exactMatches)
-                    {
-                        services.TryAddTransient(iface, type);
-                    }
-                }
+                RegisterMatches(services, iface, exactMatches, addIfAlreadyExists);
 
                 if (!iface.IsOpenGeneric())
                 {
                     AddConcretionsThatCouldBeClosed(iface, concretions, services);
                 }
             }
+        }
+
+        private static void RegisterMatches(IServiceCollection services, Type iface, List<Type> exactMatches, bool addIfAlreadyExists)
+        {
+            if (addIfAlreadyExists)
+            {
+                foreach (var type in exactMatches)
+                {
+                    services.AddTransient(iface, type);
+                }
+                return;
+            }
 
+            if (exactMatches.Count > 1)
+            {
+                exactMatches.RemoveAll(m => !IsMatchingWithInterface(m, iface));
+            }
+
+            foreach (var type in exactMatches)
+            {
+                services.TryAddTransient(iface, type);
+            }
+        }
+
+        private static void RegisterGenericMatches(
+            IServiceCollection services,
+            IEnumerable<Assembly> assembliesToScan,
+            List<Type> genericConcretions,
+            IEnumerable<Type> genericInterfaces,
+            CancellationToken cancellationToken)
+        {
             foreach (var iface in genericInterfaces)
             {
                 var exactMatches = genericConcretions.Where(x => x.CanBeCastTo(iface)).ToList();

Sources/EasyExtensions.Tests/StringHelperTests.cs

@@ -31,7 +31,6 @@ public void IsMatch_ValidInput_MustBeFalse()
             Assert.That(StringHelpers.IsMatch(left, right, threshold: 0.8), Is.False);
         }
 
-
         [Test]
         public void IsMatch_ValidInputZeroThresholdSameStrings_MustBeTrue()
         {
@@ -40,7 +39,6 @@ public void IsMatch_ValidInputZeroThresholdSameStrings_MustBeTrue()
             Assert.That(StringHelpers.IsMatch(left, right, threshold: 0), Is.True);
         }
 
-
         [Test]
         public void IsMatch_ValidInputZeroThresholdDiffStrings_MustBeTrue()
         {

Sources/EasyExtensions/Extensions/ByteArrayExtensions.cs

@@ -31,5 +31,33 @@ public static string Sha512(this byte[] bytes)
             using MemoryStream memoryStream = new MemoryStream(bytes);
             return memoryStream.Sha512();
         }
+
+        /// <summary>
+        /// Converts the specified byte array to its equivalent lowercase hexadecimal string representation.
+        /// </summary>
+        /// <param name="bytes">The array of bytes to convert to a hexadecimal string. Cannot be null.</param>
+        /// <returns>A string containing the lowercase hexadecimal representation of the input byte array, or an empty string if
+        /// the array is empty.</returns>
+        public static string ToHexStringLower(this byte[] bytes)
+        {
+            if (bytes.Length == 0)
+            {
+                return string.Empty;
+            }
+
+            char[] chars = new char[bytes.Length * 2];
+            int c = 0;
+            for (int i = 0; i < bytes.Length; i++)
+            {
+                byte b = bytes[i];
+                int hi = b >> 4;
+                int lo = b & 0xF;
+
+                chars[c++] = (char)(hi < 10 ? '0' + hi : 'a' + (hi - 10));
+                chars[c++] = (char)(lo < 10 ? '0' + lo : 'a' + (lo - 10));
+            }
+
+            return new string(chars);
+        }
     }
 }

Sources/EasyExtensions/Extensions/StreamExtensions.cs

@@ -55,27 +55,36 @@ public static async Task<byte[]> ReadToEndAsync(this Stream stream, bool leaveOp
         }
 
         /// <summary>
-        /// Calculate SHA256 hash of byte stream.
+        /// Computes the SHA-256 hash of the data in the specified stream and returns it as a lowercase hexadecimal
+        /// string.
         /// </summary>
-        /// <param name="stream"> Data to calculate hash. </param>
-        /// <returns> SHA256 hash of byte stream. </returns>
+        /// <remarks>The method reads from the current position of the stream to the end. After the
+        /// operation, the stream's position will be at the end of the stream. The caller is responsible for managing
+        /// the stream's position and lifetime.</remarks>
+        /// <param name="stream">The input stream containing the data to hash. The stream must be readable and positioned at the start of the
+        /// data to hash.</param>
+        /// <returns>A lowercase hexadecimal string representation of the SHA-256 hash of the stream's contents.</returns>
         public static string Sha256(this Stream stream)
         {
             using SHA256 sha = SHA256.Create();
             byte[] array = sha.ComputeHash(stream);
-            return BitConverter.ToString(array).Replace("-", string.Empty).ToLower();
+            return array.ToHexStringLower();
         }
 
         /// <summary>
-        /// Calculate SHA512 hash of byte stream.
+        /// Computes the SHA-512 hash of the data in the specified stream and returns it as a lowercase hexadecimal
+        /// string.
         /// </summary>
-        /// <param name="stream"> Data to calculate hash. </param>
-        /// <returns> SHA512 hash of byte stream. </returns>
+        /// <remarks>The method does not reset the position of the stream after computing the hash. The
+        /// caller is responsible for managing the stream's position and lifetime.</remarks>
+        /// <param name="stream">The input stream containing the data to hash. The stream must be readable and positioned at the start of the
+        /// data to hash.</param>
+        /// <returns>A lowercase hexadecimal string representing the SHA-512 hash of the stream's contents.</returns>
         public static string Sha512(this Stream stream)
         {
             using SHA512 sha = SHA512.Create();
             byte[] array = sha.ComputeHash(stream);
-            return BitConverter.ToString(array).Replace("-", string.Empty).ToLower();
+            return array.ToHexStringLower();
         }
     }
 }