v1.7.0

src/HashVerifierBase.cs

@@ -28,25 +28,25 @@ public abstract class HashVerifierBase<T> : IHashVerifierAsync<T>
     /// </summary>
     public const StringComparison DefaultComparisonMethod = StringComparison.OrdinalIgnoreCase;
 
-    public bool VerifyHash(T data, string expectedHash, IHashingAlgorithm<T> algorithm)
+    public bool VerifyHash(T data, string expectedHash, IHashingAlgorithm<T> algorithm, IStringEncoding? encoding = null)
     {
-        string actualHash = algorithm.ComputeHash(data, HashProvider);
+        string actualHash = algorithm.ComputeHash(data, HashProvider, encoding);
         return string.Equals(actualHash, expectedHash, ComparisonMethod);
     }
 
-    public Task<bool> VerifyHashAsync(T data, string expectedHash, IHashingAlgorithm<T> algorithm, CancellationToken cancellationToken = default)
+    public Task<bool> VerifyHashAsync(T data, string expectedHash, IHashingAlgorithm<T> algorithm, CancellationToken cancellationToken = default, IStringEncoding? encoding = null)
     {
-        return Task.Run(() => AsyncHashVerification(data, expectedHash, algorithm, cancellationToken), cancellationToken);
+        return Task.Run(() => AsyncHashVerification(data, expectedHash, algorithm, cancellationToken, encoding), cancellationToken);
     }
 
-    private async Task<bool> AsyncHashVerification(T data, string expectedHash, IHashingAlgorithm<T> algorithm, CancellationToken cancellationToken)
+    private async Task<bool> AsyncHashVerification(T data, string expectedHash, IHashingAlgorithm<T> algorithm, CancellationToken cancellationToken, IStringEncoding? encoding)
     {
         string actualHash;
         bool result;
 
         if (algorithm is IHashingAlgorithmAsync<T> asyncAlgorithm)
         {
-            actualHash = await asyncAlgorithm.ComputeHashAsync(data, HashProvider, cancellationToken);
+            actualHash = await asyncAlgorithm.ComputeHashAsync(data, HashProvider, cancellationToken, encoding);
         }
         else
         {

src/HashingAlgorithmBase.cs

@@ -56,6 +56,14 @@ private async Task<string> AsyncHashComputation(T data, IHashingProvider<T> prov
         }
 
         byte[] hashBytes = await ComputeHashAsync(bytes, cancellationToken);
-        return encoding.ConvertToString(hashBytes);
+
+        if (encoding is IStringEncodingAsync asyncEncoding)
+        {
+            return await asyncEncoding.ConvertToStringAsync(hashBytes);
+        }
+        else
+        {
+            return encoding.ConvertToString(hashBytes);
+        }
     }
 }

src/HashingHandler.csproj

@@ -20,7 +20,7 @@
 		<AssemblyVersion Condition="'$(AssemblyVersion)' == ''">$(Version)</AssemblyVersion>
 		<AssemblyFileVersion Condition="'$(AssemblyFileVersion)' == ''">$(Version)</AssemblyFileVersion>
 		<PackageVersion Condition="'$(PackageVersion)' == ''">$(Version)</PackageVersion>
-		<Version>1.6.0</Version>
+		<Version>1.7.0</Version>
 	</PropertyGroup>
 
 	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">

src/IHashVerifier.cs

@@ -14,6 +14,7 @@ public interface IHashVerifier<T>
     /// <param name="data">Data to be hashed, in format <typeparamref name="T"/>.</param>
     /// <param name="expectedHash">A <see cref="string"/> representing the expected hash for the given <paramref name="data"/> of type <typeparamref name="T"/>.</param>
     /// <param name="algorithm">The algorithm used to hash the given data of type <typeparamref name="T"/>.</param>
+    /// <param name="encoding">An <see cref="IStringEncoding"/> representing the conversion method of the hash from <see cref="byte"/>[] to <see cref="string"/>. Default: Hexadecimal string.</param>
     /// <returns>True, if the calculated hash of the data of type <typeparamref name="T"/> matches the <paramref name="expectedHash"/>. Otherwise, false.</returns>
-    public bool VerifyHash(T data, string expectedHash, IHashingAlgorithm<T> algorithm);
+    public bool VerifyHash(T data, string expectedHash, IHashingAlgorithm<T> algorithm, IStringEncoding? encoding = null);
 }

src/IHashVerifierAsync.cs

@@ -18,6 +18,7 @@ public interface IHashVerifierAsync<T> : IHashVerifier<T>
     /// <param name="expectedHash">A <see cref="string"/> representing the expected hash for the given <paramref name="data"/> of type <typeparamref name="T"/>.</param>
     /// <param name="algorithm">The algorithm used to hash the given data of type <typeparamref name="T"/>.</param>
     /// <param name="cancellationToken">A cancellation token allowing the canceling of asynchronous jobs.</param>
+    /// <param name="encoding">An <see cref="IStringEncoding"/> representing the conversion method of the hash from <see cref="byte"/>[] to <see cref="string"/>. Default: Hexadecimal string.</param>
     /// <returns>True, if the hashes match. Otherwise, false.</returns>
-    public Task<bool> VerifyHashAsync(T data, string expectedHash, IHashingAlgorithm<T> algorithm, CancellationToken cancellationToken = default);
+    public Task<bool> VerifyHashAsync(T data, string expectedHash, IHashingAlgorithm<T> algorithm, CancellationToken cancellationToken = default, IStringEncoding? encoding = null);
 }

src/IStringEncoding.cs

@@ -2,6 +2,9 @@
 
 namespace HashingHandler;
 
+/// <summary>
+/// Interface for encoding <see cref="byte"/>[] to <see cref="string"/>.
+/// </summary>
 public interface IStringEncoding
 {
     /// <summary>

src/IStringEncodingAsync.cs

@@ -0,0 +1,18 @@
+// HashingHandler by Simon Field
+
+using System.Threading.Tasks;
+
+namespace HashingHandler;
+
+/// <summary>
+/// Interface for encoding <see cref="byte"/>[] to <see cref="string"/> asynchronously.
+/// </summary>
+public interface IStringEncodingAsync : IStringEncoding
+{
+    /// <summary>
+    /// Converts a <see cref="byte"/>[] to a <see cref="string"/> asynchronously.
+    /// </summary>
+    /// <param name="bytes">The <see cref="byte"/>[] to convert to a <see cref="string"/>.</param>
+    /// <returns>A <see cref="Task"/> representing the asynchronous operation that returns a <see cref="string"/> converted from the <see cref="byte"/>[].</returns>
+    public Task<string> ConvertToStringAsync(byte[] bytes);
+}

src/StringEncodingBase.cs

@@ -0,0 +1,15 @@
+// HashingHandler by Simon Field
+
+using System.Threading.Tasks;
+
+namespace HashingHandler;
+
+/// <summary>
+/// Base class for encoding <see cref="byte"/>[] to <see cref="string"/>.
+/// </summary>
+public abstract class StringEncodingBase : IStringEncodingAsync
+{
+    public abstract string ConvertToString(byte[] bytes);
+
+    public virtual Task<string> ConvertToStringAsync(byte[] bytes) => Task.Run(() => ConvertToString(bytes));
+}

src/StringExtensions.cs

@@ -7,9 +7,9 @@ namespace HashingHandler;
 /// <summary>
 /// A class containing methods for manipulating <see cref="string"/> objects.
 /// </summary>
-internal class StringExtensions : IStringEncoding
+internal class StringExtensions : StringEncodingBase
 {
-    public string ConvertToString(byte[] data)
+    public override string ConvertToString(byte[] data)
     {
         return BitConverter.ToString(data).Replace("-", "");
     }