Quizzer-8: Migrating to .NET 10

Quizzer-8/Quizzer/Extensions/Extensions.cs

@@ -0,0 +1,109 @@
+using Newtonsoft.Json.Linq;
+using System.IO.Compression;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Quizzer.Extensions
+{
+    public static class Extensions
+    {
+        /// <summary>
+        /// Compresses a string and returns a deflate compressed, Base64 encoded string.
+        /// </summary>
+        /// <param name="uncompressedString">String to compress</param>
+        public static string Compress(this string uncompressedString)
+        {
+            byte[] compressedBytes;
+
+            using (var uncompressedStream = new MemoryStream(Encoding.UTF8.GetBytes(uncompressedString)))
+            {
+                using (var compressedStream = new MemoryStream())
+                {
+                    // setting the leaveOpen parameter to true to ensure that compressedStream will not be closed when compressorStream is disposed
+                    // this allows compressorStream to close and flush its buffers to compressedStream and guarantees that compressedStream.ToArray() can be called afterward
+                    // although MSDN documentation states that ToArray() can be called on a closed MemoryStream, I don't want to rely on that very odd behavior should it ever change
+                    using (var compressorStream = new DeflateStream(compressedStream, CompressionLevel.Fastest, true))
+                    {
+                        uncompressedStream.CopyTo(compressorStream);
+                    }
+
+                    // call compressedStream.ToArray() after the enclosing DeflateStream has closed and flushed its buffer to compressedStream
+                    compressedBytes = compressedStream.ToArray();
+                }
+            }
+
+            return Convert.ToBase64String(compressedBytes);
+        }
+
+        /// <summary>
+        /// Decompresses a deflate compressed, Base64 encoded string and returns an uncompressed string.
+        /// </summary>
+        /// <param name="compressedString">String to decompress.</param>
+        public static string Decompress(this string compressedString)
+        {
+            byte[] decompressedBytes;
+
+            var compressedStream = new MemoryStream(Convert.FromBase64String(compressedString));
+
+            using (var decompressorStream = new DeflateStream(compressedStream, CompressionMode.Decompress))
+            {
+                using (var decompressedStream = new MemoryStream())
+                {
+                    decompressorStream.CopyTo(decompressedStream);
+
+                    decompressedBytes = decompressedStream.ToArray();
+                }
+            }
+
+            return Encoding.UTF8.GetString(decompressedBytes);
+        }
+        /// <summary>
+        /// Hashes the string using SHA256
+        /// </summary>
+        /// <param name="plaintext">
+        /// What needs to be hashed
+        /// </param>
+        /// <returns>
+        /// The hash
+        /// </returns>
+        public static string HashSHA256(this string plaintext)
+        {
+            StringBuilder Sb = new StringBuilder();
+
+            using (var hash = SHA256.Create())
+            {
+                Encoding enc = Encoding.UTF8;
+                byte[] result = hash.ComputeHash(enc.GetBytes(plaintext));
+
+                foreach (byte b in result)
+                    Sb.Append(b.ToString("x2"));
+            }
+
+            return Sb.ToString();
+        }
+        /// <summary>
+        /// Hashes the string using MD5
+        /// </summary>
+        /// <param name="plaintext">
+        /// What needs to be hashed
+        /// </param>
+        /// <returns>
+        /// The hash
+        /// </returns>
+        public static string HashMD5(this string plaintext)
+        {
+            StringBuilder Sb = new StringBuilder();
+
+            using (var hash = MD5.Create())
+            {
+                Encoding enc = Encoding.UTF8;
+                byte[] result = hash.ComputeHash(enc.GetBytes(plaintext));
+
+                foreach (byte b in result)
+                    Sb.Append(b.ToString("x2"));
+            }
+
+            return Sb.ToString();
+        }
+    }
+}

Quizzer-8/Quizzer/Extensions/IPAddressExtensions.cs

@@ -0,0 +1,56 @@
+// Original: https://learn.microsoft.com/en-us/archive/blogs/knom/ip-address-calculations-with-c-subnetmasks-networks
+using Microsoft.AspNetCore.HttpOverrides;
+using System.Net;
+
+namespace Quizzer.Extensions
+{
+    public static class IPAddressExtensions
+    {
+        public static IPAddress GetBroadcastAddress(this IPAddress address, IPAddress subnetMask)
+        {
+            byte[] ipAdressBytes = address.GetAddressBytes();
+            byte[] subnetMaskBytes = subnetMask.GetAddressBytes();
+
+            if (ipAdressBytes.Length != subnetMaskBytes.Length)
+                throw new ArgumentException("Lengths of IP address and subnet mask do not match.");
+
+            byte[] broadcastAddress = new byte[ipAdressBytes.Length];
+            for (int i = 0; i < broadcastAddress.Length; i++)
+            {
+                broadcastAddress[i] = (byte)(ipAdressBytes[i] | (subnetMaskBytes[i] ^ 255));
+            }
+            return new IPAddress(broadcastAddress);
+        }
+
+        public static IPAddress GetNetworkAddress(this IPAddress address, IPAddress subnetMask)
+        {
+            byte[] ipAdressBytes = address.GetAddressBytes();
+            byte[] subnetMaskBytes = subnetMask.GetAddressBytes();
+
+            if (ipAdressBytes.Length != subnetMaskBytes.Length)
+                throw new ArgumentException("Lengths of IP address and subnet mask do not match.");
+
+            byte[] broadcastAddress = new byte[ipAdressBytes.Length];
+            for (int i = 0; i < broadcastAddress.Length; i++)
+            {
+                broadcastAddress[i] = (byte)(ipAdressBytes[i] & (subnetMaskBytes[i]));
+            }
+            return new IPAddress(broadcastAddress);
+        }
+
+        /// <summary>
+        /// Are addressA on the same network as addressB ?
+        /// </summary>
+        /// <param name="addressA"></param>
+        /// <param name="addressB"></param>
+        /// <param name="subnetMask"></param>
+        /// <returns>True if A and B are on the same network.</returns>
+        public static bool IsInSameSubnet(this IPAddress addressA, IPAddress addressB, IPAddress subnetMask)
+        {
+            IPAddress networkA = addressA.GetNetworkAddress(subnetMask);
+            IPAddress networkB = addressB.GetNetworkAddress(subnetMask);
+
+            return networkA.Equals(networkB);
+        }
+    }
+}