v1.5.0

src/HashVerifierBase.cs

@@ -1,23 +1,54 @@
 // HashingHandler by Simon Field
 
 using System;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace HashingHandler;
 
 /// <summary>
 /// Base class for verifying hashes of objects of type <typeparamref name="T"/>.
 /// </summary>
 /// <typeparam name="T">The type of objects being hashed.</typeparam>
-public abstract class HashVerifierBase<T> : IHashChecker<T>
+public abstract class HashVerifierBase<T> : IHashVerifierAsync<T>
 {
     /// <summary>
     /// The hashing provider used to convert objects of type <typeparamref name="T"/> to <see cref="byte"/>[].
     /// </summary>
     protected abstract IHashingProvider<T> HashProvider { get; }
 
+    /// <summary>
+    /// The method used for comparing the actual hash with the expected hash.
+    /// </summary>
+    protected virtual StringComparison ComparisonMethod => StringComparison.OrdinalIgnoreCase;
+
     public bool VerifyHash(T data, string expectedHash, IHashingAlgorithm<T> algorithm)
     {
         string actualHash = algorithm.ComputeHash(data, HashProvider);
-        return string.Equals(actualHash, expectedHash, StringComparison.OrdinalIgnoreCase);
+        return string.Equals(actualHash, expectedHash, ComparisonMethod);
+    }
+
+    public Task<bool> VerifyHashAsync(T data, string expectedHash, IHashingAlgorithm<T> algorithm, CancellationToken cancellationToken = default)
+    {
+        return Task.Run(() => AsyncHashVerification(data, expectedHash, algorithm, cancellationToken), cancellationToken);
+    }
+
+    private async Task<bool> AsyncHashVerification(T data, string expectedHash, IHashingAlgorithm<T> algorithm, CancellationToken cancellationToken)
+    {
+        string actualHash;
+        bool result;
+
+        if (algorithm is IHashingAlgorithmAsync<T> asyncAlgorithm)
+        {
+            actualHash = await asyncAlgorithm.ComputeHashAsync(data, HashProvider, cancellationToken);
+        }
+        else
+        {
+            actualHash = algorithm.ComputeHash(data, HashProvider);
+        }
+
+        result = string.Equals(actualHash, expectedHash, ComparisonMethod);
+
+        return result;
     }
 }

src/HashingAlgorithmBase.cs

@@ -5,7 +5,11 @@
 
 namespace HashingHandler;
 
-public abstract class HashingAlgorithmBase<T> : IHashingAlgorithm<T>, IHashingAlgorithmAsync<T>
+/// <summary>
+/// Base class for hashing algorithms.
+/// </summary>
+/// <typeparam name="T">The type of objects being hashed.</typeparam>
+public abstract class HashingAlgorithmBase<T> : IHashingAlgorithmAsync<T>
 {
     /// <summary>
     /// Compute a hash of type <see cref="byte"/>[] given the data <paramref name="bytes"/> of type <see cref="byte"/>[].
@@ -29,13 +33,18 @@ public string ComputeHash(T data, IHashingProvider<T> provider)
         return StringExtensions.ByteToHex(hashBytes);
     }
 
-    public async Task<string> ComputeHashAsync(T data, IHashingProvider<T> provider, CancellationToken cancellationToken = default)
+    public Task<string> ComputeHashAsync(T data, IHashingProvider<T> provider, CancellationToken cancellationToken = default)
+    {
+        return Task.Run(() => AsyncHashComputation(data, provider, cancellationToken), cancellationToken);
+    }
+
+    private async Task<string> AsyncHashComputation(T data, IHashingProvider<T> provider, CancellationToken cancellationToken)
     {
         byte[] bytes;
 
         if (provider is IHashingProviderAsync<T> asyncProvider)
         {
-            bytes = await asyncProvider.ConvertToBytes(data, cancellationToken);
+            bytes = await asyncProvider.ConvertToBytesAsync(data, cancellationToken);
         }
         else
         {

src/HashingHandler.csproj

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

src/IHashVerifier.cs

@@ -1,15 +1,19 @@
-// HashingHandler by Simon Field
+// HashingHandler by Simon Field
 
 namespace HashingHandler;
 
 /// <summary>
-/// Interface for classes supporting the verification of data using hashes.
+/// Unifies classes supporting the verifying of a hash of an object of type <typeparamref name="T"/> with another hash.
 /// </summary>
-public interface IHashVerifier
+/// <typeparam name="T">The type of the object being hashed.</typeparam>
+public interface IHashVerifier<T>
 {
     /// <summary>
-    /// Verifies whether checksum included in the data matches the dats's contents.
+    /// Verify that the hash of the given <paramref name="data"/> of type <typeparamref name="T"/> matches the <paramref name="expectedHash"/>.
     /// </summary>
-    /// <returns>True, if the checksum matches. Otherwise, false.</returns>
-    bool VerifyHash();
+    /// <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>
+    /// <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);
 }

src/IHashVerifierAsync.cs

@@ -0,0 +1,23 @@
+// HashingHandler by Simon Field
+
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace HashingHandler;
+
+/// <summary>
+/// Unifies classes supporting the asynchronous verification of a hash of an object of type <typeparamref name="T"/> with another hash.
+/// </summary>
+/// <typeparam name="T">The type of the object being hashed.</typeparam>
+public interface IHashVerifierAsync<T> : IHashVerifier<T>
+{
+    /// <summary>
+    /// Asynchronously verify that the hash of the given <paramref name="data"/> of type <typeparamref name="T"/> matches the <paramref name="expectedHash"/>.
+    /// </summary>
+    /// <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="cancellationToken">A cancellation token allowing the canceling of asynchronous jobs.</param>
+    /// <returns></returns>
+    public Task<bool> VerifyHashAsync(T data, string expectedHash, IHashingAlgorithm<T> algorithm, CancellationToken cancellationToken = default);
+}

src/IHashingAlgorithmAsync.cs

@@ -18,5 +18,5 @@ public interface IHashingAlgorithmAsync<T> : IHashingAlgorithm<T>
     /// <param name="provider">The data interpreter.</param>
     /// <param name="cancellationToken">A cancellation token allowing the canceling of asynchronous jobs.</param>
     /// <returns>A <see cref="Task"/> including the hash computation job.</returns>
-    public Task<string> ComputeHashAsync(T data, IHashingProvider<T> provider, CancellationToken cancellationToken);
+    public Task<string> ComputeHashAsync(T data, IHashingProvider<T> provider, CancellationToken cancellationToken = default);
 }

src/IHashingProviderAsync.cs

@@ -17,5 +17,5 @@ public interface IHashingProviderAsync<T> : IHashingProvider<T>
     /// <param name="data">An object of type <typeparamref name="T"/> to be converted to <see cref="byte"/>[].</param>
     /// <param name="cancellationToken">A cancellation token allowing the canceling of asynchronous jobs.</param>
     /// <returns>A <see cref="Task"/> representing the conversion of this document of type <typeparamref name="T"/> in the form <see cref="byte"/>[].</returns>
-    public Task<byte[]> ConvertToBytes(T data, CancellationToken cancellationToken);
+    public Task<byte[]> ConvertToBytesAsync(T data, CancellationToken cancellationToken = default);
 }

src/StringExtensions.cs

@@ -7,7 +7,7 @@ namespace HashingHandler;
 /// <summary>
 /// A class containing methods for manipulating <see cref="string"/> objects.
 /// </summary>
-public static class StringExtensions
+internal static class StringExtensions
 {
     /// <summary>
     /// Convert a <see cref="byte"/>[] to a <see cref="string"/> of hexadecimal characters.