Use unsafe methods to improve performance.

KN4CK3R · KN4CK3R · commit 38af5d0bfee5 · 2018-04-02T21:18:17.000+02:00
diff --git a/ReClass.NET/MemoryScanner/BytePattern.cs b/ReClass.NET/MemoryScanner/BytePattern.cs
@@ -5,7 +5,6 @@
 using System.Linq;
 using System.Text;
 using ReClassNET.Extensions;
-using ReClassNET.Util;
 
 namespace ReClassNET.MemoryScanner
 {
@@ -223,6 +222,21 @@ public bool Equals(byte[] data, int index)
 			return true;
 		}
 
+		public unsafe bool Equals(byte* data)
+		{
+			Contract.Requires(data != null);
+
+			for (var j = 0; j < pattern.Count; ++j)
+			{
+				if (!pattern[j].Equals(*(data + j)))
+				{
+					return false;
+				}
+			}
+
+			return true;
+		}
+
 		/// <summary>
 		/// Converts this <see cref="BytePattern"/> to a byte array.
 		/// </summary>
diff --git a/ReClass.NET/MemoryScanner/Comparer/ArrayOfBytesMemoryComparer.cs b/ReClass.NET/MemoryScanner/Comparer/ArrayOfBytesMemoryComparer.cs
@@ -1,5 +1,4 @@
-﻿using System;
-using System.Diagnostics;
+﻿using System.Diagnostics;
 using System.Diagnostics.Contracts;
 
 namespace ReClassNET.MemoryScanner.Comparer
@@ -31,39 +30,45 @@ public ArrayOfBytesMemoryComparer(byte[] pattern)
 			byteArray = pattern;
 		}
 
-		public bool Compare(byte[] data, int index, out ScanResult result)
+		public unsafe bool Compare(byte* data, out ScanResult result)
 		{
 			result = null;
 
 			if (byteArray != null)
 			{
 				for (var i = 0; i < byteArray.Length; ++i)
 				{
-					if (data[index + i] != byteArray[i])
+					if (*(data + i) != byteArray[i])
 					{
 						return false;
 					}
 				}
 			}
-			else if (!bytePattern.Equals(data, index))
+			else if (!bytePattern.Equals(data))
 			{
 				return false;
 			}
 
 			var temp = new byte[ValueSize];
-			Array.Copy(data, index, temp, 0, temp.Length);
+			fixed (byte* cpy = &temp[0])
+			{
+				for (var i = 0; i < ValueSize; ++i)
+				{
+					*(cpy + i) = *(data + i);
+				}
+			}
 			result = new ArrayOfBytesScanResult(temp);
 
 			return true;
 		}
 
-		public bool Compare(byte[] data, int index, ScanResult previous, out ScanResult result)
+		public unsafe bool Compare(byte* data, ScanResult previous, out ScanResult result)
 		{
 #if DEBUG
 			Debug.Assert(previous is ArrayOfBytesScanResult);
 #endif
 
-			return Compare(data, index, out result);
+			return Compare(data, out result);
 		}
 	}
 }
diff --git a/ReClass.NET/MemoryScanner/Comparer/ByteMemoryComparer.cs b/ReClass.NET/MemoryScanner/Comparer/ByteMemoryComparer.cs
@@ -26,11 +26,11 @@ public ByteMemoryComparer(ScanCompareType compareType, byte value1, byte value2)
 			Value2 = value2;
 		}
 
-		public bool Compare(byte[] data, int index, out ScanResult result)
+		public unsafe bool Compare(byte* data, out ScanResult result)
 		{
 			result = null;
 
-			var value = data[index];
+			var value = *data;
 
 			bool IsMatch()
 			{
@@ -69,20 +69,20 @@ bool IsMatch()
 			return true;
 		}
 
-		public bool Compare(byte[] data, int index, ScanResult previous, out ScanResult result)
+		public unsafe bool Compare(byte* data, ScanResult previous, out ScanResult result)
 		{
 #if DEBUG
 			Debug.Assert(previous is ByteScanResult);
 #endif
 
-			return Compare(data, index, (ByteScanResult)previous, out result);
+			return Compare(data, (ByteScanResult)previous, out result);
 		}
 
-		public bool Compare(byte[] data, int index, ByteScanResult previous, out ScanResult result)
+		public unsafe bool Compare(byte* data, ByteScanResult previous, out ScanResult result)
 		{
 			result = null;
 
-			var value = data[index];
+			var value = *data;
 
 			bool IsMatch()
 			{
diff --git a/ReClass.NET/MemoryScanner/Comparer/DoubleMemoryComparer.cs b/ReClass.NET/MemoryScanner/Comparer/DoubleMemoryComparer.cs
@@ -55,11 +55,11 @@ private bool CheckRoundedEquality(double value)
 			}
 		}
 
-		public bool Compare(byte[] data, int index, out ScanResult result)
+		public unsafe bool Compare(byte* data, out ScanResult result)
 		{
 			result = null;
 
-			var value = BitConverter.ToDouble(data, index);
+			var value = *(double*)data;
 
 			bool IsMatch()
 			{
@@ -98,20 +98,20 @@ bool IsMatch()
 			return true;
 		}
 
-		public bool Compare(byte[] data, int index, ScanResult previous, out ScanResult result)
+		public unsafe bool Compare(byte* data, ScanResult previous, out ScanResult result)
 		{
 #if DEBUG
 			Debug.Assert(previous is DoubleScanResult);
 #endif
 
-			return Compare(data, index, (DoubleScanResult)previous, out result);
+			return Compare(data, (DoubleScanResult)previous, out result);
 		}
 
-		public bool Compare(byte[] data, int index, DoubleScanResult previous, out ScanResult result)
+		public unsafe bool Compare(byte* data, DoubleScanResult previous, out ScanResult result)
 		{
 			result = null;
 
-			var value = BitConverter.ToDouble(data, index);
+			var value = *(double*)data;
 
 			bool IsMatch()
 			{
diff --git a/ReClass.NET/MemoryScanner/Comparer/FloatMemoryComparer.cs b/ReClass.NET/MemoryScanner/Comparer/FloatMemoryComparer.cs
@@ -55,11 +55,11 @@ private bool CheckRoundedEquality(float value)
 			}
 		}
 
-		public bool Compare(byte[] data, int index, out ScanResult result)
+		public unsafe bool Compare(byte* data, out ScanResult result)
 		{
 			result = null;
 
-			var value = BitConverter.ToSingle(data, index);
+			var value = *(float*)data;
 
 			bool IsMatch()
 			{
@@ -98,20 +98,20 @@ bool IsMatch()
 			return true;
 		}
 
-		public bool Compare(byte[] data, int index, ScanResult previous, out ScanResult result)
+		public unsafe bool Compare(byte* data, ScanResult previous, out ScanResult result)
 		{
 #if DEBUG
 			Debug.Assert(previous is FloatScanResult);
 #endif
 
-			return Compare(data, index, (FloatScanResult)previous, out result);
+			return Compare(data, (FloatScanResult)previous, out result);
 		}
 
-		public bool Compare(byte[] data, int index, FloatScanResult previous, out ScanResult result)
+		public unsafe bool Compare(byte* data, FloatScanResult previous, out ScanResult result)
 		{
 			result = null;
 
-			var value = BitConverter.ToSingle(data, index);
+			var value = *(float*)data;
 
 			bool IsMatch()
 			{
diff --git a/ReClass.NET/MemoryScanner/Comparer/IScanComparer.cs b/ReClass.NET/MemoryScanner/Comparer/IScanComparer.cs
@@ -13,21 +13,19 @@ public interface IScanComparer
 		/// Compares the data at the provided index to the current <see cref="CompareType"/>.
 		/// </summary>
 		/// <param name="data">The byte array to be compared.</param>
-		/// <param name="index">The index into the byte array.</param>
 		/// <param name="result">[out] The scan result if the <see cref="CompareType"/> matched.</param>
 		/// <returns>True if matched.</returns>
-		bool Compare(byte[] data, int index, out ScanResult result);
+		unsafe bool Compare(byte* data, out ScanResult result);
 
 		/// <summary>
 		/// Compares the data at the provided index to the current <see cref="CompareType"/>.
 		/// The previous results may be used.
 		/// </summary>
 		/// <param name="data">The byte array to be compared.</param>
-		/// <param name="index">The index into the byte array.</param>
 		/// <param name="previous">Scan result to be compared.</param>
 		/// <param name="result">[out] The scan result if the <see cref="CompareType"/> matched.</param>
 		/// <returns>True if matched.</returns>
-		bool Compare(byte[] data, int index, ScanResult previous, out ScanResult result);
+		unsafe bool Compare(byte* data, ScanResult previous, out ScanResult result);
 	}
 
 	[ContractClassFor(typeof(IScanComparer))]
@@ -44,18 +42,13 @@ public int ValueSize
 				throw new NotImplementedException();
 			}
 		}
-		public bool Compare(byte[] data, int index, out ScanResult result)
+		public unsafe bool Compare(byte* data, out ScanResult result)
 		{
-			Contract.Requires(data != null);
-			Contract.Requires(index >= 0);
-
 			throw new NotImplementedException();
 		}
 
-		public bool Compare(byte[] data, int index, ScanResult previous, out ScanResult result)
+		public unsafe bool Compare(byte* data, ScanResult previous, out ScanResult result)
 		{
-			Contract.Requires(data != null);
-			Contract.Requires(index >= 0);
 			Contract.Requires(previous != null);
 
 			throw new NotImplementedException();
diff --git a/ReClass.NET/MemoryScanner/Comparer/IntegerMemoryComparer.cs b/ReClass.NET/MemoryScanner/Comparer/IntegerMemoryComparer.cs
@@ -1,5 +1,4 @@
-﻿using System;
-using System.Diagnostics;
+﻿using System.Diagnostics;
 using ReClassNET.Util;
 
 namespace ReClassNET.MemoryScanner.Comparer
@@ -27,11 +26,11 @@ public IntegerMemoryComparer(ScanCompareType compareType, int value1, int value2
 			Value2 = value2;
 		}
 
-		public bool Compare(byte[] data, int index, out ScanResult result)
+		public unsafe bool Compare(byte* data, out ScanResult result)
 		{
 			result = null;
 
-			var value = BitConverter.ToInt32(data, index);
+			var value = *(int*)data;
 
 			bool IsMatch()
 			{
@@ -70,20 +69,20 @@ bool IsMatch()
 			return true;
 		}
 
-		public bool Compare(byte[] data, int index, ScanResult previous, out ScanResult result)
+		public unsafe bool Compare(byte* data, ScanResult previous, out ScanResult result)
 		{
 #if DEBUG
 			Debug.Assert(previous is IntegerScanResult);
 #endif
 
-			return Compare(data, index, (IntegerScanResult)previous, out result);
+			return Compare(data, (IntegerScanResult)previous, out result);
 		}
 
-		public bool Compare(byte[] data, int index, IntegerScanResult previous, out ScanResult result)
+		public unsafe bool Compare(byte* data, IntegerScanResult previous, out ScanResult result)
 		{
 			result = null;
 
-			var value = BitConverter.ToInt32(data, index);
+			var value = *(int*)data;
 
 			bool IsMatch()
 			{
diff --git a/ReClass.NET/MemoryScanner/Comparer/LongMemoryComparer.cs b/ReClass.NET/MemoryScanner/Comparer/LongMemoryComparer.cs
@@ -1,5 +1,4 @@
-﻿using System;
-using System.Diagnostics;
+﻿using System.Diagnostics;
 using ReClassNET.Util;
 
 namespace ReClassNET.MemoryScanner.Comparer
@@ -27,11 +26,11 @@ public LongMemoryComparer(ScanCompareType compareType, long value1, long value2)
 			Value2 = value2;
 		}
 
-		public bool Compare(byte[] data, int index, out ScanResult result)
+		public unsafe bool Compare(byte* data, out ScanResult result)
 		{
 			result = null;
 
-			var value = BitConverter.ToInt64(data, index);
+			var value = *(long*)data;
 
 			bool IsMatch()
 			{
@@ -70,20 +69,20 @@ bool IsMatch()
 			return true;
 		}
 
-		public bool Compare(byte[] data, int index, ScanResult previous, out ScanResult result)
+		public unsafe bool Compare(byte* data, ScanResult previous, out ScanResult result)
 		{
 #if DEBUG
 			Debug.Assert(previous is LongScanResult);
 #endif
 
-			return Compare(data, index, (LongScanResult)previous, out result);
+			return Compare(data, (LongScanResult)previous, out result);
 		}
 
-		public bool Compare(byte[] data, int index, LongScanResult previous, out ScanResult result)
+		public unsafe bool Compare(byte* data, LongScanResult previous, out ScanResult result)
 		{
 			result = null;
 
-			var value = BitConverter.ToInt64(data, index);
+			var value = *(long*)data;
 
 			bool IsMatch()
 			{
diff --git a/ReClass.NET/MemoryScanner/Comparer/ShortMemoryComparer.cs b/ReClass.NET/MemoryScanner/Comparer/ShortMemoryComparer.cs
@@ -1,5 +1,4 @@
-﻿using System;
-using System.Diagnostics;
+﻿using System.Diagnostics;
 using ReClassNET.Util;
 
 namespace ReClassNET.MemoryScanner.Comparer
@@ -27,11 +26,11 @@ public ShortMemoryComparer(ScanCompareType compareType, short value1, short valu
 			Value2 = value2;
 		}
 
-		public bool Compare(byte[] data, int index, out ScanResult result)
+		public unsafe bool Compare(byte* data, out ScanResult result)
 		{
 			result = null;
 
-			var value = BitConverter.ToInt16(data, index);
+			var value = *(short*)data;
 
 			bool IsMatch()
 			{
@@ -70,20 +69,20 @@ bool IsMatch()
 			return true;
 		}
 
-		public bool Compare(byte[] data, int index, ScanResult previous, out ScanResult result)
+		public unsafe bool Compare(byte* data, ScanResult previous, out ScanResult result)
 		{
 #if DEBUG
 			Debug.Assert(previous is ShortScanResult);
 #endif
 
-			return Compare(data, index, (ShortScanResult)previous, out result);
+			return Compare(data, (ShortScanResult)previous, out result);
 		}
 
-		public bool Compare(byte[] data, int index, ShortScanResult previous, out ScanResult result)
+		public unsafe bool Compare(byte* data, ShortScanResult previous, out ScanResult result)
 		{
 			result = null;
 
-			var value = BitConverter.ToInt16(data, index);
+			var value = *(short*)data;
 
 			bool IsMatch()
 			{
diff --git a/ReClass.NET/MemoryScanner/Comparer/StringMemoryComparer.cs b/ReClass.NET/MemoryScanner/Comparer/StringMemoryComparer.cs
diff --git a/ReClass.NET/MemoryScanner/ScannerWorker.cs b/ReClass.NET/MemoryScanner/ScannerWorker.cs
diff --git a/ReClass.NET/ReClass.NET.csproj b/ReClass.NET/ReClass.NET.csproj

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`		`-using System;`
`2`		`-using System.Diagnostics;`
	`1`	`+using System.Diagnostics;`
`3`	`2`	`using System.Diagnostics.Contracts;`
`4`	`3`
`5`	`4`	`namespace ReClassNET.MemoryScanner.Comparer`
`@@ -31,39 +30,45 @@ public ArrayOfBytesMemoryComparer(byte[] pattern)`
`31`	`30`	`byteArray = pattern;`
`32`	`31`	`}`
`33`	`32`
`34`		`- public bool Compare(byte[] data, int index, out ScanResult result)`
	`33`	`+ public unsafe bool Compare(byte* data, out ScanResult result)`
`35`	`34`	`{`
`36`	`35`	`result = null;`
`37`	`36`
`38`	`37`	`if (byteArray != null)`
`39`	`38`	`{`
`40`	`39`	`for (var i = 0; i < byteArray.Length; ++i)`
`41`	`40`	`{`
`42`		`- if (data[index + i] != byteArray[i])`
	`41`	`+ if (*(data + i) != byteArray[i])`
`43`	`42`	`{`
`44`	`43`	`return false;`
`45`	`44`	`}`
`46`	`45`	`}`
`47`	`46`	`}`
`48`		`- else if (!bytePattern.Equals(data, index))`
	`47`	`+ else if (!bytePattern.Equals(data))`
`49`	`48`	`{`
`50`	`49`	`return false;`
`51`	`50`	`}`
`52`	`51`
`53`	`52`	`var temp = new byte[ValueSize];`
`54`		`- Array.Copy(data, index, temp, 0, temp.Length);`
	`53`	`+ fixed (byte* cpy = &temp[0])`
	`54`	`+ {`
	`55`	`+ for (var i = 0; i < ValueSize; ++i)`
	`56`	`+ {`
	`57`	`+ (cpy + i) = (data + i);`
	`58`	`+ }`
	`59`	`+ }`
`55`	`60`	`result = new ArrayOfBytesScanResult(temp);`
`56`	`61`
`57`	`62`	`return true;`
`58`	`63`	`}`
`59`	`64`
`60`		`- public bool Compare(byte[] data, int index, ScanResult previous, out ScanResult result)`
	`65`	`+ public unsafe bool Compare(byte* data, ScanResult previous, out ScanResult result)`
`61`	`66`	`{`
`62`	`67`	`#if DEBUG`
`63`	`68`	`Debug.Assert(previous is ArrayOfBytesScanResult);`
`64`	`69`	`#endif`
`65`	`70`
`66`		`- return Compare(data, index, out result);`
	`71`	`+ return Compare(data, out result);`
`67`	`72`	`}`
`68`	`73`	`}`
`69`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,11 +26,11 @@ public ByteMemoryComparer(ScanCompareType compareType, byte value1, byte value2)`
`26`	`26`	`Value2 = value2;`
`27`	`27`	`}`
`28`	`28`
`29`		`- public bool Compare(byte[] data, int index, out ScanResult result)`
	`29`	`+ public unsafe bool Compare(byte* data, out ScanResult result)`
`30`	`30`	`{`
`31`	`31`	`result = null;`
`32`	`32`
`33`		`- var value = data[index];`
	`33`	`+ var value = *data;`
`34`	`34`
`35`	`35`	`bool IsMatch()`
`36`	`36`	`{`
`@@ -69,20 +69,20 @@ bool IsMatch()`
`69`	`69`	`return true;`
`70`	`70`	`}`
`71`	`71`
`72`		`- public bool Compare(byte[] data, int index, ScanResult previous, out ScanResult result)`
	`72`	`+ public unsafe bool Compare(byte* data, ScanResult previous, out ScanResult result)`
`73`	`73`	`{`
`74`	`74`	`#if DEBUG`
`75`	`75`	`Debug.Assert(previous is ByteScanResult);`
`76`	`76`	`#endif`
`77`	`77`
`78`		`- return Compare(data, index, (ByteScanResult)previous, out result);`
	`78`	`+ return Compare(data, (ByteScanResult)previous, out result);`
`79`	`79`	`}`
`80`	`80`
`81`		`- public bool Compare(byte[] data, int index, ByteScanResult previous, out ScanResult result)`
	`81`	`+ public unsafe bool Compare(byte* data, ByteScanResult previous, out ScanResult result)`
`82`	`82`	`{`
`83`	`83`	`result = null;`
`84`	`84`
`85`		`- var value = data[index];`
	`85`	`+ var value = *data;`
`86`	`86`
`87`	`87`	`bool IsMatch()`
`88`	`88`	`{`
Original file line number	Diff line number	Diff line change
`@@ -55,11 +55,11 @@ private bool CheckRoundedEquality(double value)`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
`58`		`- public bool Compare(byte[] data, int index, out ScanResult result)`
	`58`	`+ public unsafe bool Compare(byte* data, out ScanResult result)`
`59`	`59`	`{`
`60`	`60`	`result = null;`
`61`	`61`
`62`		`- var value = BitConverter.ToDouble(data, index);`
	`62`	`+ var value = (double)data;`
`63`	`63`
`64`	`64`	`bool IsMatch()`
`65`	`65`	`{`
`@@ -98,20 +98,20 @@ bool IsMatch()`
`98`	`98`	`return true;`
`99`	`99`	`}`
`100`	`100`
`101`		`- public bool Compare(byte[] data, int index, ScanResult previous, out ScanResult result)`
	`101`	`+ public unsafe bool Compare(byte* data, ScanResult previous, out ScanResult result)`
`102`	`102`	`{`
`103`	`103`	`#if DEBUG`
`104`	`104`	`Debug.Assert(previous is DoubleScanResult);`
`105`	`105`	`#endif`
`106`	`106`
`107`		`- return Compare(data, index, (DoubleScanResult)previous, out result);`
	`107`	`+ return Compare(data, (DoubleScanResult)previous, out result);`
`108`	`108`	`}`
`109`	`109`
`110`		`- public bool Compare(byte[] data, int index, DoubleScanResult previous, out ScanResult result)`
	`110`	`+ public unsafe bool Compare(byte* data, DoubleScanResult previous, out ScanResult result)`
`111`	`111`	`{`
`112`	`112`	`result = null;`
`113`	`113`
`114`		`- var value = BitConverter.ToDouble(data, index);`
	`114`	`+ var value = (double)data;`
`115`	`115`
`116`	`116`	`bool IsMatch()`
`117`	`117`	`{`