Better EntryType checking for enumerables and dicts

src/Core/Reflection/Il2CppReflection.cs

@@ -258,6 +258,18 @@ namespace UnityExplorer
             }
         }
 
+        private static bool IsAssignableFrom(Type thisType, Type fromType)
+        {
+            if (!Il2CppTypeNotNull(fromType, out IntPtr fromTypePtr)
+                || !Il2CppTypeNotNull(thisType, out IntPtr thisTypePtr))
+            {
+                // one or both of the types are not Il2Cpp types, use normal check
+                return thisType.IsAssignableFrom(fromType);
+            }
+
+            return il2cpp_class_is_assignable_from(thisTypePtr, fromTypePtr);
+        }
+
         #endregion
 
 
@@ -508,7 +520,7 @@ namespace UnityExplorer
 #endregion
 
 
-#region Il2cpp reflection blacklist
+        #region Il2cpp reflection blacklist
 
         public override string DefaultReflectionBlacklist => string.Join(";", defaultIl2CppBlacklist);
 
@@ -654,10 +666,54 @@ namespace UnityExplorer
             "UnityEngine.XR.InputDevice.SendHapticImpulse",
         };
 
-#endregion
+        #endregion
 
 
-#region Temp il2cpp list/dictionary fixes
+        protected override bool Internal_TryGetEntryType(Type enumerableType, out Type type)
+        {
+            // Check for system types (not unhollowed)
+            if (base.Internal_TryGetEntryType(enumerableType, out type))
+                return true;
+
+            // Type is either an IL2CPP enumerable, or its not generic.
+
+            if (type.IsGenericType)
+            {
+                // Temporary naive solution until IL2CPP interface support improves.
+                // This will work fine for most cases, but there are edge cases which would not work.
+                type = type.GetGenericArguments()[0];
+                return true;
+            }
+
+            // Unable to determine entry type
+            type = typeof(object);
+            return false;
+        }
+
+        protected override bool Internal_TryGetEntryTypes(Type type, out Type keys, out Type values)
+        {
+            if (base.Internal_TryGetEntryTypes(type, out keys, out values))
+                return true;
+
+            // Type is either an IL2CPP dictionary, or its not generic.
+            if (type.IsGenericType)
+            {
+                // Naive solution until IL2CPP interfaces improve.
+                var args = type.GetGenericArguments();
+                if (args.Length == 2)
+                {
+                    keys = args[0];
+                    values = args[1];
+                    return true;
+                }
+            }
+
+            keys = typeof(object);
+            values = typeof(object);
+            return false;
+        }
+
+        #region Temp il2cpp list/dictionary fixes
 
         // Temp fix until Unhollower interface support improves
 

src/Core/Reflection/ReflectionUtility.cs

@@ -495,6 +495,39 @@ namespace UnityExplorer
             enumerator = (list as IEnumerable).GetEnumerator();
             return true;
         }
+
+        // TryGetEntryType
+
+        public static bool TryGetEntryType(Type enumerableType, out Type type)
+            => Instance.Internal_TryGetEntryType(enumerableType, out type);
+
+        protected virtual bool Internal_TryGetEntryType(Type enumerableType, out Type type)
+        {
+            // Check for arrays
+            if (enumerableType.IsArray)
+            {
+                type = enumerableType.GetElementType();
+                return true;
+            }
+
+            // Check for implementation of IEnumerable<T>, IList<T> or ICollection<T>
+            foreach (var t in enumerableType.GetInterfaces())
+            {
+                if (t.IsGenericType)
+                {
+                    var typeDef = t.GetGenericTypeDefinition();
+                    if (typeDef == typeof(IEnumerable<>) || typeDef == typeof(IList<>) || typeDef == typeof(ICollection<>))
+                    {
+                        type = t.GetGenericArguments()[0];
+                        return true;
+                    }
+                }
+            }
+
+            // Unable to determine any generic element type, just use object.
+            type = typeof(object);
+            return false;
+        }
         
         // IsDictionary
 
@@ -524,5 +557,28 @@ namespace UnityExplorer
                 yield return new DictionaryEntry(enumerator.Key, enumerator.Value);
             }
         }
+
+        // TryGetEntryTypes
+
+        public static bool TryGetEntryTypes(Type dictionaryType, out Type keys, out Type values)
+            => Instance.Internal_TryGetEntryTypes(dictionaryType, out keys, out values);
+
+        protected virtual bool Internal_TryGetEntryTypes(Type dictionaryType, out Type keys, out Type values)
+        {
+            foreach (var t in dictionaryType.GetInterfaces())
+            {
+                if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(IDictionary<,>))
+                {
+                    var args = t.GetGenericArguments();
+                    keys = args[0];
+                    values = args[1];
+                    return true;
+                }
+            }
+
+            keys = typeof(object);
+            values = typeof(object);
+            return false;
+        }
     }
 }