Changed checksum to a structure as output.

Author: Redeagle48

OutSystems.NetChecksumUtils.UnitTests/NetChecksumUtils.ComputeChecksum.Tests.cs

@@ -66,13 +66,13 @@ public void ComputeChecksum_ValidInput_ReturnsCorrectHash(string algorithm, stri
             string expected = GetExpectedHash(algorithm, text);
 
             // Act
-            _sut.ComputeChecksum(algorithm, text, out string actualHex, out string actualBase64, out long ticks);
+            _sut.ComputeChecksum(algorithm, text, out Checksum checksum, out long ticks);
 
             // Assert
             Assert.Multiple(() =>
             {
-                Assert.That(actualHex, Is.EqualTo(expected), $"Hex hash mismatch for {algorithm}");
-                Assert.That(actualBase64, Is.EqualTo(GetExpectedBase64(algorithm, text)), $"Base64 hash mismatch for {algorithm}");
+                Assert.That(checksum.Hex, Is.EqualTo(expected), $"Hex hash mismatch for {algorithm}");
+                Assert.That(checksum.Base64, Is.EqualTo(GetExpectedBase64(algorithm, text)), $"Base64 hash mismatch for {algorithm}");
                 Assert.That(ticks, Is.GreaterThanOrEqualTo(0), "Duration should be non-negative.");
             });
         }
@@ -134,8 +134,8 @@ public void Methods_NullInputs_ThrowArgumentNullException()
             Assert.Multiple(() =>
             {
                 // ComputeChecksum null checks
-                Assert.Throws<ArgumentNullException>(() => _sut.ComputeChecksum(null!, "text", out _, out _, out _));
-                Assert.Throws<ArgumentNullException>(() => _sut.ComputeChecksum("SHA256", null!, out _, out _, out _));
+                Assert.Throws<ArgumentNullException>(() => _sut.ComputeChecksum(null!, "text", out _, out _));
+                Assert.Throws<ArgumentNullException>(() => _sut.ComputeChecksum("SHA256", null!, out _, out _));
 
                 // VerifyChecksum null checks
                 Assert.Throws<ArgumentNullException>(() => _sut.VerifyChecksum(null!, "text", "hash", out _, out _));
@@ -153,7 +153,7 @@ public void Methods_NullInputs_ThrowArgumentNullException()
         public void Methods_InvalidAlgorithm_ThrowsArgumentException(string invalidAlgo)
         {
             Assert.Throws<ArgumentException>(() => 
-                _sut.ComputeChecksum(invalidAlgo, "text", out _, out _, out _));
+                _sut.ComputeChecksum(invalidAlgo, "text", out _, out _));
         }
 
         #endregion

OutSystems.NetChecksumUtils/Checksum.cs

@@ -0,0 +1,33 @@
+using System;
+using OutSystems.ExternalLibraries.SDK;
+
+namespace OutSystems.NetChecksumUtils
+{
+    /// <summary>
+    /// The checksum result structure containing both Hex and Base64 representations.
+    /// </summary>
+    [OSStructure(
+        Description = "Represents a computed checksum in both hexadecimal and Base64 encodings.",
+        OriginalName = "Checksum"
+    )]
+    public struct Checksum
+    {
+        /// <summary>
+        /// Gets the hexadecimal representation of the checksum.
+        /// </summary>
+        [OSStructureField(
+            Description = "Hexadecimal representation of the checksum.",
+            OriginalName = "Hex"
+        )]
+        public string Hex;
+
+        /// <summary>
+        /// Gets the Base64 representation of the checksum.
+        /// </summary>
+        [OSStructureField(
+            Description = "Base64 representation of the checksum.",
+            OriginalName = "Base64"
+        )]
+        public string Base64;
+    }
+}

OutSystems.NetChecksumUtils/INetChecksumUtils.cs

@@ -20,10 +20,8 @@ void ComputeChecksum(
             string algorithm,
             [OSParameterAttribute(Description = "The text to compute the checksum for. The text is encoded as UTF-8 before hashing.")]
             string textToHash,
-            [OSParameterAttribute(Description = "Output parameter that receives the computed checksum as an uppercase hexadecimal string.")]
-            out string checksumText,
-            [OSParameterAttribute(Description = "Output parameter that receives the computed checksum as a Base64 string.")]
-            out string checksumBase64,
+            [OSParameterAttribute(Description = "Output parameter that receives the computed checksum (Hex + Base64).")]
+            out Checksum checksum,
             [OSParameterAttribute(Description = "Output parameter that receives the duration of the hashing operation in ticks.")]
             out long operationDuration
         );

OutSystems.NetChecksumUtils/NetChecksumUtils.cs

@@ -12,7 +12,7 @@ namespace OutSystems.NetChecksumUtils
     /// </summary>
     public class NetChecksumUtils : INetChecksumUtils
     {
-        static (byte[] HashBytes, TimeSpan Elapsed) ComputeChecksum(Func<byte[], byte[]> hashFunc, byte[] bytes)
+        static (byte[] HashBytes, TimeSpan Elapsed) ComputeHashBytes(Func<byte[], byte[]> hashFunc, byte[] bytes)
         {
             var sw = Stopwatch.StartNew();
             byte[] hashBytes = hashFunc(bytes);
@@ -59,7 +59,7 @@ private static Func<byte[], byte[]> GetHashFunction(string algorithm)
         /// <exception cref="ArgumentException">Thrown when <paramref name="algorithm"/> is not recognized/supported.</exception>
         public void ComputeChecksum(
             string algorithm, string textToHash,
-            out string checksumTextHex, out string checksumTextBase64, out long operationDurationInTicks)
+            out Checksum checksum, out long operationDurationInTicks)
         {
             // Ensure inputs are not null before proceeding
             ArgumentNullException.ThrowIfNull(algorithm);
@@ -72,11 +72,14 @@ public void ComputeChecksum(
             var hashFunc = GetHashFunction(algorithm);
 
             // 3. Execute the hashing logic and measure performance.
-            var (hashBytes, elapsed) = ComputeChecksum(hashFunc, inputBytes);
+            var (hashBytes, elapsed) = ComputeHashBytes(hashFunc, inputBytes);
 
             // 4. Assign results to output parameters (hex + base64)
-            checksumTextHex = Convert.ToHexString(hashBytes);
-            checksumTextBase64 = Convert.ToBase64String(hashBytes);
+            checksum = new Checksum
+            {
+                Hex = Convert.ToHexString(hashBytes),
+                Base64 = Convert.ToBase64String(hashBytes)
+            };
             operationDurationInTicks = elapsed.Ticks;
         }
 
@@ -110,7 +113,7 @@ public void VerifyChecksum(
 
             // 3. Measure the whole operation: hashing + comparison
             var sw = Stopwatch.StartNew();
-            var (hashBytes, _) = ComputeChecksum(hashFunc, inputBytes);
+            var (hashBytes, _) = ComputeHashBytes(hashFunc, inputBytes);
             var newHex = Convert.ToHexString(hashBytes);
             var newBase64 = Convert.ToBase64String(hashBytes);
             isValid = string.Equals(newHex, existingChecksum, StringComparison.OrdinalIgnoreCase)