Reflection_Engine: SortExtensionMethods improved to return the most relevant method

Reflection_Engine/Modify/SortExtensionMethods.cs

@@ -42,11 +42,72 @@ public static partial class Modify
         [Output("metods", "Sorted methods")]
         public static List<MethodInfo> SortExtensionMethods(this IEnumerable<MethodInfo> methods, Type type)
         {
-            //TODO: Sort methods based on closeness to the type, not just exact vs non exact.
-            //Example A : B and B : C
-            //Then if the type is A and list of methods contain one method with first parameter matching each type, then the list should be
-            //Sorted so that the method with A comes first followed by B and lastly C.
-            return methods.OrderBy(x => x.GetParameters().FirstOrDefault()?.ParameterType == type ? 0 : 1).ToList();
+            List<List<Type>> hierarchy = type.InheritanceHierarchy();
+            IEnumerable<int> levels = methods.Select(x => hierarchy.InheritanceLevel(x.GetParameters()[0].ParameterType));
+            return methods.Zip(levels, (m, l) => new { m, l }).Where(x => x.l != -1).OrderBy(x => x.l).Select(x => x.m).ToList();
+        }
+
+
+        /***************************************************/
+        /**** Private Methods                           ****/
+        /***************************************************/
+
+        private static List<List<Type>> InheritanceHierarchy(this Type type)
+        {
+            List<Type> typeAncestry = new List<Type>();
+            Type ancestor = type;
+            while (ancestor != null && ancestor != typeof(object))
+            {
+                typeAncestry.Add(ancestor);
+                ancestor = ancestor.BaseType;
+            }
+
+            List<List<Type>> result = new List<List<Type>>();
+
+            for (int i = typeAncestry.Count - 1; i >= 0; i--)
+            {
+                Type child = typeAncestry[i];
+                result.Insert(0, new List<Type> { child });
+
+                IEnumerable<Type> alreadyMapped = result.SelectMany(x => x);
+                List<List<Type>> interfaces = child.InterfaceHierarchy();
+                for (int j = 0; j < interfaces.Count; j++)
+                {
+                    IEnumerable<Type> notMapped = interfaces[j].Except(alreadyMapped);
+                    if (notMapped.Any())
+                    {
+                        if (j + 1 < result.Count)
+                            result[j + 1].AddRange(notMapped);
+                        else
+                            result.Add(notMapped.ToList());
+                    }
+                    else
+                        break;
+                }
+            }
+
+            return result;
+        }
+
+        /***************************************************/
+
+        private static List<List<Type>> InterfaceHierarchy(this Type type)
+        {
+            Type[] interfaces = type.GetInterfaces();
+            return interfaces.GroupBy(x => interfaces.Count(y => x.IsAssignableFrom(y))).OrderBy(x => x.Key).Select(x => x.ToList()).ToList();
+        }
+
+        /***************************************************/
+
+        private static int InheritanceLevel(this List<List<Type>> hierarchy, Type type)
+        {
+            for (int i = 0; i < hierarchy.Count; i++)
+            {
+                if (hierarchy[i].Contains(type))
+                    return i;
+            }
+
+            return -1;
         }
 
         /***************************************************/