From 9f85fdadd043312af6699d71401e035d3fd73668 Mon Sep 17 00:00:00 2001
From: Eduard Sergeev <eduard.sergeev@gmail.com>
Date: Thu, 7 Jul 2022 21:13:51 +1000
Subject: [PATCH 1/4] Add hardware accelerated implementations

- Force.Crc32.Intrinsics.Crc32Algorithm - CRC32 (supported by ARM)
- Force.Crc32.Intrinsics.Crc32CAlgorithm - CRC32A (supported by Intel and ARM)
---
 Crc32.NET/Crc32.NET.Core.csproj         |   6 +-
 Crc32.NET/Intrinsics/Crc32Algorithm.cs  | 112 ++++++++++++++++++
 Crc32.NET/Intrinsics/Crc32CAlgorithm.cs | 149 ++++++++++++++++++++++++
 Crc32.NET/Intrinsics/Platform.cs        |  19 +++
 4 files changed, 283 insertions(+), 3 deletions(-)
 create mode 100644 Crc32.NET/Intrinsics/Crc32Algorithm.cs
 create mode 100644 Crc32.NET/Intrinsics/Crc32CAlgorithm.cs
 create mode 100644 Crc32.NET/Intrinsics/Platform.cs

diff --git a/Crc32.NET/Crc32.NET.Core.csproj b/Crc32.NET/Crc32.NET.Core.csproj
index cec1661..54842b5 100644
--- a/Crc32.NET/Crc32.NET.Core.csproj
+++ b/Crc32.NET/Crc32.NET.Core.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <VersionPrefix>1.2.1</VersionPrefix>
-    <TargetFrameworks>netstandard1.3;netstandard2.0;net20</TargetFrameworks>
+    <VersionPrefix>1.3.0</VersionPrefix>
+    <TargetFrameworks>netstandard1.3;netstandard2.0;net20;net5.0;net6.0</TargetFrameworks>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <AssemblyName>Crc32.NET</AssemblyName>
     <!--DelaySign>true</DelaySign>
@@ -32,4 +32,4 @@
   <ItemGroup Condition=" '$(TargetFramework)' == 'net20' ">
     <Reference Include="System" />
   </ItemGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/Crc32.NET/Intrinsics/Crc32Algorithm.cs b/Crc32.NET/Intrinsics/Crc32Algorithm.cs
new file mode 100644
index 0000000..14d5a17
--- /dev/null
+++ b/Crc32.NET/Intrinsics/Crc32Algorithm.cs
@@ -0,0 +1,112 @@
+using System;
+using System.Security.Cryptography;
+
+#if NET5_0_OR_GREATER
+using Arm32 = System.Runtime.Intrinsics.Arm.Crc32;
+using Arm64 = System.Runtime.Intrinsics.Arm.Crc32.Arm64;
+#endif
+
+namespace Force.Crc32.Intrinsics
+{
+    /// <summary>
+    /// The hardware implementation of the CRC32-C polynomial 
+    /// implemented on Intel CPUs supporting SSE4.2.
+    /// </summary>
+    public class Crc32Algorithm : HashAlgorithm
+    {
+        /// <summary>
+        /// the current CRC value, bit-flipped
+        /// </summary>
+        private uint _crc;
+
+        /// <summary>
+        /// Default constructor
+        /// </summary>
+        public Crc32Algorithm()
+        {
+            // The size, in bits, of the computed hash code.
+            this.HashSizeValue = 32;
+            this.Reset();
+        }
+
+        /// <summary>Initializes an implementation of the <see cref="T:System.Security.Cryptography.HashAlgorithm"></see> class.</summary>
+        public override void Initialize()
+        {
+            this.Reset();
+        }
+
+		/// <summary>
+		/// Computes CRC-32C from input buffer.
+		/// </summary>
+		/// <param name="input">Input buffer containing data to be checksummed.</param>
+		/// <returns>CRC-32C of the buffer.</returns>
+        public static uint Compute(byte[] input)
+		{
+			var algo = new Crc32Algorithm();
+            algo.HashCore(input);
+            return ~algo._crc;
+		}
+
+
+        /// <summary>When overridden in a derived class, routes data written to the object into the hash algorithm for computing the hash.</summary>
+        /// <param name="array">The input to compute the hash code for.</param>
+        /// <param name="ibStart">The offset into the byte array from which to begin using data.</param>
+        /// <param name="cbSize">The number of bytes in the byte array to use as data.</param>
+        protected override void HashCore(byte[] array, int ibStart, int cbSize)
+        {
+            switch(Platform)
+            {
+                case Platform.Arm64:
+                case Platform.Arm32:
+                    HashCoreArm(array, ibStart, cbSize);
+                    break;
+                default:
+                    throw new NotSupportedException("CRC32 intrinsics are not suppored on this platform");
+            }
+        }
+
+        /// <summary>When overridden in a derived class, finalizes the hash computation after the last data is processed by the cryptographic stream object.</summary>
+        /// <returns>The computed hash code.</returns>
+        protected override byte[] HashFinal()
+        {
+            uint outputCrcValue = ~_crc;
+
+            return BitConverter.GetBytes(outputCrcValue);
+        }
+
+
+        private void HashCoreArm(byte[] array, int ibStart, int cbSize)
+        {
+#if NET5_0_OR_GREATER
+            if (Platform == Platform.Arm64)
+            {
+                while (cbSize >= 8)
+                {
+                    _crc = Arm64.ComputeCrc32(_crc, BitConverter.ToUInt64(array, ibStart));
+                    ibStart += 8;
+                    cbSize -= 8;
+                }
+            }
+
+            while (cbSize > 0)
+            {
+                _crc = Arm32.ComputeCrc32(_crc, array[ibStart]);
+                ibStart++;
+                cbSize--;
+            }
+#endif
+        }
+
+        private static Platform Platform =>
+#if NET5_0_OR_GREATER
+            Arm64.IsSupported ? Platform.Arm64 :
+            Arm32.IsSupported ? Platform.Arm32 :
+#endif
+            Platform.Unsupported;
+
+        private void Reset()
+        {
+            _crc = uint.MaxValue;
+        }
+    }
+}
diff --git a/Crc32.NET/Intrinsics/Crc32CAlgorithm.cs b/Crc32.NET/Intrinsics/Crc32CAlgorithm.cs
new file mode 100644
index 0000000..09d1ed3
--- /dev/null
+++ b/Crc32.NET/Intrinsics/Crc32CAlgorithm.cs
@@ -0,0 +1,149 @@
+using System;
+using System.Security.Cryptography;
+
+#if NETCOREAPP3_0_OR_GREATER
+using X86 = System.Runtime.Intrinsics.X86.Sse42;
+using X64 = System.Runtime.Intrinsics.X86.Sse42.X64;
+#endif
+
+#if NET5_0_OR_GREATER
+using Arm32 = System.Runtime.Intrinsics.Arm.Crc32;
+using Arm64 = System.Runtime.Intrinsics.Arm.Crc32.Arm64;
+#endif
+
+namespace Force.Crc32.Intrinsics
+{
+    /// <summary>
+    /// The hardware implementation of the CRC32-C polynomial 
+    /// implemented on Intel CPUs supporting SSE4.2.
+    /// </summary>
+    public class Crc32CAlgorithm : HashAlgorithm
+    {
+        /// <summary>
+        /// the current CRC value, bit-flipped
+        /// </summary>
+        private uint _crc;
+
+        /// <summary>
+        /// Default constructor
+        /// </summary>
+        public Crc32CAlgorithm()
+        {
+            // The size, in bits, of the computed hash code.
+            this.HashSizeValue = 32;
+            this.Reset();
+        }
+
+        /// <summary>Initializes an implementation of the <see cref="T:System.Security.Cryptography.HashAlgorithm"></see> class.</summary>
+        public override void Initialize()
+        {
+            this.Reset();
+        }
+
+		/// <summary>
+		/// Computes CRC-32C from input buffer.
+		/// </summary>
+		/// <param name="input">Input buffer containing data to be checksummed.</param>
+		/// <returns>CRC-32C of the buffer.</returns>
+        public static uint Compute(byte[] input)
+		{
+			var algo = new Crc32CAlgorithm();
+            algo.HashCore(input);
+            return ~algo._crc;
+		}
+
+
+        /// <summary>When overridden in a derived class, routes data written to the object into the hash algorithm for computing the hash.</summary>
+        /// <param name="array">The input to compute the hash code for.</param>
+        /// <param name="ibStart">The offset into the byte array from which to begin using data.</param>
+        /// <param name="cbSize">The number of bytes in the byte array to use as data.</param>
+        protected override void HashCore(byte[] array, int ibStart, int cbSize)
+        {
+            switch(Platform)
+            {
+                case Platform.X64:
+                case Platform.X86:
+                    HashCoreX86(array, ibStart, cbSize);
+                    break;
+                case Platform.Arm64:
+                case Platform.Arm32:
+                    HashCoreArm(array, ibStart, cbSize);
+                    break;
+                default:
+                    throw new NotSupportedException("CRC32 intrinsics are not suppored on this platform");
+            }
+        }
+
+        private void HashCoreX86(byte[] array, int ibStart, int cbSize)
+        {
+#if NETCOREAPP3_0_OR_GREATER
+            if (Platform == Platform.X64)
+            {
+                ulong crc = _crc;
+                while (cbSize >= 8)
+                {
+                    crc = X64.Crc32(crc, BitConverter.ToUInt64(array, ibStart));
+                    ibStart += 8;
+                    cbSize -= 8;
+                }
+                _crc = (uint)crc;
+            }
+
+            while (cbSize > 0)
+            {
+                _crc = X86.Crc32(_crc, array[ibStart]);
+                ibStart++;
+                cbSize--;
+            }
+#endif
+        }
+
+        private void HashCoreArm(byte[] array, int ibStart, int cbSize)
+        {
+#if NET5_0_OR_GREATER
+            if (Platform == Platform.Arm64)
+            {
+                while (cbSize >= 8)
+                {
+                    _crc = Arm64.ComputeCrc32C(_crc, BitConverter.ToUInt64(array, ibStart));
+                    ibStart += 8;
+                    cbSize -= 8;
+                }
+            }
+
+            while (cbSize > 0)
+            {
+                _crc = Arm32.ComputeCrc32C(_crc, array[ibStart]);
+                ibStart++;
+                cbSize--;
+            }
+#endif
+        }
+
+
+        /// <summary>When overridden in a derived class, finalizes the hash computation after the last data is processed by the cryptographic stream object.</summary>
+        /// <returns>The computed hash code.</returns>
+        protected override byte[] HashFinal()
+        {
+            uint outputCrcValue = ~_crc;
+
+            return BitConverter.GetBytes(outputCrcValue);
+        }
+
+        private static Platform Platform =>
+#if NETCOREAPP3_0_OR_GREATER
+            X64.IsSupported ? Platform.X64 :
+            X86.IsSupported ? Platform.X86 :
+#endif
+#if NET5_0_OR_GREATER
+            Arm64.IsSupported ? Platform.Arm64 :
+            Arm32.IsSupported ? Platform.Arm32 :
+#endif
+            Platform.Unsupported;
+
+        private void Reset()
+        {
+            _crc = uint.MaxValue;
+        }
+    }
+}
diff --git a/Crc32.NET/Intrinsics/Platform.cs b/Crc32.NET/Intrinsics/Platform.cs
new file mode 100644
index 0000000..542fd5d
--- /dev/null
+++ b/Crc32.NET/Intrinsics/Platform.cs
@@ -0,0 +1,19 @@
+namespace Force.Crc32.Intrinsics
+{
+    /// <summary>
+    /// Hardware intrinsics platforms supported by the current CPU
+    /// </summary>
+    public enum Platform
+    {
+        /// Hardware intrinsics are not supported on this CPU
+        Unsupported,
+        /// Intel SSE4.2 hardware instructions
+        X86,
+        /// Intel SSE4.2 x64 hardware instructions
+        X64,
+        /// ARM Crc32 hardware instructions
+        Arm32,
+        /// ARM64 Crc32 hardware instructions
+        Arm64,
+    }
+}

From e2950c41fc771af1fbf848b85da25b047b230208 Mon Sep 17 00:00:00 2001
From: Eduard Sergeev <eduard.sergeev@gmail.com>
Date: Sat, 9 Jul 2022 16:14:38 +1000
Subject: [PATCH 2/4] Update tests

Add unit and performance tests for intrinsics implementations
---
 Crc32.NET.Tests/BytePatternsTest.cs           |   4 +-
 Crc32.NET.Tests/Crc32.NET.Tests.Core.csproj   |   4 +-
 .../Crc32Implementations/CH_Crc32_Crc.cs      |   4 +-
 .../Crc32C_Crc32CAlgorithm.cs                 |   4 +-
 .../Crc32Implementations/Crc32C_Standard.cs   |   4 +-
 .../Crc32_Crc32Algorithm.cs                   |   4 +-
 .../Crc32Implementations/CrcCalculator.cs     |   5 +-
 .../Dexiom_Quick_Crc32.cs                     |   4 +-
 .../Force_Intrinsics_Crc32_Crc32Algorithm.cs  |  17 ++
 .../Force_Intrinsics_Crc32_Crc32CAlgorithm.cs |  17 ++
 .../Klinkby_Checkum_Crc32.cs                  |   4 +-
 .../System_Data_HashFunction_CRC.cs           |   4 +-
 Crc32.NET.Tests/ImplementationCTest.cs        |  29 +++-
 Crc32.NET.Tests/ImplementationTest.cs         |  29 +++-
 Crc32.NET.Tests/PerformanceTest.cs            |  25 ++-
 Crc32.NET.Tests/Program.cs                    |   9 +-
 Crc32.NET/Crc32.NET.Core.csproj               |   1 +
 Crc32.NET/Intrinsics/Crc32Algorithm.cs        |  96 ++++++++---
 Crc32.NET/Intrinsics/Crc32CAlgorithm.cs       | 154 ++++++++++++------
 19 files changed, 312 insertions(+), 106 deletions(-)
 create mode 100644 Crc32.NET.Tests/Crc32Implementations/Force_Intrinsics_Crc32_Crc32Algorithm.cs
 create mode 100644 Crc32.NET.Tests/Crc32Implementations/Force_Intrinsics_Crc32_Crc32CAlgorithm.cs

diff --git a/Crc32.NET.Tests/BytePatternsTest.cs b/Crc32.NET.Tests/BytePatternsTest.cs
index 02bb874..4651136 100644
--- a/Crc32.NET.Tests/BytePatternsTest.cs
+++ b/Crc32.NET.Tests/BytePatternsTest.cs
@@ -1,4 +1,4 @@
-#if !NETCORE
+#if NETFRAMEWORK
 using System;
 using System.Linq;
 using Force.Crc32.Tests.Crc32Implementations;
@@ -91,4 +91,4 @@ private void TestByteSequence(byte[] data)
 	}
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/Crc32.NET.Tests/Crc32.NET.Tests.Core.csproj b/Crc32.NET.Tests/Crc32.NET.Tests.Core.csproj
index abd6655..e31bd0e 100644
--- a/Crc32.NET.Tests/Crc32.NET.Tests.Core.csproj
+++ b/Crc32.NET.Tests/Crc32.NET.Tests.Core.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netcoreapp1.0;netcoreapp2.0;net461</TargetFrameworks>
+    <TargetFrameworks>netcoreapp1.0;netcoreapp2.0;net461;net5.0;net6.0</TargetFrameworks>
     <DebugType>portable</DebugType>
     <AssemblyName>Crc32.NET.Tests</AssemblyName>
     <OutputType>Exe</OutputType>
@@ -43,4 +43,4 @@
   <PropertyGroup>
     <DefineConstants>$(DefineConstants);COREVERSION</DefineConstants>
   </PropertyGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/Crc32.NET.Tests/Crc32Implementations/CH_Crc32_Crc.cs b/Crc32.NET.Tests/Crc32Implementations/CH_Crc32_Crc.cs
index 6699a19..c7eae41 100644
--- a/Crc32.NET.Tests/Crc32Implementations/CH_Crc32_Crc.cs
+++ b/Crc32.NET.Tests/Crc32Implementations/CH_Crc32_Crc.cs
@@ -1,4 +1,4 @@
-#if !NETCORE
+#if NETFRAMEWORK
 
 namespace Force.Crc32.Tests.Crc32Implementations
 {
@@ -14,4 +14,4 @@ public override uint Calculate(byte[] data)
 		}
 	}
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/Crc32.NET.Tests/Crc32Implementations/Crc32C_Crc32CAlgorithm.cs b/Crc32.NET.Tests/Crc32Implementations/Crc32C_Crc32CAlgorithm.cs
index 175ef8b..e522985 100644
--- a/Crc32.NET.Tests/Crc32Implementations/Crc32C_Crc32CAlgorithm.cs
+++ b/Crc32.NET.Tests/Crc32Implementations/Crc32C_Crc32CAlgorithm.cs
@@ -1,4 +1,4 @@
-#if !NETCORE
+#if NETFRAMEWORK
 namespace Force.Crc32.Tests.Crc32Implementations
 {
 	public class Crc32C_Crc32CAlgorithm : CrcCalculator
@@ -13,4 +13,4 @@ public override uint Calculate(byte[] data)
 		}
 	}
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/Crc32.NET.Tests/Crc32Implementations/Crc32C_Standard.cs b/Crc32.NET.Tests/Crc32Implementations/Crc32C_Standard.cs
index e9226f7..5920265 100644
--- a/Crc32.NET.Tests/Crc32Implementations/Crc32C_Standard.cs
+++ b/Crc32.NET.Tests/Crc32Implementations/Crc32C_Standard.cs
@@ -1,4 +1,4 @@
-#if NETCORE
+#if !NETFRAMEWORK
 namespace Force.Crc32.Tests.Crc32Implementations
 {
 	public class Crc32C_Standard : CrcCalculator
@@ -15,4 +15,4 @@ public override uint Calculate(byte[] data)
 		}
 	}
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/Crc32.NET.Tests/Crc32Implementations/Crc32_Crc32Algorithm.cs b/Crc32.NET.Tests/Crc32Implementations/Crc32_Crc32Algorithm.cs
index a034074..04f95b3 100644
--- a/Crc32.NET.Tests/Crc32Implementations/Crc32_Crc32Algorithm.cs
+++ b/Crc32.NET.Tests/Crc32Implementations/Crc32_Crc32Algorithm.cs
@@ -1,4 +1,4 @@
-#if !NETCORE
+#if NETFRAMEWORK
 using Crc = Crc32.Crc32Algorithm;
 
 namespace Force.Crc32.Tests.Crc32Implementations
@@ -15,4 +15,4 @@ public override uint Calculate(byte[] data)
 		}
 	}
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/Crc32.NET.Tests/Crc32Implementations/CrcCalculator.cs b/Crc32.NET.Tests/Crc32Implementations/CrcCalculator.cs
index dad7ab5..9e7a301 100644
--- a/Crc32.NET.Tests/Crc32Implementations/CrcCalculator.cs
+++ b/Crc32.NET.Tests/Crc32Implementations/CrcCalculator.cs
@@ -2,13 +2,16 @@
 {
 	public abstract class CrcCalculator
 	{
-		protected CrcCalculator(string name)
+		protected CrcCalculator(string name, bool isSupported = true)
 		{
 			Name = name;
+			IsSupported = isSupported;
 		}
 
 		public string Name { get; private set; }
 
+		public bool IsSupported { get; private set; }
+
 		public abstract uint Calculate(byte[] data);
 	}
 }
diff --git a/Crc32.NET.Tests/Crc32Implementations/Dexiom_Quick_Crc32.cs b/Crc32.NET.Tests/Crc32Implementations/Dexiom_Quick_Crc32.cs
index 62512b1..77e28f3 100644
--- a/Crc32.NET.Tests/Crc32Implementations/Dexiom_Quick_Crc32.cs
+++ b/Crc32.NET.Tests/Crc32Implementations/Dexiom_Quick_Crc32.cs
@@ -1,4 +1,4 @@
-#if !NETCORE
+#if NETFRAMEWORK
 namespace Force.Crc32.Tests.Crc32Implementations
 {
 	public class Dexiom_Quick_Crc32 : CrcCalculator
@@ -14,4 +14,4 @@ public override uint Calculate(byte[] data)
 		}
 	}
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/Crc32.NET.Tests/Crc32Implementations/Force_Intrinsics_Crc32_Crc32Algorithm.cs b/Crc32.NET.Tests/Crc32Implementations/Force_Intrinsics_Crc32_Crc32Algorithm.cs
new file mode 100644
index 0000000..9aa37f9
--- /dev/null
+++ b/Crc32.NET.Tests/Crc32Implementations/Force_Intrinsics_Crc32_Crc32Algorithm.cs
@@ -0,0 +1,17 @@
+namespace Force.Crc32.Tests.Crc32Implementations
+{
+	using Algorithm = Force.Crc32.Intrinsics.Crc32Algorithm;
+
+	public class Force_Intrinsics_Crc32_Crc32Algorithm : CrcCalculator
+	{
+		public Force_Intrinsics_Crc32_Crc32Algorithm()
+			: base("Force.Crc32.Intrinsics.Crc32Algorithm", Algorithm.IsSupported)
+		{
+		}
+
+		public override uint Calculate(byte[] data)
+		{
+			return Algorithm.Compute(data);
+		}
+	}
+}
diff --git a/Crc32.NET.Tests/Crc32Implementations/Force_Intrinsics_Crc32_Crc32CAlgorithm.cs b/Crc32.NET.Tests/Crc32Implementations/Force_Intrinsics_Crc32_Crc32CAlgorithm.cs
new file mode 100644
index 0000000..0dc0111
--- /dev/null
+++ b/Crc32.NET.Tests/Crc32Implementations/Force_Intrinsics_Crc32_Crc32CAlgorithm.cs
@@ -0,0 +1,17 @@
+namespace Force.Crc32.Tests.Crc32Implementations
+{
+	using Algorithm = Force.Crc32.Intrinsics.Crc32CAlgorithm;
+	
+	public class Force_Intrinsics_Crc32_Crc32CAlgorithm : CrcCalculator
+	{
+		public Force_Intrinsics_Crc32_Crc32CAlgorithm()
+			: base("Force.Crc32.Intrinsics.Crc32CAlgorithm", Algorithm.IsSupported)
+		{
+		}
+
+		public override uint Calculate(byte[] data)
+		{
+			return Algorithm.Compute(data);
+		}
+	}
+}
diff --git a/Crc32.NET.Tests/Crc32Implementations/Klinkby_Checkum_Crc32.cs b/Crc32.NET.Tests/Crc32Implementations/Klinkby_Checkum_Crc32.cs
index d846ec2..ccd2d8c 100644
--- a/Crc32.NET.Tests/Crc32Implementations/Klinkby_Checkum_Crc32.cs
+++ b/Crc32.NET.Tests/Crc32Implementations/Klinkby_Checkum_Crc32.cs
@@ -1,4 +1,4 @@
-#if !NETCORE
+#if NETFRAMEWORK
 namespace Force.Crc32.Tests.Crc32Implementations
 {
 	public class Klinkby_Checkum_Crc32 : CrcCalculator
@@ -13,4 +13,4 @@ public override uint Calculate(byte[] data)
 		}
 	}
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/Crc32.NET.Tests/Crc32Implementations/System_Data_HashFunction_CRC.cs b/Crc32.NET.Tests/Crc32Implementations/System_Data_HashFunction_CRC.cs
index fd1bb48..37f2fc7 100644
--- a/Crc32.NET.Tests/Crc32Implementations/System_Data_HashFunction_CRC.cs
+++ b/Crc32.NET.Tests/Crc32Implementations/System_Data_HashFunction_CRC.cs
@@ -1,4 +1,4 @@
-#if !NETCORE
+#if NETFRAMEWORK
 using System;
 using System.Data.HashFunction;
 
@@ -19,4 +19,4 @@ public override uint Calculate(byte[] data)
 		private readonly CRC _crc;
 	}
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/Crc32.NET.Tests/ImplementationCTest.cs b/Crc32.NET.Tests/ImplementationCTest.cs
index 90735de..15eef0e 100644
--- a/Crc32.NET.Tests/ImplementationCTest.cs
+++ b/Crc32.NET.Tests/ImplementationCTest.cs
@@ -4,16 +4,16 @@
 
 using NUnit.Framework;
 
-#if !NETCORE
+#if NETFRAMEWORK
 using E = Crc32C.Crc32CAlgorithm;
 #endif
 
+
 namespace Force.Crc32.Tests
 {
 	[TestFixture]
 	public class ImplementationCTest
 	{
-#if !NETCORE
 		[TestCase("Hello", 3)]
 		[TestCase("Nazdar", 0)]
 		[TestCase("Ahoj", 1)]
@@ -23,11 +23,20 @@ public void ResultConsistency(string text, int offset)
 		{
 			var bytes = Encoding.ASCII.GetBytes(text);
 
+#if NETFRAMEWORK
 			var crc1 = E.Compute(bytes.Skip(offset).ToArray());
 			var crc2 = Crc32CAlgorithm.Append(0, bytes, offset, bytes.Length - offset);
 			Assert.That(crc2, Is.EqualTo(crc1));
-		}
+#elif NETCOREAPP3_0_OR_GREATER
+			if(Intrinsics.Crc32CAlgorithm.IsSupported)
+			{
+				var crc32C = new Ralph.Crc32C.Crc32C();
+				crc32C.Update(bytes, offset, bytes.Length - offset);
+				var crc3 = Intrinsics.Crc32CAlgorithm.Compute(bytes, offset, bytes.Length - offset);
+				Assert.That(crc3, Is.EqualTo(crc32C.GetIntValue()));
+			}
 #endif
+		}
 
 		[Test]
 		public void ResultConsistency2()
@@ -36,7 +45,19 @@ public void ResultConsistency2()
 			Assert.That(Crc32CAlgorithm.Compute(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }), Is.EqualTo(0xB219DB69));
 		}
 
-#if !NETCORE
+#if NETCOREAPP3_0_OR_GREATER
+		[Test]
+		public void ResultConsistencyIntrinsics()
+		{
+			if(Intrinsics.Crc32CAlgorithm.IsSupported)
+			{
+				Assert.That(Intrinsics.Crc32CAlgorithm.Compute(new byte[] { 1 }), Is.EqualTo(0xA016D052));
+				Assert.That(Intrinsics.Crc32CAlgorithm.Compute(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }), Is.EqualTo(0xB219DB69));
+			}
+		}
+#endif
+
+#if NETFRAMEWORK
 		[Test]
 		public void ResultConsistencyAsHashAlgorithm()
 		{
diff --git a/Crc32.NET.Tests/ImplementationTest.cs b/Crc32.NET.Tests/ImplementationTest.cs
index 7bfe6da..e42a400 100644
--- a/Crc32.NET.Tests/ImplementationTest.cs
+++ b/Crc32.NET.Tests/ImplementationTest.cs
@@ -4,7 +4,7 @@
 
 using NUnit.Framework;
 
-#if !NETCORE
+#if NETFRAMEWORK
 using E = Crc32.Crc32Algorithm;
 #endif
 
@@ -15,7 +15,6 @@ namespace Force.Crc32.Tests
 	public class ImplementationTest
 	{
 
-#if !NETCORE
 		[TestCase("Hello", 3)]
 		[TestCase("Nazdar", 0)]
 		[TestCase("Ahoj", 1)]
@@ -25,11 +24,20 @@ public void ResultConsistency(string text, int offset)
 		{
 			var bytes = Encoding.ASCII.GetBytes(text);
 
+#if NETFRAMEWORK
 			var crc1 = E.Compute(bytes.Skip(offset).ToArray());
 			var crc2 = Crc32Algorithm.Append(0, bytes, offset, bytes.Length - offset);
 			Assert.That(crc2, Is.EqualTo(crc1));
-		}
 #endif
+#if NET5_0_OR_GREATER
+			if(Intrinsics.Crc32Algorithm.IsSupported)
+			{
+				var crc1 = K4os.Hash.Crc.Crc32.DigestOf(bytes, offset, bytes.Length - offset);
+				var crc2 = Intrinsics.Crc32Algorithm.Compute(bytes, offset, bytes.Length - offset);
+				Assert.That(crc2, Is.EqualTo(crc1));
+			}
+#endif
+		}
 		
 		[Test]
 		public void ResultConsistency2()
@@ -38,7 +46,20 @@ public void ResultConsistency2()
 			Assert.That(Crc32Algorithm.Compute(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }), Is.EqualTo(622876539));
 		}
 
-#if !NETCORE
+#if NET5_0_OR_GREATER
+		[Test]
+		public void ResultConsistencyIntrinsics()
+		{
+			if(Intrinsics.Crc32Algorithm.IsSupported)
+			{
+				Assert.That(Intrinsics.Crc32Algorithm.Compute(new byte[] { 1 }), Is.EqualTo(2768625435));
+				Assert.That(Intrinsics.Crc32Algorithm.Compute(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }), Is.EqualTo(622876539));
+			}
+		}
+#endif
+
+
+#if NETFRAMEWORK
 		[Test]
 		public void ResultConsistencyAsHashAlgorithm()
 		{
diff --git a/Crc32.NET.Tests/PerformanceTest.cs b/Crc32.NET.Tests/PerformanceTest.cs
index 5b96338..fb1b6d1 100644
--- a/Crc32.NET.Tests/PerformanceTest.cs
+++ b/Crc32.NET.Tests/PerformanceTest.cs
@@ -8,7 +8,7 @@ namespace Force.Crc32.Tests
 	[TestFixture]
 	public class PerformanceTest
 	{
-#if !NETCORE
+#if NETFRAMEWORK
 		[Test]
 		public void ThroughputCHCrc32_By_tanglebones()
 		{
@@ -70,7 +70,23 @@ public void ThroughputCrc32C_By_Me()
 			Calculate(new Force_Crc32_Crc32CAlgorithm());
 		}
 
-#if COREVERSION && !NETCORE13
+#if NETCOREAPP3_0_OR_GREATER
+		[Test]
+		public void ThroughputCrc32C_By_Me_Intrinsics()
+		{
+			Calculate(new Force_Intrinsics_Crc32_Crc32CAlgorithm());
+		}
+#endif
+
+#if NET5_0_OR_GREATER
+		[Test]
+		public void ThroughputCrc32_By_Me_Intrinsics()
+		{
+			Calculate(new Force_Intrinsics_Crc32_Crc32Algorithm());
+		}
+#endif
+
+#if COREVERSION && NETFRAMEWORK13
 		[Test]
 		public void ThroughputCrc32C_By_K4os_Hash_Crc()
 		{
@@ -80,6 +96,11 @@ public void ThroughputCrc32C_By_K4os_Hash_Crc()
 
 		private void Calculate(CrcCalculator implementation, int size = 65536)
 		{
+			if(!implementation.IsSupported)
+			{
+				return;
+			}
+
 			var data = new byte[size];
 			var random = new Random();
 			random.NextBytes(data);
diff --git a/Crc32.NET.Tests/Program.cs b/Crc32.NET.Tests/Program.cs
index 3538919..2d47edb 100644
--- a/Crc32.NET.Tests/Program.cs
+++ b/Crc32.NET.Tests/Program.cs
@@ -5,7 +5,7 @@ public static class Program
 		public static void Main()
 		{
 			var pt = new PerformanceTest();
-#if !NETCORE
+#if NETFRAMEWORK
 			pt.ThroughputCrc32_By_dariogriffo();
 			pt.ThroughputCHCrc32_By_tanglebones();
             pt.ThroughputKlinkby_Checksum();
@@ -19,8 +19,13 @@ public static void Main()
 			pt.ThroughputCrc32C_Standard();
 			pt.ThroughputCrc32C_By_Me();
 			pt.ThroughputCrc32_By_Me();
+#if NETCOREAPP3_0_OR_GREATER
+			pt.ThroughputCrc32C_By_Me_Intrinsics();
+#endif
+#if NET5_0_OR_GREATER
+			pt.ThroughputCrc32_By_Me_Intrinsics();
+#endif
 #endif
-
         }
     }
 }
diff --git a/Crc32.NET/Crc32.NET.Core.csproj b/Crc32.NET/Crc32.NET.Core.csproj
index 54842b5..d189354 100644
--- a/Crc32.NET/Crc32.NET.Core.csproj
+++ b/Crc32.NET/Crc32.NET.Core.csproj
@@ -12,6 +12,7 @@
     <NetStandardImplicitPackageVersion Condition=" '$(TargetFramework)' == 'netstandard1.3' ">1.6.1</NetStandardImplicitPackageVersion>
     <NetStandardImplicitPackageVersion Condition=" '$(TargetFramework)' == 'netstandard2.0' ">2.0.0</NetStandardImplicitPackageVersion>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'BuildCore' ">
     <DelaySign>true</DelaySign>
diff --git a/Crc32.NET/Intrinsics/Crc32Algorithm.cs b/Crc32.NET/Intrinsics/Crc32Algorithm.cs
index 14d5a17..8d052e5 100644
--- a/Crc32.NET/Intrinsics/Crc32Algorithm.cs
+++ b/Crc32.NET/Intrinsics/Crc32Algorithm.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Security.Cryptography;
-
 #if NET5_0_OR_GREATER
 using Arm32 = System.Runtime.Intrinsics.Arm.Crc32;
 using Arm64 = System.Runtime.Intrinsics.Arm.Crc32.Arm64;
@@ -9,8 +8,8 @@
 namespace Force.Crc32.Intrinsics
 {
     /// <summary>
-    /// The hardware implementation of the CRC32-C polynomial 
-    /// implemented on Intel CPUs supporting SSE4.2.
+    /// The hardware implementation of the CRC32 polynomial supported by:
+    /// - ARM CPUs since ARMv8.1 
     /// </summary>
     public class Crc32Algorithm : HashAlgorithm
     {
@@ -24,37 +23,59 @@ public class Crc32Algorithm : HashAlgorithm
         /// </summary>
         public Crc32Algorithm()
         {
-            // The size, in bits, of the computed hash code.
+#if NETSTANDARD2_0_OR_GREATER
             this.HashSizeValue = 32;
+#endif
             this.Reset();
         }
 
-        /// <summary>Initializes an implementation of the <see cref="T:System.Security.Cryptography.HashAlgorithm"></see> class.</summary>
+        /// <summary>
+        /// Check if the algorithm is supported on the current CPU
+        /// </summary>
+        public static bool IsSupported => Platform != Platform.Unsupported;
+
+        /// <summary>
+        /// Initializes an implementation of the <see cref="T:System.Security.Cryptography.HashAlgorithm" /> class
+        /// </summary>
         public override void Initialize()
         {
             this.Reset();
         }
 
-		/// <summary>
-		/// Computes CRC-32C from input buffer.
-		/// </summary>
-		/// <param name="input">Input buffer containing data to be checksummed.</param>
-		/// <returns>CRC-32C of the buffer.</returns>
+        /// <summary>
+        /// Computes CRC32 from input buffer.
+        /// </summary>
+        /// <param name="input">Input buffer with data to be checksummed.</param>
+        /// <returns>CRC32 of the data in the buffer.</returns>
         public static uint Compute(byte[] input)
-		{
-			var algo = new Crc32Algorithm();
-            algo.HashCore(input);
+        {
+            return Compute(input, 0, input.Length);
+        }
+
+        /// <summary>
+        /// Computes CRC32 from input buffer.
+        /// </summary>
+        /// <param name="input">Input buffer with data to be checksummed.</param>
+        /// <param name="offset">Offset of the input data within the buffer.</param>
+        /// <param name="length">Length of the input data in the buffer.</param>
+        /// <returns>CRC32 of the data in the buffer.</returns>
+        public static uint Compute(byte[] input, int offset, int length)
+        {
+            var algo = new Crc32Algorithm();
+            algo.HashCore(input, offset, length);
             return ~algo._crc;
-		}
+        }
 
 
-        /// <summary>When overridden in a derived class, routes data written to the object into the hash algorithm for computing the hash.</summary>
+        /// <summary>
+        /// When overridden in a derived class, routes data written to the object into the hash algorithm for computing the hash
+        /// </summary>
         /// <param name="array">The input to compute the hash code for.</param>
         /// <param name="ibStart">The offset into the byte array from which to begin using data.</param>
         /// <param name="cbSize">The number of bytes in the byte array to use as data.</param>
         protected override void HashCore(byte[] array, int ibStart, int cbSize)
         {
-            switch(Platform)
+            switch (Platform)
             {
                 case Platform.Arm64:
                 case Platform.Arm32:
@@ -65,7 +86,9 @@ protected override void HashCore(byte[] array, int ibStart, int cbSize)
             }
         }
 
-        /// <summary>When overridden in a derived class, finalizes the hash computation after the last data is processed by the cryptographic stream object.</summary>
+        /// <summary>
+        /// When overridden in a derived class, finalizes the hash computation after the last data is processed by the cryptographic stream object
+        /// </summary>
         /// <returns>The computed hash code.</returns>
         protected override byte[] HashFinal()
         {
@@ -74,25 +97,44 @@ protected override byte[] HashFinal()
             return BitConverter.GetBytes(outputCrcValue);
         }
 
-
         private void HashCoreArm(byte[] array, int ibStart, int cbSize)
         {
 #if NET5_0_OR_GREATER
-            if (Platform == Platform.Arm64)
+
+            var span = new ReadOnlySpan<byte>(array, ibStart, cbSize);
+
+            if (Platform == Platform.Arm64 && span.Length > 0)
             {
-                while (cbSize >= 8)
+                unsafe
                 {
-                    _crc = Arm64.ComputeCrc32(_crc, BitConverter.ToUInt64(array, ibStart));
-                    ibStart += 8;
-                    cbSize -= 8;
+                    fixed(byte* start = &span[0])
+                    {
+                        ulong* current = (ulong*)start;
+                        ulong* end = current + span.Length / sizeof(ulong);
+                        while (current < end)
+                        {
+                            _crc = Arm64.ComputeCrc32(_crc, *current++);
+                        }
+
+                        span = new ReadOnlySpan<byte>((byte*)current, span.Length % sizeof(ulong));
+                    }
                 }
             }
 
-            while (cbSize > 0)
+            if(span.Length > 0)
             {
-                _crc = Arm32.ComputeCrc32(_crc, array[ibStart]);
-                ibStart++;
-                cbSize--;
+                unsafe
+                {
+                    fixed(byte* start = &span[0])
+                    {
+                        byte* current = start;
+                        byte* end = current + span.Length;
+                        while (current < end)
+                        {
+                            _crc = Arm32.ComputeCrc32(_crc, *current++);
+                        }
+                    }
+                }
             }
 #endif
         }
diff --git a/Crc32.NET/Intrinsics/Crc32CAlgorithm.cs b/Crc32.NET/Intrinsics/Crc32CAlgorithm.cs
index 09d1ed3..4a7accd 100644
--- a/Crc32.NET/Intrinsics/Crc32CAlgorithm.cs
+++ b/Crc32.NET/Intrinsics/Crc32CAlgorithm.cs
@@ -1,21 +1,21 @@
 using System;
 using System.Security.Cryptography;
-
 #if NETCOREAPP3_0_OR_GREATER
 using X86 = System.Runtime.Intrinsics.X86.Sse42;
 using X64 = System.Runtime.Intrinsics.X86.Sse42.X64;
 #endif
-
 #if NET5_0_OR_GREATER
 using Arm32 = System.Runtime.Intrinsics.Arm.Crc32;
 using Arm64 = System.Runtime.Intrinsics.Arm.Crc32.Arm64;
+using System.Runtime.InteropServices;
 #endif
 
 namespace Force.Crc32.Intrinsics
 {
     /// <summary>
-    /// The hardware implementation of the CRC32-C polynomial 
-    /// implemented on Intel CPUs supporting SSE4.2.
+    /// The hardware implementation of the CRC32C polynomial supported by:
+    /// - Intel CPUs supporting SSE4.2
+    /// - ARM CPUs since ARMv8.1 
     /// </summary>
     public class Crc32CAlgorithm : HashAlgorithm
     {
@@ -29,37 +29,58 @@ public class Crc32CAlgorithm : HashAlgorithm
         /// </summary>
         public Crc32CAlgorithm()
         {
-            // The size, in bits, of the computed hash code.
+#if NETSTANDARD2_0_OR_GREATER
             this.HashSizeValue = 32;
+#endif
             this.Reset();
         }
 
-        /// <summary>Initializes an implementation of the <see cref="T:System.Security.Cryptography.HashAlgorithm"></see> class.</summary>
+        /// <summary>
+        /// Check if the algorithm is supported on the current CPU
+        /// </summary>
+        public static bool IsSupported => Platform != Platform.Unsupported;
+
+        /// <summary>
+        /// Initializes an implementation of the <see cref="T:System.Security.Cryptography.HashAlgorithm" /> class
+        /// </summary>
         public override void Initialize()
         {
             this.Reset();
         }
 
-		/// <summary>
-		/// Computes CRC-32C from input buffer.
-		/// </summary>
-		/// <param name="input">Input buffer containing data to be checksummed.</param>
-		/// <returns>CRC-32C of the buffer.</returns>
+        /// <summary>
+        /// Computes CRC32C from input buffer.
+        /// </summary>
+        /// <param name="input">Input buffer with data to be checksummed.</param>
+        /// <returns>CRC32C of the data in the buffer.</returns>
         public static uint Compute(byte[] input)
-		{
-			var algo = new Crc32CAlgorithm();
-            algo.HashCore(input);
-            return ~algo._crc;
-		}
+        {
+            return Compute(input, 0, input.Length);
+        }
 
+        /// <summary>
+        /// Computes CRC32C from input buffer.
+        /// </summary>
+        /// <param name="input">Input buffer with data to be checksummed.</param>
+        /// <param name="offset">Offset of the input data within the buffer.</param>
+        /// <param name="length">Length of the input data in the buffer.</param>
+        /// <returns>CRC32C of the data in the buffer.</returns>
+        public static uint Compute(byte[] input, int offset, int length)
+        {
+            var algo = new Crc32CAlgorithm();
+            algo.HashCore(input, offset, length);
+            return ~algo._crc;
+        }
 
-        /// <summary>When overridden in a derived class, routes data written to the object into the hash algorithm for computing the hash.</summary>
+        /// <summary>
+        /// When overridden in a derived class, routes data written to the object into the hash algorithm for computing the hash
+        /// </summary>
         /// <param name="array">The input to compute the hash code for.</param>
         /// <param name="ibStart">The offset into the byte array from which to begin using data.</param>
         /// <param name="cbSize">The number of bytes in the byte array to use as data.</param>
         protected override void HashCore(byte[] array, int ibStart, int cbSize)
         {
-            switch(Platform)
+            switch (Platform)
             {
                 case Platform.X64:
                 case Platform.X86:
@@ -74,26 +95,54 @@ protected override void HashCore(byte[] array, int ibStart, int cbSize)
             }
         }
 
+        /// <summary>
+        /// When overridden in a derived class, finalizes the hash computation after the last data is processed by the cryptographic stream object.
+        /// </summary>
+        /// <returns>The computed hash code.</returns>
+        protected override byte[] HashFinal()
+        {
+            return BitConverter.GetBytes(~_crc);
+        }
+
         private void HashCoreX86(byte[] array, int ibStart, int cbSize)
         {
 #if NETCOREAPP3_0_OR_GREATER
-            if (Platform == Platform.X64)
+            var span = new ReadOnlySpan<byte>(array, ibStart, cbSize);
+
+            if (Platform == Platform.X64 && span.Length > 0)
             {
-                ulong crc = _crc;
-                while (cbSize >= 8)
+                unsafe
                 {
-                    crc = X64.Crc32(crc, BitConverter.ToUInt64(array, ibStart));
-                    ibStart += 8;
-                    cbSize -= 8;
+                    fixed(byte* start = &span[0])
+                    {
+                        ulong* current = (ulong*)start;
+                        ulong* end = current + span.Length / sizeof(ulong);
+                        ulong crc = _crc;
+                        while (current < end)
+                        {
+                            crc = X64.Crc32(crc, *current++);
+                        }
+                        _crc = (uint)crc;
+
+                        span = new ReadOnlySpan<byte>((byte*)current, span.Length % sizeof(ulong));
+                    }
                 }
-                _crc = (uint)crc;
             }
 
-            while (cbSize > 0)
+            if(span.Length > 0)
             {
-                _crc = X86.Crc32(_crc, array[ibStart]);
-                ibStart++;
-                cbSize--;
+                unsafe
+                {
+                    fixed(byte* start = &span[0])
+                    {
+                        byte* current = start;
+                        byte* end = current + span.Length;
+                        while (current < end)
+                        {
+                            _crc = X86.Crc32(_crc, *current++);
+                        }
+                    }
+                }
             }
 #endif
         }
@@ -101,35 +150,44 @@ private void HashCoreX86(byte[] array, int ibStart, int cbSize)
         private void HashCoreArm(byte[] array, int ibStart, int cbSize)
         {
 #if NET5_0_OR_GREATER
-            if (Platform == Platform.Arm64)
+            var span = new ReadOnlySpan<byte>(array, ibStart, cbSize);
+
+            if (Platform == Platform.Arm64 && span.Length > 0)
             {
-                while (cbSize >= 8)
+                unsafe
                 {
-                    _crc = Arm64.ComputeCrc32C(_crc, BitConverter.ToUInt64(array, ibStart));
-                    ibStart += 8;
-                    cbSize -= 8;
+                    fixed(byte* start = &span[0])
+                    {
+                        ulong* current = (ulong*)start;
+                        ulong* end = current + span.Length / sizeof(ulong);
+                        while (current < end)
+                        {
+                            _crc = Arm64.ComputeCrc32C(_crc, *current++);
+                        }
+
+                        span = new ReadOnlySpan<byte>((byte*)current, span.Length % sizeof(ulong));
+                    }
                 }
             }
 
-            while (cbSize > 0)
+            if(span.Length > 0)
             {
-                _crc = Arm32.ComputeCrc32C(_crc, array[ibStart]);
-                ibStart++;
-                cbSize--;
+                unsafe
+                {
+                    fixed(byte* start = &span[0])
+                    {
+                        byte* current = start;
+                        byte* end = current + span.Length;
+                        while (current < end)
+                        {
+                            _crc = Arm32.ComputeCrc32C(_crc, *current++);
+                        }
+                    }
+                }
             }
 #endif
         }
 
-
-        /// <summary>When overridden in a derived class, finalizes the hash computation after the last data is processed by the cryptographic stream object.</summary>
-        /// <returns>The computed hash code.</returns>
-        protected override byte[] HashFinal()
-        {
-            uint outputCrcValue = ~_crc;
-
-            return BitConverter.GetBytes(outputCrcValue);
-        }
-
         private static Platform Platform =>
 #if NETCOREAPP3_0_OR_GREATER
             X64.IsSupported ? Platform.X64 :

From 57837cec099189f813624cc8fb0b2bc8ea88bad7 Mon Sep 17 00:00:00 2001
From: Eduard Sergeev <eduard.sergeev@gmail.com>
Date: Sat, 9 Jul 2022 17:55:00 +1000
Subject: [PATCH 3/4] Bump dependencies

Update performance tests to use latest dependencies
Run performance tests on all supported platforms
Remove no longer supported frameworks
---
 Crc32.NET.Tests/Crc32.NET.Tests.Core.csproj   | 34 ++++++-------------
 .../Crc32Implementations/Crc32C_Standard.cs   |  4 +--
 .../Crc32_Crc32Algorithm.cs                   |  4 +--
 .../Crc32Implementations/K4os_Hash_Crc.cs     |  4 +--
 Crc32.NET.Tests/PerformanceTest.cs            | 31 ++++++++---------
 Crc32.NET.Tests/Program.cs                    |  7 ++--
 6 files changed, 30 insertions(+), 54 deletions(-)

diff --git a/Crc32.NET.Tests/Crc32.NET.Tests.Core.csproj b/Crc32.NET.Tests/Crc32.NET.Tests.Core.csproj
index e31bd0e..c029d85 100644
--- a/Crc32.NET.Tests/Crc32.NET.Tests.Core.csproj
+++ b/Crc32.NET.Tests/Crc32.NET.Tests.Core.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netcoreapp1.0;netcoreapp2.0;net461;net5.0;net6.0</TargetFrameworks>
+    <TargetFrameworks>net461;net5.0;net6.0</TargetFrameworks>
     <DebugType>portable</DebugType>
     <AssemblyName>Crc32.NET.Tests</AssemblyName>
     <OutputType>Exe</OutputType>
@@ -13,34 +13,22 @@
     <ProjectReference Include="..\Crc32.NET\Crc32.NET.Core.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="K4os.Hash.Crc" Version="1.1.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0-preview-20170106-08" />
     <PackageReference Include="CRC32C.Standard" Version="1.0.0" />
-    <PackageReference Include="NUnit" Version="3.10.1" />
+    <PackageReference Include="Crc32" Version="1.1.0" />
+    <PackageReference Include="K4os.Hash.Crc" Version="1.1.4" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0" />
+    <PackageReference Include="NUnit" Version="3.13.3" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.10.0" />
   </ItemGroup>
-  <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp2.0'">
-    <PackageReference Include="NETStandard.Library" Version="2.0.0" />
-  </ItemGroup>
   <ItemGroup Condition=" '$(TargetFramework)' == 'net461'">
     <PackageReference Include="CH.Crc32" Version="1.0" />
-    <PackageReference Include="Crc32" Version="1.0.0" />
-    <PackageReference Include="Crc32C.NET" Version="1.0.5.0" />
+    <PackageReference Include="Crc32" Version="1.1.0" />
+    <PackageReference Include="Crc32C.NET" Version="1.0.5" />
     <PackageReference Include="Dexiom.QuickCrc32" Version="1.0.3" />
-    <PackageReference Include="Klinkby.Checksum" Version="1.0.2.1" />
-    <PackageReference Include="System.Data.HashFunction.Core" Version="1.8.2.2" />
-    <PackageReference Include="System.Data.HashFunction.CRC" Version="1.8.2.2" />
-    <PackageReference Include="System.Data.HashFunction.Interfaces" Version="1.0.0.2" />
+    <PackageReference Include="Klinkby.Checksum" Version="1.0.2" />
+    <PackageReference Include="System.Data.HashFunction.Core" Version="2.0.0" />
+    <PackageReference Include="System.Data.HashFunction.CRC" Version="2.0.0" />
+    <PackageReference Include="System.Data.HashFunction.Interfaces" Version="2.0.0" />
     <PackageReference Include="CRC32C.Standard" Version="1.0.0" />
-    <!--PackageReference Include="NUnit" Version="3.6.0" /-->
   </ItemGroup>
-  <PropertyGroup Condition=" '$(TargetFramework)' == 'netcoreapp1.0' ">
-    <DefineConstants>$(DefineConstants);NETCORE;;NETCORE13</DefineConstants>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(TargetFramework)' == 'netcoreapp2.0' ">
-    <DefineConstants>$(DefineConstants);NETCORE;NETCORE20</DefineConstants>
-  </PropertyGroup>
-  <PropertyGroup>
-    <DefineConstants>$(DefineConstants);COREVERSION</DefineConstants>
-  </PropertyGroup>
 </Project>
diff --git a/Crc32.NET.Tests/Crc32Implementations/Crc32C_Standard.cs b/Crc32.NET.Tests/Crc32Implementations/Crc32C_Standard.cs
index 5920265..a57cd4a 100644
--- a/Crc32.NET.Tests/Crc32Implementations/Crc32C_Standard.cs
+++ b/Crc32.NET.Tests/Crc32Implementations/Crc32C_Standard.cs
@@ -1,5 +1,4 @@
-#if !NETFRAMEWORK
-namespace Force.Crc32.Tests.Crc32Implementations
+namespace Force.Crc32.Tests.Crc32Implementations
 {
 	public class Crc32C_Standard : CrcCalculator
 	{
@@ -15,4 +14,3 @@ public override uint Calculate(byte[] data)
 		}
 	}
 }
-#endif
diff --git a/Crc32.NET.Tests/Crc32Implementations/Crc32_Crc32Algorithm.cs b/Crc32.NET.Tests/Crc32Implementations/Crc32_Crc32Algorithm.cs
index 04f95b3..cdc31f2 100644
--- a/Crc32.NET.Tests/Crc32Implementations/Crc32_Crc32Algorithm.cs
+++ b/Crc32.NET.Tests/Crc32Implementations/Crc32_Crc32Algorithm.cs
@@ -1,5 +1,4 @@
-#if NETFRAMEWORK
-using Crc = Crc32.Crc32Algorithm;
+using Crc = Crc32.Crc32Algorithm;
 
 namespace Force.Crc32.Tests.Crc32Implementations
 {
@@ -15,4 +14,3 @@ public override uint Calculate(byte[] data)
 		}
 	}
 }
-#endif
diff --git a/Crc32.NET.Tests/Crc32Implementations/K4os_Hash_Crc.cs b/Crc32.NET.Tests/Crc32Implementations/K4os_Hash_Crc.cs
index 62870d8..72abf4b 100644
--- a/Crc32.NET.Tests/Crc32Implementations/K4os_Hash_Crc.cs
+++ b/Crc32.NET.Tests/Crc32Implementations/K4os_Hash_Crc.cs
@@ -1,5 +1,4 @@
-#if COREVERSION
-namespace Force.Crc32.Tests.Crc32Implementations
+namespace Force.Crc32.Tests.Crc32Implementations
 {
 	public class K4os_Hash_Crc : CrcCalculator
 	{
@@ -13,4 +12,3 @@ public override uint Calculate(byte[] data)
 		}
 	}
 }
-#endif
\ No newline at end of file
diff --git a/Crc32.NET.Tests/PerformanceTest.cs b/Crc32.NET.Tests/PerformanceTest.cs
index fb1b6d1..3ab0459 100644
--- a/Crc32.NET.Tests/PerformanceTest.cs
+++ b/Crc32.NET.Tests/PerformanceTest.cs
@@ -21,12 +21,6 @@ public void ThroughputKlinkby_Checksum()
 			Calculate(new Klinkby_Checkum_Crc32());
 		}
 
-		[Test]
-		public void ThroughputCrc32_By_dariogriffo()
-		{
-			Calculate(new Crc32_Crc32Algorithm());
-		}
-
 		[Test]
 		public void ThroughputCrc32_By_Data_HashFunction_Crc()
 		{
@@ -44,14 +38,25 @@ public void ThroughputCrc32C_Crc32C()
 		{
 			Calculate(new Crc32C_Crc32CAlgorithm());
 		}
-#else
+#endif
 		[Test]
 		public void ThroughputCrc32C_Standard()
 		{
 			Calculate(new Crc32C_Standard());
 		}
-#endif
-	
+
+		[Test]
+		public void ThroughputCrc32_By_dariogriffo()
+		{
+			Calculate(new Crc32_Crc32Algorithm());
+		}
+
+		[Test]
+		public void ThroughputCrc32C_By_K4os_Hash_Crc()
+		{
+			Calculate(new K4os_Hash_Crc());
+		}
+
 		[Test]
 		public void ThroughputCrc32_By_Me()
 		{
@@ -86,14 +91,6 @@ public void ThroughputCrc32_By_Me_Intrinsics()
 		}
 #endif
 
-#if COREVERSION && NETFRAMEWORK13
-		[Test]
-		public void ThroughputCrc32C_By_K4os_Hash_Crc()
-		{
-			Calculate(new K4os_Hash_Crc());
-		}
-#endif
-
 		private void Calculate(CrcCalculator implementation, int size = 65536)
 		{
 			if(!implementation.IsSupported)
diff --git a/Crc32.NET.Tests/Program.cs b/Crc32.NET.Tests/Program.cs
index 2d47edb..7f9354b 100644
--- a/Crc32.NET.Tests/Program.cs
+++ b/Crc32.NET.Tests/Program.cs
@@ -6,16 +6,14 @@ public static void Main()
 		{
 			var pt = new PerformanceTest();
 #if NETFRAMEWORK
-			pt.ThroughputCrc32_By_dariogriffo();
 			pt.ThroughputCHCrc32_By_tanglebones();
             pt.ThroughputKlinkby_Checksum();
 			pt.ThroughputCrc32_By_Data_HashFunction_Crc();
 			pt.ThroughputCrc32_By_Me();
 			pt.ThroughputCrc32_By_Dexiom();
-#if COREVERSION
-			pt.ThroughputCrc32C_By_K4os_Hash_Crc();
 #endif
-#else
+			pt.ThroughputCrc32_By_dariogriffo();
+			pt.ThroughputCrc32C_By_K4os_Hash_Crc();
 			pt.ThroughputCrc32C_Standard();
 			pt.ThroughputCrc32C_By_Me();
 			pt.ThroughputCrc32_By_Me();
@@ -24,7 +22,6 @@ public static void Main()
 #endif
 #if NET5_0_OR_GREATER
 			pt.ThroughputCrc32_By_Me_Intrinsics();
-#endif
 #endif
         }
     }

From dd80c05de0f4f24a6fc2bc614027501d23df94d8 Mon Sep 17 00:00:00 2001
From: Eduard Sergeev <eduard.sergeev@gmail.com>
Date: Mon, 28 Aug 2023 08:39:40 +1000
Subject: [PATCH 4/4] Update .NET `TargetFrameworks`

Use latest supported .NET frameworks:
- .NET 6
- .NET 7
---
 Crc32.NET.Tests/Crc32.NET.Tests.Core.csproj | 2 +-
 Crc32.NET/Crc32.NET.Core.csproj             | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Crc32.NET.Tests/Crc32.NET.Tests.Core.csproj b/Crc32.NET.Tests/Crc32.NET.Tests.Core.csproj
index c029d85..9642f6b 100644
--- a/Crc32.NET.Tests/Crc32.NET.Tests.Core.csproj
+++ b/Crc32.NET.Tests/Crc32.NET.Tests.Core.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>net461;net5.0;net6.0</TargetFrameworks>
+    <TargetFrameworks>net6.0;net7.0</TargetFrameworks>
     <DebugType>portable</DebugType>
     <AssemblyName>Crc32.NET.Tests</AssemblyName>
     <OutputType>Exe</OutputType>
diff --git a/Crc32.NET/Crc32.NET.Core.csproj b/Crc32.NET/Crc32.NET.Core.csproj
index d189354..6faefad 100644
--- a/Crc32.NET/Crc32.NET.Core.csproj
+++ b/Crc32.NET/Crc32.NET.Core.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <VersionPrefix>1.3.0</VersionPrefix>
-    <TargetFrameworks>netstandard1.3;netstandard2.0;net20;net5.0;net6.0</TargetFrameworks>
+    <TargetFrameworks>net6.0;net7.0</TargetFrameworks>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <AssemblyName>Crc32.NET</AssemblyName>
     <!--DelaySign>true</DelaySign>