Merge pull request #21 from nalka0/temp

sebastientromp · web-flow · commit d941c406aff3 · 2024-01-16T10:00:51.000+01:00
Constants.NullPtr =&gt; IntPtr.Zero and few extra cleanups
diff --git a/src/HackF5.UnitySpy/AssemblyImageFactory.cs b/src/HackF5.UnitySpy/AssemblyImageFactory.cs
@@ -105,7 +105,7 @@ private static AssemblyImage GetAssemblyImage(UnityProcessFacade process, string
             //// pointer to array of structs of type _MonoAssembly
             var assemblyArrayAddress = process.ReadPtr(domain + process.MonoLibraryOffsets.ReferencedAssemblies);
             for (var assemblyAddress = assemblyArrayAddress;
-                assemblyAddress != Constants.NullPtr;
+                assemblyAddress != IntPtr.Zero;
                 assemblyAddress = process.ReadPtr(assemblyAddress + process.SizeOfPtr))
             {
                 var assembly = process.ReadPtr(assemblyAddress);
@@ -132,10 +132,9 @@ private static IntPtr GetRootDomainFunctionAddressPEFormat(byte[] moduleDump, Mo
             var numberOfFunctions = moduleDump.ToInt32(exportDirectory + PEFormatOffsets.NumberOfFunctions);
             var functionAddressArrayIndex = moduleDump.ToInt32(exportDirectory + PEFormatOffsets.FunctionAddressArrayIndex);
             var functionNameArrayIndex = moduleDump.ToInt32(exportDirectory + PEFormatOffsets.FunctionNameArrayIndex);
-
-            var rootDomainFunctionAddress = Constants.NullPtr;
+            var rootDomainFunctionAddress = IntPtr.Zero;
             for (var functionIndex = 0;
-                functionIndex < (numberOfFunctions * PEFormatOffsets.FunctionEntrySize);
+                functionIndex < numberOfFunctions * PEFormatOffsets.FunctionEntrySize;
                 functionIndex += PEFormatOffsets.FunctionEntrySize)
             {
                 var functionNameIndex = moduleDump.ToInt32(functionNameArrayIndex + functionIndex);
@@ -149,7 +148,7 @@ private static IntPtr GetRootDomainFunctionAddressPEFormat(byte[] moduleDump, Mo
                 }
             }
 
-            if (rootDomainFunctionAddress == Constants.NullPtr)
+            if (rootDomainFunctionAddress == IntPtr.Zero)
             {
                 throw new InvalidOperationException("Failed to find mono_get_root_domain function.");
             }
@@ -159,7 +158,7 @@ private static IntPtr GetRootDomainFunctionAddressPEFormat(byte[] moduleDump, Mo
 
         private static IntPtr GetRootDomainFunctionAddressMachOFormat(ModuleInfo monoModuleInfo)
         {
-            var rootDomainFunctionAddress = Constants.NullPtr;
+            var rootDomainFunctionAddress = IntPtr.Zero;
 
             byte[] moduleFromPath = File.ReadAllBytes(monoModuleInfo.Path);
 
@@ -196,7 +195,7 @@ private static IntPtr GetRootDomainFunctionAddressMachOFormat(ModuleInfo monoMod
                 }
             }
 
-            if (rootDomainFunctionAddress == Constants.NullPtr)
+            if (rootDomainFunctionAddress == IntPtr.Zero)
             {
                 throw new InvalidOperationException("Failed to find mono_get_root_domain function.");
             }
diff --git a/src/HackF5.UnitySpy/Detail/AssemblyImage.cs b/src/HackF5.UnitySpy/Detail/AssemblyImage.cs
@@ -5,7 +5,6 @@
     using System.Collections.Generic;
     using System.Linq;
     using HackF5.UnitySpy.ProcessFacade;
-    using HackF5.UnitySpy.Util;
     using JetBrains.Annotations;
 
     /// <summary>
@@ -68,7 +67,7 @@ public TypeDefinition GetTypeDefinition(string fullTypeName) =>
 
         public TypeDefinition GetTypeDefinition(IntPtr address)
         {
-            if (address == Constants.NullPtr)
+            if (address == IntPtr.Zero)
             {
                 return default;
             }
@@ -81,7 +80,6 @@ public TypeDefinition GetTypeDefinition(IntPtr address)
         private ConcurrentDictionary<IntPtr, TypeDefinition> CreateTypeDefinitions()
         {
             var definitions = new ConcurrentDictionary<IntPtr, TypeDefinition>();
-
             int classCache = this.Process.MonoLibraryOffsets.ImageClassCache;
             var classCacheSize = this.ReadUInt32(classCache + this.Process.MonoLibraryOffsets.HashTableSize);
             var classCacheTableArray = this.ReadPtr(classCache + this.Process.MonoLibraryOffsets.HashTableTable);
@@ -91,7 +89,7 @@ private ConcurrentDictionary<IntPtr, TypeDefinition> CreateTypeDefinitions()
                 tableItem += this.Process.SizeOfPtr)
             {
                 for (var definition = this.Process.ReadPtr(classCacheTableArray + tableItem);
-                    definition != Constants.NullPtr;
+                    definition != IntPtr.Zero;
                     definition = this.Process.ReadPtr(definition + this.Process.MonoLibraryOffsets.TypeDefinitionNextClassCache))
                 {
                     definitions.GetOrAdd(definition, new TypeDefinition(this, definition));
diff --git a/src/HackF5.UnitySpy/Detail/FieldDefinition.cs b/src/HackF5.UnitySpy/Detail/FieldDefinition.cs
@@ -37,7 +37,7 @@ public FieldDefinition([NotNull] TypeDefinition declaringType, IntPtr address)
             {
                 var monoGenericClassAddress = this.TypeInfo.Data;
                 var monoClassAddress = this.Process.ReadPtr(monoGenericClassAddress);
-                TypeDefinition monoClass = this.Image.GetTypeDefinition(monoClassAddress);
+                this.Image.GetTypeDefinition(monoClassAddress);
 
                 var monoGenericContainerPtr = monoClassAddress + this.Process.MonoLibraryOffsets.TypeDefinitionGenericContainer;
                 var monoGenericContainerAddress = this.Process.ReadPtr(monoGenericContainerPtr);
@@ -80,24 +80,8 @@ public TValue GetValue<TValue>(IntPtr address)
 
         public TValue GetValue<TValue>(List<TypeInfo> genericTypeArguments, IntPtr address)
         {
-            int offset;
-            if (this.DeclaringType.IsValueType && !this.TypeInfo.IsStatic)
-            {
-                offset = this.Offset - (this.Process.SizeOfPtr * 2);
-            }
-            else
-            {
-                offset = this.Offset;
-            }
-
-            if (this.genericTypeArguments != null)
-            {
-                return (TValue)this.TypeInfo.GetValue(this.genericTypeArguments, address + offset);
-            }
-            else
-            {
-                return (TValue)this.TypeInfo.GetValue(genericTypeArguments, address + offset);
-            }
+            int offset = this.DeclaringType.IsValueType && !this.TypeInfo.IsStatic ? this.Offset - (this.Process.SizeOfPtr * 2) : this.Offset;
+            return (TValue)this.TypeInfo.GetValue(this.genericTypeArguments ?? genericTypeArguments, address + offset);
         }
     }
 }
diff --git a/src/HackF5.UnitySpy/Detail/TypeDefinition.cs b/src/HackF5.UnitySpy/Detail/TypeDefinition.cs
@@ -7,7 +7,6 @@
     using System.Diagnostics;
     using System.Linq;
     using System.Text;
-    using HackF5.UnitySpy.Util;
     using JetBrains.Annotations;
 
     /// <summary>
@@ -58,17 +57,17 @@ public TypeDefinition([NotNull] AssemblyImage image, IntPtr address)
             this.NamespaceName = this.ReadString(image.Process.MonoLibraryOffsets.TypeDefinitionNamespace);
             this.Size = this.ReadInt32(image.Process.MonoLibraryOffsets.TypeDefinitionSize);
             var vtablePtr = this.ReadPtr(image.Process.MonoLibraryOffsets.TypeDefinitionRuntimeInfo);
-            this.VTable = vtablePtr == Constants.NullPtr ? Constants.NullPtr : image.Process.ReadPtr(vtablePtr + image.Process.MonoLibraryOffsets.TypeDefinitionRuntimeInfoDomainVTables);
+            this.VTable = vtablePtr == IntPtr.Zero ? IntPtr.Zero : image.Process.ReadPtr(vtablePtr + image.Process.MonoLibraryOffsets.TypeDefinitionRuntimeInfoDomainVTables);
             this.TypeInfo = new TypeInfo(image, this.Address + image.Process.MonoLibraryOffsets.TypeDefinitionByValArg);
-            this.VTableSize = vtablePtr == Constants.NullPtr ? 0 : this.ReadInt32(image.Process.MonoLibraryOffsets.TypeDefinitionVTableSize);
+            this.VTableSize = vtablePtr == IntPtr.Zero ? 0 : this.ReadInt32(image.Process.MonoLibraryOffsets.TypeDefinitionVTableSize);
             this.ClassKind = (MonoClassKind)(this.ReadByte(image.Process.MonoLibraryOffsets.TypeDefinitionClassKind) & 0x7);
 
             // Get the generic type arguments
             if (this.TypeInfo.TypeCode == TypeCode.GENERICINST)
             {
                 var monoGenericClassAddress = this.TypeInfo.Data;
                 var monoClassAddress = this.Process.ReadPtr(monoGenericClassAddress);
-                TypeDefinition monoClass = this.Image.GetTypeDefinition(monoClassAddress);
+                this.Image.GetTypeDefinition(monoClassAddress);
 
                 var monoGenericContainerPtr = monoClassAddress + this.Process.MonoLibraryOffsets.TypeDefinitionGenericContainer;
                 var monoGenericContainerAddress = this.Process.ReadPtr(monoGenericContainerPtr);
@@ -165,9 +164,7 @@ public TValue GetStaticValue<TValue>(string fieldName)
             }
             catch (Exception e)
             {
-                throw new Exception(
-                    $"Exception received when trying to get static value for field '{fieldName}' in class '{this.FullName}': ${e.Message}.",
-                    e);
+                throw new Exception($"Exception received when trying to get static value for field '{fieldName}' in class '{this.FullName}': ${e.Message}.", e);
             }
         }
 
@@ -190,7 +187,7 @@ private TypeDefinition GetClassDefinition(int address) =>
         private IReadOnlyList<FieldDefinition> GetFields()
         {
             var firstField = this.ReadPtr(this.Image.Process.MonoLibraryOffsets.TypeDefinitionFields);
-            if (firstField == Constants.NullPtr)
+            if (firstField == IntPtr.Zero)
             {
                 return this.Parent?.Fields ?? new List<FieldDefinition>();
             }
@@ -205,7 +202,7 @@ private IReadOnlyList<FieldDefinition> GetFields()
                 for (var fieldIndex = 0; fieldIndex < this.fieldCount; fieldIndex++)
                 {
                     var field = firstField + (fieldIndex * this.Process.MonoLibraryOffsets.TypeDefinitionFieldSize);
-                    if (this.Process.ReadPtr(field) == Constants.NullPtr)
+                    if (this.Process.ReadPtr(field) == IntPtr.Zero)
                     {
                         break;
                     }
@@ -222,7 +219,6 @@ private IReadOnlyList<FieldDefinition> GetFields()
         private string GetFullName()
         {
             var builder = new StringBuilder();
-
             var hierarchy = this.NestedHierarchy().Reverse().ToArray();
             if (!string.IsNullOrWhiteSpace(this.NamespaceName))
             {
diff --git a/src/HackF5.UnitySpy/Offsets/MonoLibraryOffsets.cs b/src/HackF5.UnitySpy/Offsets/MonoLibraryOffsets.cs
@@ -333,7 +333,7 @@ private static MonoLibraryOffsets GetOffsets(UnityVersion unityVersion, bool is6
                         }
 
                         Console.WriteLine(unsupportedMsg);
-                        Console.WriteLine($"Offsets of {bestCandidateUnityVersion.ToString()} selected instead.");
+                        Console.WriteLine($"Offsets of {bestCandidateUnityVersion} selected instead.");
 
                         return bestCandidate;
                     }
diff --git a/src/HackF5.UnitySpy/ProcessFacade/ProcessFacade.cs b/src/HackF5.UnitySpy/ProcessFacade/ProcessFacade.cs
@@ -192,7 +192,7 @@ private TValue ReadBufferValue<TValue>(IntPtr address, int size, Func<byte[], TV
         private object[] ReadManagedArray(TypeInfo type, List<TypeInfo> genericTypeArguments, IntPtr address)
         {
             var ptr = this.ReadPtr(address);
-            if (ptr == Constants.NullPtr)
+            if (ptr == IntPtr.Zero)
             {
                 return default;
             }
@@ -216,7 +216,7 @@ private object[] ReadManagedArray(TypeInfo type, List<TypeInfo> genericTypeArgum
         private ManagedClassInstance ReadManagedClassInstance(TypeInfo type, List<TypeInfo> genericTypeArguments, IntPtr address)
         {
             var ptr = this.ReadPtr(address);
-            return ptr == Constants.NullPtr
+            return ptr == IntPtr.Zero
                 ? default
                 : new ManagedClassInstance(type.Image, genericTypeArguments, ptr);
         }
@@ -252,7 +252,7 @@ private object ReadManagedVar(TypeInfo type, List<TypeInfo> genericTypeArguments
         private string ReadManagedString(IntPtr address)
         {
             var ptr = this.ReadPtr(address);
-            if (ptr == Constants.NullPtr)
+            if (ptr == IntPtr.Zero)
             {
                 return default;
             }
diff --git a/src/HackF5.UnitySpy/Util/Constants.cs b/src/HackF5.UnitySpy/Util/Constants.cs
diff --git a/src/HackF5.UnitySpy/Util/MemoryReadingUtils.cs b/src/HackF5.UnitySpy/Util/MemoryReadingUtils.cs
@@ -40,14 +40,14 @@ private void SingleReadMemoryRecursive(IntPtr address, int length, int stepSize,
 
             strBuilder.AppendLine("========================================== Reading Memory at " + addressStr + " Depth = " + recursiveDepth + " ========================================== ");
 
-            var ptr = Constants.NullPtr;
-            if (address != Constants.NullPtr)
+            var ptr = IntPtr.Zero;
+            if (address != IntPtr.Zero)
             {
                 try
                 {
                     ptr = this.process.ReadPtr(address);
                 }
-                catch (Exception)
+                catch
                 {
                 }
             }
@@ -74,7 +74,7 @@ private void SingleReadMemoryRecursive(IntPtr address, int length, int stepSize,
                 return;
             }
 
-            if (ptr != Constants.NullPtr)
+            if (ptr != IntPtr.Zero)
             {
                 if (this.pointersShown.Contains(ptr))
                 {
@@ -86,7 +86,7 @@ private void SingleReadMemoryRecursive(IntPtr address, int length, int stepSize,
                     {
                         strBuilder.AppendLine("Value as char *: " + this.process.ReadAsciiString(ptr));
                     }
-                    catch (Exception)
+                    catch
                     {
                     }
 

Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ private static AssemblyImage GetAssemblyImage(UnityProcessFacade process, string`
`105`	`105`	`//// pointer to array of structs of type _MonoAssembly`
`106`	`106`	`var assemblyArrayAddress = process.ReadPtr(domain + process.MonoLibraryOffsets.ReferencedAssemblies);`
`107`	`107`	`for (var assemblyAddress = assemblyArrayAddress;`
`108`		`- assemblyAddress != Constants.NullPtr;`
	`108`	`+ assemblyAddress != IntPtr.Zero;`
`109`	`109`	`assemblyAddress = process.ReadPtr(assemblyAddress + process.SizeOfPtr))`
`110`	`110`	`{`
`111`	`111`	`var assembly = process.ReadPtr(assemblyAddress);`
`@@ -132,10 +132,9 @@ private static IntPtr GetRootDomainFunctionAddressPEFormat(byte[] moduleDump, Mo`
`132`	`132`	`var numberOfFunctions = moduleDump.ToInt32(exportDirectory + PEFormatOffsets.NumberOfFunctions);`
`133`	`133`	`var functionAddressArrayIndex = moduleDump.ToInt32(exportDirectory + PEFormatOffsets.FunctionAddressArrayIndex);`
`134`	`134`	`var functionNameArrayIndex = moduleDump.ToInt32(exportDirectory + PEFormatOffsets.FunctionNameArrayIndex);`
`135`		`-`
`136`		`- var rootDomainFunctionAddress = Constants.NullPtr;`
	`135`	`+ var rootDomainFunctionAddress = IntPtr.Zero;`
`137`	`136`	`for (var functionIndex = 0;`
`138`		`- functionIndex < (numberOfFunctions * PEFormatOffsets.FunctionEntrySize);`
	`137`	`+ functionIndex < numberOfFunctions * PEFormatOffsets.FunctionEntrySize;`
`139`	`138`	`functionIndex += PEFormatOffsets.FunctionEntrySize)`
`140`	`139`	`{`
`141`	`140`	`var functionNameIndex = moduleDump.ToInt32(functionNameArrayIndex + functionIndex);`
`@@ -149,7 +148,7 @@ private static IntPtr GetRootDomainFunctionAddressPEFormat(byte[] moduleDump, Mo`
`149`	`148`	`}`
`150`	`149`	`}`
`151`	`150`
`152`		`- if (rootDomainFunctionAddress == Constants.NullPtr)`
	`151`	`+ if (rootDomainFunctionAddress == IntPtr.Zero)`
`153`	`152`	`{`
`154`	`153`	`throw new InvalidOperationException("Failed to find mono_get_root_domain function.");`
`155`	`154`	`}`
`@@ -159,7 +158,7 @@ private static IntPtr GetRootDomainFunctionAddressPEFormat(byte[] moduleDump, Mo`
`159`	`158`
`160`	`159`	`private static IntPtr GetRootDomainFunctionAddressMachOFormat(ModuleInfo monoModuleInfo)`
`161`	`160`	`{`
`162`		`- var rootDomainFunctionAddress = Constants.NullPtr;`
	`161`	`+ var rootDomainFunctionAddress = IntPtr.Zero;`
`163`	`162`
`164`	`163`	`byte[] moduleFromPath = File.ReadAllBytes(monoModuleInfo.Path);`
`165`	`164`
`@@ -196,7 +195,7 @@ private static IntPtr GetRootDomainFunctionAddressMachOFormat(ModuleInfo monoMod`
`196`	`195`	`}`
`197`	`196`	`}`
`198`	`197`
`199`		`- if (rootDomainFunctionAddress == Constants.NullPtr)`
	`198`	`+ if (rootDomainFunctionAddress == IntPtr.Zero)`
`200`	`199`	`{`
`201`	`200`	`throw new InvalidOperationException("Failed to find mono_get_root_domain function.");`
`202`	`201`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,6 @@`
`5`	`5`	`using System.Collections.Generic;`
`6`	`6`	`using System.Linq;`
`7`	`7`	`using HackF5.UnitySpy.ProcessFacade;`
`8`		`- using HackF5.UnitySpy.Util;`
`9`	`8`	`using JetBrains.Annotations;`
`10`	`9`
`11`	`10`	`/// <summary>`
`@@ -68,7 +67,7 @@ public TypeDefinition GetTypeDefinition(string fullTypeName) =>`
`68`	`67`
`69`	`68`	`public TypeDefinition GetTypeDefinition(IntPtr address)`
`70`	`69`	`{`
`71`		`- if (address == Constants.NullPtr)`
	`70`	`+ if (address == IntPtr.Zero)`
`72`	`71`	`{`
`73`	`72`	`return default;`
`74`	`73`	`}`
`@@ -81,7 +80,6 @@ public TypeDefinition GetTypeDefinition(IntPtr address)`
`81`	`80`	`private ConcurrentDictionary<IntPtr, TypeDefinition> CreateTypeDefinitions()`
`82`	`81`	`{`
`83`	`82`	`var definitions = new ConcurrentDictionary<IntPtr, TypeDefinition>();`
`84`		`-`
`85`	`83`	`int classCache = this.Process.MonoLibraryOffsets.ImageClassCache;`
`86`	`84`	`var classCacheSize = this.ReadUInt32(classCache + this.Process.MonoLibraryOffsets.HashTableSize);`
`87`	`85`	`var classCacheTableArray = this.ReadPtr(classCache + this.Process.MonoLibraryOffsets.HashTableTable);`
`@@ -91,7 +89,7 @@ private ConcurrentDictionary<IntPtr, TypeDefinition> CreateTypeDefinitions()`
`91`	`89`	`tableItem += this.Process.SizeOfPtr)`
`92`	`90`	`{`
`93`	`91`	`for (var definition = this.Process.ReadPtr(classCacheTableArray + tableItem);`
`94`		`- definition != Constants.NullPtr;`
	`92`	`+ definition != IntPtr.Zero;`
`95`	`93`	`definition = this.Process.ReadPtr(definition + this.Process.MonoLibraryOffsets.TypeDefinitionNextClassCache))`
`96`	`94`	`{`
`97`	`95`	`definitions.GetOrAdd(definition, new TypeDefinition(this, definition));`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,6 @@`
`7`	`7`	`using System.Diagnostics;`
`8`	`8`	`using System.Linq;`
`9`	`9`	`using System.Text;`
`10`		`- using HackF5.UnitySpy.Util;`
`11`	`10`	`using JetBrains.Annotations;`
`12`	`11`
`13`	`12`	`/// <summary>`
`@@ -58,17 +57,17 @@ public TypeDefinition([NotNull] AssemblyImage image, IntPtr address)`
`58`	`57`	`this.NamespaceName = this.ReadString(image.Process.MonoLibraryOffsets.TypeDefinitionNamespace);`
`59`	`58`	`this.Size = this.ReadInt32(image.Process.MonoLibraryOffsets.TypeDefinitionSize);`
`60`	`59`	`var vtablePtr = this.ReadPtr(image.Process.MonoLibraryOffsets.TypeDefinitionRuntimeInfo);`
`61`		`- this.VTable = vtablePtr == Constants.NullPtr ? Constants.NullPtr : image.Process.ReadPtr(vtablePtr + image.Process.MonoLibraryOffsets.TypeDefinitionRuntimeInfoDomainVTables);`
	`60`	`+ this.VTable = vtablePtr == IntPtr.Zero ? IntPtr.Zero : image.Process.ReadPtr(vtablePtr + image.Process.MonoLibraryOffsets.TypeDefinitionRuntimeInfoDomainVTables);`
`62`	`61`	`this.TypeInfo = new TypeInfo(image, this.Address + image.Process.MonoLibraryOffsets.TypeDefinitionByValArg);`
`63`		`- this.VTableSize = vtablePtr == Constants.NullPtr ? 0 : this.ReadInt32(image.Process.MonoLibraryOffsets.TypeDefinitionVTableSize);`
	`62`	`+ this.VTableSize = vtablePtr == IntPtr.Zero ? 0 : this.ReadInt32(image.Process.MonoLibraryOffsets.TypeDefinitionVTableSize);`
`64`	`63`	`this.ClassKind = (MonoClassKind)(this.ReadByte(image.Process.MonoLibraryOffsets.TypeDefinitionClassKind) & 0x7);`
`65`	`64`
`66`	`65`	`// Get the generic type arguments`
`67`	`66`	`if (this.TypeInfo.TypeCode == TypeCode.GENERICINST)`
`68`	`67`	`{`
`69`	`68`	`var monoGenericClassAddress = this.TypeInfo.Data;`
`70`	`69`	`var monoClassAddress = this.Process.ReadPtr(monoGenericClassAddress);`
`71`		`- TypeDefinition monoClass = this.Image.GetTypeDefinition(monoClassAddress);`
	`70`	`+ this.Image.GetTypeDefinition(monoClassAddress);`
`72`	`71`
`73`	`72`	`var monoGenericContainerPtr = monoClassAddress + this.Process.MonoLibraryOffsets.TypeDefinitionGenericContainer;`
`74`	`73`	`var monoGenericContainerAddress = this.Process.ReadPtr(monoGenericContainerPtr);`
`@@ -165,9 +164,7 @@ public TValue GetStaticValue<TValue>(string fieldName)`
`165`	`164`	`}`
`166`	`165`	`catch (Exception e)`
`167`	`166`	`{`
`168`		`- throw new Exception(`
`169`		`- $"Exception received when trying to get static value for field '{fieldName}' in class '{this.FullName}': ${e.Message}.",`
`170`		`- e);`
	`167`	`+ throw new Exception($"Exception received when trying to get static value for field '{fieldName}' in class '{this.FullName}': ${e.Message}.", e);`
`171`	`168`	`}`
`172`	`169`	`}`
`173`	`170`
`@@ -190,7 +187,7 @@ private TypeDefinition GetClassDefinition(int address) =>`
`190`	`187`	`private IReadOnlyList<FieldDefinition> GetFields()`
`191`	`188`	`{`
`192`	`189`	`var firstField = this.ReadPtr(this.Image.Process.MonoLibraryOffsets.TypeDefinitionFields);`
`193`		`- if (firstField == Constants.NullPtr)`
	`190`	`+ if (firstField == IntPtr.Zero)`
`194`	`191`	`{`
`195`	`192`	`return this.Parent?.Fields ?? new List<FieldDefinition>();`
`196`	`193`	`}`
`@@ -205,7 +202,7 @@ private IReadOnlyList<FieldDefinition> GetFields()`
`205`	`202`	`for (var fieldIndex = 0; fieldIndex < this.fieldCount; fieldIndex++)`
`206`	`203`	`{`
`207`	`204`	`var field = firstField + (fieldIndex * this.Process.MonoLibraryOffsets.TypeDefinitionFieldSize);`
`208`		`- if (this.Process.ReadPtr(field) == Constants.NullPtr)`
	`205`	`+ if (this.Process.ReadPtr(field) == IntPtr.Zero)`
`209`	`206`	`{`
`210`	`207`	`break;`
`211`	`208`	`}`
`@@ -222,7 +219,6 @@ private IReadOnlyList<FieldDefinition> GetFields()`
`222`	`219`	`private string GetFullName()`
`223`	`220`	`{`
`224`	`221`	`var builder = new StringBuilder();`
`225`		`-`
`226`	`222`	`var hierarchy = this.NestedHierarchy().Reverse().ToArray();`
`227`	`223`	`if (!string.IsNullOrWhiteSpace(this.NamespaceName))`
`228`	`224`	`{`
Original file line number	Diff line number	Diff line change
`@@ -333,7 +333,7 @@ private static MonoLibraryOffsets GetOffsets(UnityVersion unityVersion, bool is6`
`333`	`333`	`}`
`334`	`334`
`335`	`335`	`Console.WriteLine(unsupportedMsg);`
`336`		`- Console.WriteLine($"Offsets of {bestCandidateUnityVersion.ToString()} selected instead.");`
	`336`	`+ Console.WriteLine($"Offsets of {bestCandidateUnityVersion} selected instead.");`
`337`	`337`
`338`	`338`	`return bestCandidate;`
`339`	`339`	`}`
Original file line number	Diff line number	Diff line change
`@@ -192,7 +192,7 @@ private TValue ReadBufferValue<TValue>(IntPtr address, int size, Func<byte[], TV`
`192`	`192`	`private object[] ReadManagedArray(TypeInfo type, List<TypeInfo> genericTypeArguments, IntPtr address)`
`193`	`193`	`{`
`194`	`194`	`var ptr = this.ReadPtr(address);`
`195`		`- if (ptr == Constants.NullPtr)`
	`195`	`+ if (ptr == IntPtr.Zero)`
`196`	`196`	`{`
`197`	`197`	`return default;`
`198`	`198`	`}`
`@@ -216,7 +216,7 @@ private object[] ReadManagedArray(TypeInfo type, List<TypeInfo> genericTypeArgum`
`216`	`216`	`private ManagedClassInstance ReadManagedClassInstance(TypeInfo type, List<TypeInfo> genericTypeArguments, IntPtr address)`
`217`	`217`	`{`
`218`	`218`	`var ptr = this.ReadPtr(address);`
`219`		`- return ptr == Constants.NullPtr`
	`219`	`+ return ptr == IntPtr.Zero`
`220`	`220`	`? default`
`221`	`221`	`: new ManagedClassInstance(type.Image, genericTypeArguments, ptr);`
`222`	`222`	`}`
`@@ -252,7 +252,7 @@ private object ReadManagedVar(TypeInfo type, List<TypeInfo> genericTypeArguments`
`252`	`252`	`private string ReadManagedString(IntPtr address)`
`253`	`253`	`{`
`254`	`254`	`var ptr = this.ReadPtr(address);`
`255`		`- if (ptr == Constants.NullPtr)`
	`255`	`+ if (ptr == IntPtr.Zero)`
`256`	`256`	`{`
`257`	`257`	`return default;`
`258`	`258`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,14 +40,14 @@ private void SingleReadMemoryRecursive(IntPtr address, int length, int stepSize,`
`40`	`40`
`41`	`41`	`strBuilder.AppendLine("========================================== Reading Memory at " + addressStr + " Depth = " + recursiveDepth + " ========================================== ");`
`42`	`42`
`43`		`- var ptr = Constants.NullPtr;`
`44`		`- if (address != Constants.NullPtr)`
	`43`	`+ var ptr = IntPtr.Zero;`
	`44`	`+ if (address != IntPtr.Zero)`
`45`	`45`	`{`
`46`	`46`	`try`
`47`	`47`	`{`
`48`	`48`	`ptr = this.process.ReadPtr(address);`
`49`	`49`	`}`
`50`		`- catch (Exception)`
	`50`	`+ catch`
`51`	`51`	`{`
`52`	`52`	`}`
`53`	`53`	`}`
`@@ -74,7 +74,7 @@ private void SingleReadMemoryRecursive(IntPtr address, int length, int stepSize,`
`74`	`74`	`return;`
`75`	`75`	`}`
`76`	`76`
`77`		`- if (ptr != Constants.NullPtr)`
	`77`	`+ if (ptr != IntPtr.Zero)`
`78`	`78`	`{`
`79`	`79`	`if (this.pointersShown.Contains(ptr))`
`80`	`80`	`{`
`@@ -86,7 +86,7 @@ private void SingleReadMemoryRecursive(IntPtr address, int length, int stepSize,`
`86`	`86`	`{`
`87`	`87`	`strBuilder.AppendLine("Value as char *: " + this.process.ReadAsciiString(ptr));`
`88`	`88`	`}`
`89`		`- catch (Exception)`
	`89`	`+ catch`
`90`	`90`	`{`
`91`	`91`	`}`
`92`	`92`