perf: optimise subsequent GetHash and TryWriteHash calls

CHANGELOG.md

@@ -38,6 +38,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 BigEndian/LittleEndian methods.
 - X10D: `Stream.GetHash<>` and `Stream.TryWriteHash<>` now throw ArgumentException in lieu of
 TypeInitializationException.
+- X10D: `Stream.GetHash<>` and `Stream.TryWriteHash<>` are now more efficient on second and subsequent calls.
 
 ### Removed
 

X10D/src/IO/StreamExtensions.cs

@@ -1,4 +1,5 @@
-using System.Reflection;
+using System.Collections.Concurrent;
+using System.Reflection;
 using System.Security.Cryptography;
 
 namespace X10D.IO;
@@ -8,6 +9,8 @@ namespace X10D.IO;
 /// </summary>
 public static partial class StreamExtensions
 {
+    private static readonly ConcurrentDictionary<Type, HashAlgorithm> HashAlgorithmCache = new();
+
     /// <summary>
     ///     Returns the hash of the current stream as an array of bytes using the specified hash algorithm.
     /// </summary>
@@ -37,6 +40,11 @@ public static byte[] GetHash<T>(this Stream stream)
             throw new IOException(ExceptionMessages.StreamDoesNotSupportReading);
         }
 
+        if (HashAlgorithmCache.TryGetValue(typeof(T), out HashAlgorithm? cachedHashAlgorithm))
+        {
+            return cachedHashAlgorithm.ComputeHash(stream);
+        }
+
         Type type = typeof(T);
 
         MethodInfo? createMethod = type.GetMethods(BindingFlags.Public | BindingFlags.Static)
@@ -52,6 +60,7 @@ public static byte[] GetHash<T>(this Stream stream)
             throw new ArgumentException(ExceptionMessages.HashAlgorithmCreateReturnedNull);
         }
 
+        HashAlgorithmCache.TryAdd(type, crypt);
         return crypt.ComputeHash(stream);
     }
 
@@ -91,6 +100,13 @@ public static bool TryWriteHash<T>(this Stream stream, Span<byte> destination, o
             throw new IOException(ExceptionMessages.StreamDoesNotSupportReading);
         }
 
+        Span<byte> buffer = stackalloc byte[(int)stream.Length];
+        if (HashAlgorithmCache.TryGetValue(typeof(T), out HashAlgorithm? cachedHashAlgorithm))
+        {
+            _ = stream.Read(buffer); // we don't care about the number of bytes read. we can ignore MustUseReturnValue
+            return cachedHashAlgorithm.TryComputeHash(buffer, destination, out bytesWritten);
+        }
+
         Type type = typeof(T);
 
         MethodInfo? createMethod = type.GetMethods(BindingFlags.Public | BindingFlags.Static)
@@ -111,7 +127,7 @@ public static bool TryWriteHash<T>(this Stream stream, Span<byte> destination, o
             throw new ArgumentException(ExceptionMessages.StreamTooLarge);
         }
 
-        Span<byte> buffer = stackalloc byte[(int)stream.Length];
+        HashAlgorithmCache.TryAdd(type, crypt);
         _ = stream.Read(buffer); // we don't care about the number of bytes read. we can ignore MustUseReturnValue
         return crypt.TryComputeHash(buffer, destination, out bytesWritten);
     }