2 fix code

Pose.sln

@@ -10,6 +10,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{C2484D4C-4
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Pose.Tests", "test\Pose.Tests\Pose.Tests.csproj", "{AE06C68C-032F-45CC-888C-54B0B98F860C}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Sandbox", "src\Sandbox\Sandbox.csproj", "{46827F5F-E0FD-428B-960C-9EFFFA3D7D9D}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -44,13 +46,26 @@ Global
 		{AE06C68C-032F-45CC-888C-54B0B98F860C}.Release|x64.Build.0 = Release|Any CPU
 		{AE06C68C-032F-45CC-888C-54B0B98F860C}.Release|x86.ActiveCfg = Release|Any CPU
 		{AE06C68C-032F-45CC-888C-54B0B98F860C}.Release|x86.Build.0 = Release|Any CPU
+		{46827F5F-E0FD-428B-960C-9EFFFA3D7D9D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{46827F5F-E0FD-428B-960C-9EFFFA3D7D9D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{46827F5F-E0FD-428B-960C-9EFFFA3D7D9D}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{46827F5F-E0FD-428B-960C-9EFFFA3D7D9D}.Debug|x64.Build.0 = Debug|Any CPU
+		{46827F5F-E0FD-428B-960C-9EFFFA3D7D9D}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{46827F5F-E0FD-428B-960C-9EFFFA3D7D9D}.Debug|x86.Build.0 = Debug|Any CPU
+		{46827F5F-E0FD-428B-960C-9EFFFA3D7D9D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{46827F5F-E0FD-428B-960C-9EFFFA3D7D9D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{46827F5F-E0FD-428B-960C-9EFFFA3D7D9D}.Release|x64.ActiveCfg = Release|Any CPU
+		{46827F5F-E0FD-428B-960C-9EFFFA3D7D9D}.Release|x64.Build.0 = Release|Any CPU
+		{46827F5F-E0FD-428B-960C-9EFFFA3D7D9D}.Release|x86.ActiveCfg = Release|Any CPU
+		{46827F5F-E0FD-428B-960C-9EFFFA3D7D9D}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{BBC1C0DC-ECA2-48C3-A233-0873428203AF} = {3D859125-47BB-49F0-ACB4-42CEE47FB562}
 		{AE06C68C-032F-45CC-888C-54B0B98F860C} = {C2484D4C-4BED-46C2-BD61-2508BD8BD3C5}
+		{46827F5F-E0FD-428B-960C-9EFFFA3D7D9D} = {3D859125-47BB-49F0-ACB4-42CEE47FB562}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {FE2B0751-A19A-4621-A703-18607E69D31A}

src/Pose/Delegates/ActionRef.cs

@@ -1,5 +1,3 @@
-using System;
-
 namespace Pose.Delegates
 {
     public delegate void ActionRef<T>(ref T arg);

src/Pose/Delegates/FuncRef.cs

@@ -1,5 +1,3 @@
-using System;
-
 namespace Pose.Delegates
 {
     public delegate TResult FuncRef<T1, TResult>(ref T1 arg1);

src/Pose/Exceptions/InvalidShimSignatureException.cs

@@ -3,7 +3,7 @@ namespace Pose.Exceptions
     [System.Serializable]
     internal class InvalidShimSignatureException : System.Exception
     {
-        public InvalidShimSignatureException() : base() { }
+        public InvalidShimSignatureException() { }
         public InvalidShimSignatureException(string message) : base(message) { }
         public InvalidShimSignatureException(string message, System.Exception inner) : base(message, inner) { }
         protected InvalidShimSignatureException(

src/Pose/Exceptions/MethodRewriteException.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace Pose.Exceptions
+{
+    [Serializable]
+    public class MethodRewriteException : Exception
+    {
+        public MethodRewriteException() { }
+
+        protected MethodRewriteException(SerializationInfo info, StreamingContext context) : base(info, context) { }
+
+        public MethodRewriteException(string message) : base(message) { }
+
+        public MethodRewriteException(string message, Exception innerException) : base(message, innerException) { }
+    }
+}

src/Pose/Extensions/DictionaryExtensions.cs

@@ -4,8 +4,9 @@ namespace Pose.Extensions
 {
     internal static class DictionaryExtensions
     {
-        public static bool TryAdd<T, U>(this Dictionary<T, U> dictionary, T key, U value)
+        public static bool TryAdd<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, TKey key, TValue value)
         {
+#if NETSTANDARD2_0 || NET48
             try
             {
                 dictionary.Add(key, value);
@@ -15,6 +16,9 @@ public static bool TryAdd<T, U>(this Dictionary<T, U> dictionary, T key, U value
             {
                 return false;
             }
+#else
+            return dictionary.TryAdd(key, value);
+#endif
         }
     }
 }

src/Pose/Extensions/ILGeneratorExtensions.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Reflection;
 using System.Reflection.Emit;
 
@@ -7,9 +8,18 @@ internal static class ILGeneratorExtensions
     {
         public static byte[] GetILBytes(this ILGenerator ilGenerator)
         {
-            var bakeByteArray = typeof(ILGenerator).GetMethod("BakeByteArray", BindingFlags.Instance | BindingFlags.NonPublic);
-            byte[] ilBytes = (byte[])bakeByteArray.Invoke(ilGenerator, null);
+#if NET8_0_OR_GREATER
+            var runtimeILGeneratorType = Type.GetType("System.Reflection.Emit.RuntimeILGenerator") ?? throw new Exception("Cannot find type System.Reflection.Emit.RuntimeILGenerator");
+            var bakeByteArray = runtimeILGeneratorType.GetMethod("BakeByteArray", BindingFlags.Instance | BindingFlags.NonPublic)
+                                ?? throw new Exception($"Cannot get method BakeByteArray from type {nameof(ILGenerator)}");
+            var ilBytes = (byte[])bakeByteArray.Invoke(ilGenerator, null);
             return ilBytes;
+#else
+            var bakeByteArray = typeof(ILGenerator).GetMethod("BakeByteArray", BindingFlags.Instance | BindingFlags.NonPublic)
+                                ?? throw new Exception($"Cannot get method BakeByteArray from type {nameof(ILGenerator)}");
+            var ilBytes = (byte[])bakeByteArray.Invoke(ilGenerator, null);
+            return ilBytes;
+#endif
         }
     }
 }

src/Pose/Extensions/MethodBaseExtensions.cs

@@ -7,7 +7,18 @@ internal static class MethodBaseExtensions
     {
         public static bool InCoreLibrary(this MethodBase methodBase)
         {
-            return methodBase.DeclaringType.Assembly == typeof(Exception).Assembly;
+            if (methodBase == null) throw new ArgumentNullException(nameof(methodBase));
+
+            var declaringType = methodBase.DeclaringType ?? throw new Exception($"Method {methodBase.Name} does not have a {nameof(MethodBase.DeclaringType)}");
+
+            return declaringType.Assembly == typeof(Exception).Assembly;
+        }
+
+        public static bool IsForValueType(this MethodBase methodBase)
+        {
+            if (methodBase == null) throw new ArgumentNullException(nameof(methodBase));
+
+            return methodBase.DeclaringType?.IsSubclassOf(typeof(ValueType)) ?? throw new Exception($"Method {methodBase.Name} does not have a {nameof(MethodBase.DeclaringType)}");
         }
 
         public static bool IsOverride(this MethodBase methodBase)

src/Pose/Helpers/ShimHelper.cs

@@ -1,39 +1,39 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
 
 using Pose.Exceptions;
-using Pose.Extensions;
 
 namespace Pose.Helpers
 {
     internal static class ShimHelper
     {
-        public static MethodBase GetMethodFromExpression(Expression expression, bool setter, out Object instanceOrType)
+        public static MethodBase GetMethodFromExpression(Expression expression, bool setter, out object instanceOrType)
         {
             switch (expression.NodeType)
             {
                 case ExpressionType.MemberAccess:
                     {
-                        MemberExpression memberExpression = expression as MemberExpression;
-                        MemberInfo memberInfo = memberExpression.Member;
+                        var memberExpression = expression as MemberExpression ?? throw new Exception($"Cannot cast expression to {nameof(MemberExpression)}");
+                        var memberInfo = memberExpression.Member;
                         if (memberInfo.MemberType == MemberTypes.Property)
                         {
-                            PropertyInfo propertyInfo = memberInfo as PropertyInfo;
+                            var propertyInfo = memberInfo as PropertyInfo ?? throw new Exception($"Cannot cast {nameof(memberInfo)} to {nameof(PropertyInfo)}");
                             instanceOrType = GetObjectInstanceOrType(memberExpression.Expression);
                             return setter ? propertyInfo.GetSetMethod() : propertyInfo.GetGetMethod();
                         }
                         else
+                        {
                             throw new NotImplementedException("Unsupported expression");
+                        }
                     }
                 case ExpressionType.Call:
-                    MethodCallExpression methodCallExpression = expression as MethodCallExpression;
+                    var methodCallExpression = expression as MethodCallExpression ?? throw new Exception($"Cannot cast expression to {nameof(MethodCallExpression)}");
                     instanceOrType = GetObjectInstanceOrType(methodCallExpression.Object);
                     return methodCallExpression.Method;
                 case ExpressionType.New:
-                    NewExpression newExpression = expression as NewExpression;
+                    var newExpression = expression as NewExpression ?? throw new Exception($"Cannot cast expression to {nameof(NewExpression)}");
                     instanceOrType = null;
                     return newExpression.Constructor;
                 default:
@@ -43,40 +43,45 @@ public static MethodBase GetMethodFromExpression(Expression expression, bool set
 
         public static void ValidateReplacementMethodSignature(MethodBase original, MethodInfo replacement, Type type, bool setter)
         {
-            bool isValueType = original.DeclaringType.IsValueType;
-            bool isStatic = original.IsStatic;
-            bool isConstructor = original.IsConstructor;
-            bool isStaticOrConstructor = isStatic || isConstructor;
+            if (original == null) throw new ArgumentNullException(nameof(original));
+            if (replacement == null) throw new ArgumentNullException(nameof(replacement));
+
+            var isValueType = original.DeclaringType?.IsValueType ?? throw new Exception($"Method {original.Name} does not have a {nameof(MethodBase.DeclaringType)}");
+            var isStatic = original.IsStatic;
+            var isConstructor = original.IsConstructor;
+            var isStaticOrConstructor = isStatic || isConstructor;
 
-            Type vaildReturnType = isConstructor ? original.DeclaringType : (original as MethodInfo).ReturnType;
-            vaildReturnType = setter ? typeof(void) : vaildReturnType;
-            Type shimReturnType = replacement.ReturnType;
+            var validReturnType = isConstructor ? original.DeclaringType : (original as MethodInfo).ReturnType;
+            validReturnType = setter ? typeof(void) : validReturnType;
+            var shimReturnType = replacement.ReturnType;
 
-            Type validOwningType = type;
-            Type shimOwningType = isStaticOrConstructor
+            var validOwningType = type;
+            var shimOwningType = isStaticOrConstructor
                 ? validOwningType : replacement.GetParameters().Select(p => p.ParameterType).FirstOrDefault();
 
-            var validParameterTypes = original.GetParameters().Select(p => p.ParameterType);
+            var validParameterTypes = original.GetParameters().Select(p => p.ParameterType).ToArray();
             var shimParameterTypes = replacement.GetParameters()
                                         .Select(p => p.ParameterType)
-                                        .Skip(isStaticOrConstructor ? 0 : 1);
+                                        .Skip(isStaticOrConstructor ? 0 : 1)
+                                        .ToArray();
 
-            if (vaildReturnType != shimReturnType)
-                throw new InvalidShimSignatureException("Mismatched return types");
+            if (validReturnType != shimReturnType)
+                throw new InvalidShimSignatureException($"Mismatched return types. Expected {validReturnType}. Got {shimReturnType}");
 
             if (!isStaticOrConstructor)
             {
                 if (isValueType && !shimOwningType.IsByRef)
                     throw new InvalidShimSignatureException("ValueType instances must be passed by ref");
             }
 
-            if ((isValueType && !isStaticOrConstructor ? validOwningType.MakeByRefType() : validOwningType) != shimOwningType)
-                throw new InvalidShimSignatureException("Mismatched instance types");
+            var expectedType = (isValueType && !isStaticOrConstructor ? validOwningType.MakeByRefType() : validOwningType);
+            if (expectedType != shimOwningType)
+                throw new InvalidShimSignatureException($"Mismatched instance types. Expected {expectedType.FullName}. Got {shimOwningType.FullName}");
 
-            if (validParameterTypes.Count() != shimParameterTypes.Count())
-                throw new InvalidShimSignatureException("Parameters count do not match");
+            if (validParameterTypes.Length != shimParameterTypes.Length)
+                throw new InvalidShimSignatureException($"Parameters count do not match. Expected {validParameterTypes.Length}. Got {shimParameterTypes.Length}");
 
-            for (int i = 0; i < validParameterTypes.Count(); i++)
+            for (var i = 0; i < validParameterTypes.Length; i++)
             {
                 if (validParameterTypes.ElementAt(i) != shimParameterTypes.ElementAt(i))
                     throw new InvalidShimSignatureException($"Parameter types at {i} do not match");
@@ -90,27 +95,28 @@ public static object GetObjectInstanceOrType(Expression expression)
             {
                 case ExpressionType.MemberAccess:
                     {
-                        MemberExpression memberExpression = expression as MemberExpression;
-                        ConstantExpression constantExpression = memberExpression.Expression as ConstantExpression;
+                        var memberExpression = expression as MemberExpression ?? throw new Exception($"Cannot cast expression to {nameof(MemberExpression)}");
+                        var constantExpression = memberExpression.Expression as ConstantExpression;
+
                         if (memberExpression.Member.MemberType == MemberTypes.Field)
                         {
-                            FieldInfo fieldInfo = (memberExpression.Member as FieldInfo);
-                            var obj = fieldInfo.IsStatic ? null : constantExpression.Value;
+                            var fieldInfo = memberExpression.Member as FieldInfo ?? throw new Exception($"Cannot cast {nameof(MemberExpression.Member)} to {nameof(FieldInfo)}");
+                            var obj = fieldInfo.IsStatic ? null : constantExpression?.Value;
                             instanceOrType = fieldInfo.GetValue(obj);
                         }
                         else if (memberExpression.Member.MemberType == MemberTypes.Property)
                         {
-                            PropertyInfo propertyInfo = (memberExpression.Member as PropertyInfo);
-                            var obj = propertyInfo.GetMethod.IsStatic ? null : constantExpression.Value;
+                            var propertyInfo = memberExpression.Member as PropertyInfo ?? throw new Exception($"Cannot cast {nameof(MemberExpression.Member)} to {nameof(PropertyInfo)}");
+                            var obj = propertyInfo.GetMethod.IsStatic ? null : constantExpression?.Value;
                             instanceOrType = propertyInfo.GetValue(obj);
                         }
                         EnsureInstanceNotValueType(instanceOrType);
                         break;
                     }
                 case ExpressionType.Call:
                     {
-                        MethodCallExpression methodCallExpression = expression as MethodCallExpression;
-                        MethodInfo methodInfo = methodCallExpression.Method;
+                        var methodCallExpression = expression as MethodCallExpression ?? throw new Exception($"Cannot cast expression to {nameof(MethodCallExpression)}");
+                        var methodInfo = methodCallExpression.Method;
                         instanceOrType = methodInfo.GetGenericArguments().FirstOrDefault();
                         break;
                     }