Evaluate the best common type to fit both of types

Question

Here is an algorithm to evaluate best matching System.Type for two types in hierarhy. This is one of answers for this StackOverflow question by Ken Kin:

Evaluate the maximum possible type to fit both of types

Algorithm

1. Searching for common base class (either concrete or abstract)
   • FindBaseClassWith method
2. If there is no common base class, search for common implemented interface
   • It's possible for one class to implement multiple interfaces, in this case return first common based interface
   • FindInterfaceWith method

Questions

1. GetInterfaceHierarchy implementaion
   • I'm not sure that this is correct implementation in case of complex class hierarhy with many implemented interfaces
   • Now all tests are passing for selected collection from BCL and my own testing hierarhy
2. Are there any other flaws that I do not pay attention to?
3. I had wrote this sample in LinqPad, that's why all unittests are located at Main method. Nevertheless, any improvments to Test.Assert are ok!

Full source code with unittests is available here

// provide common base class or implemented interface
public static Type FindEqualTypeWith(this Type typeLeft, Type typeRight)
{
    if(typeLeft == null || typeRight == null) return null;

    var commonBaseClass = typeLeft.FindBaseClassWith(typeRight) ?? typeof(object);

    return commonBaseClass.Equals(typeof(object))
            ? typeLeft.FindInterfaceWith(typeRight)
            : commonBaseClass;
}

// searching for common base class (either concrete or abstract)
public static Type FindBaseClassWith(this Type typeLeft, Type typeRight)
{
    if(typeLeft == null || typeRight == null) return null;

    return typeLeft
            .GetClassHierarchy()
            .Intersect(typeRight.GetClassHierarchy())
            .FirstOrDefault(type => !type.IsInterface);
}

// searching for common implemented interface
// it's possible for one class to implement multiple interfaces, 
// in this case return first common based interface
public static Type FindInterfaceWith(this Type typeLeft, Type typeRight)
{
    if(typeLeft == null || typeRight == null) return null;

    return typeLeft
            .GetInterfaceHierarchy()
            .Intersect(typeRight.GetInterfaceHierarchy())
            .FirstOrDefault();   
}

// iterate on interface hierarhy
public static IEnumerable<Type> GetInterfaceHierarchy(this Type type)
{
    if(type.IsInterface) return new [] { type }.AsEnumerable();

    return type
            .GetInterfaces()
            .OrderByDescending(current => current.GetInterfaces().Count())
            .AsEnumerable();
}

// interate on class hierarhy
public static IEnumerable<Type> GetClassHierarchy(this Type type)
{
    if(type == null) yield break;

    Type typeInHierarchy = type;

    do
    {
        yield return typeInHierarchy;
        typeInHierarchy = typeInHierarchy.BaseType;
    }
    while(typeInHierarchy != null && !typeInHierarchy.IsInterface);
}

Answer 1

Your code does not take in account interface covariance and contravariance issues.

Here is the sample code that demonstrates it:

class ObservableOfString : IObservable<string> { /*...*/ }
class ObservableOfObject : IObservable<object> { /*...*/ }
class ObserverOfObject : IObserver<object> { /*...*/ }
class ObserverOfString : IObserver<string> { /*...*/ }
class Program
{

    static void Main(string[] args)
    {
        IObservable<object> observableIsCovariant = new ObservableOfString();
        IObserver<string> observerIsContravariant = new ObserverOfObject();
        Console.WriteLine(typeof(ObservableOfString).FindEqualTypeWith(typeof(ObservableOfObject)) ?? (object)"<NULL>"); // Would it not be more useful to return IObservable<object>?
        Console.WriteLine(typeof(ObserverOfString).FindEqualTypeWith(typeof(ObserverOfObject)) ?? (object)"<NULL>"); // Would it not be more useful to return IObserver<string>?
        Console.ReadLine();
    }
}

The fundamental issue is, as soon as you want to find the "best common interface", you are going to run in an issue, as "best" and "common" are at best dependent on the context. You should clearly identify which use cases you are going to support, in the context of why that method was needed, and write a specific implementation that solves your need.

Answer 2

update:

This question can be solved by the answer of related question

• How to find the minimum covariant type between two types?

---

I've voted up the answer by Jean Hominal. The descriptions in that answer is true. Alternatively, let we change the method FinBaseClassWith to use the BaseType directly provided by the framework:

public static Type FindBaseClassWith(this Type type1, Type type2) {
    for(var baseType2=type2; null!=baseType2; baseType2=baseType2.BaseType)
        for(var baseType1=type1; null!=baseType1; baseType1=baseType1.BaseType)
            if(baseType2==baseType1)
                return baseType2;

    return default(Type);
}

consider you have two arrays and you are going to assign one to another. And you test them with:

objectArray.GetType().FindBaseTypeWith(charArray.GetType()); 

and

charArray.GetType().FindBaseTypeWith(objectArray.GetType()); 

They are all typeof(Array), but it's not possible to do

charArray=objectArray;

And copying with Array.Copy throws an exception. I cannot figure out what's the difference even though they have the same BaseType.

The original question I asked on S.O., is relevent of to find the possible path of assignment, before we invoke the constructor of the target type.