Ytukyg

Is there any relationship between the open types List<> and IEnumerable<>?

Example:

var type1 = typeof(List<>);

var type2 = typeof(IEnumerable<>);



//return false

type2.IsAssignableFrom(type1);

Is there any method to check the relationship between two open type, or the relationship only exist on closed type?

List<> and IEnumerable<> are not types; they are type definitions. As such it doesn't really make sense to ask if one is assignable to the other. Neither can be assigned to. You can't declare a variable List<> a = null, for example-- you will get a compilation error "Unexpected use of an unbound generic name."

A type definition becomes a generic type when you specify the type parameter. At that point, it is a type and can be assigned to. So for example List<string> can be assigned to IEnumerable<string>.

If you have a type definition in mind and you want to do a type-compatibility check, just use <object> (or a suitable type if there is a type constraint) instead of <>:

var type1 = typeof(List<object>);

var type2 = typeof(IEnumerable<object>);



//returns true

type2.IsAssignableFrom(type1);

Although John Wu wrote up a nice answer about the differences between a type definition and actual types I don't think it fully answers the problem/question asked in the OP.

Is there any method to check the relationship between two open type,
or the relationship only exist on closed type?

First of all, the relationship always exists; every List<> is always an IEnumerable<>, as you can see in the definition of the List<T> type:

public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, ...

But this doesn't answer your second question, if there is a way to check if such a relationship exists between two types. You would think that the IsAssignableFrom method can be used to check for existence of a relationship between the type open types, but you can't. Why? Lets find out in the documentation of the IsAssignableFrom function:

Type.IsAssignableFrom (Type c) Returns true if any of the following conditions is true:

1. c and the current instance represent the same type.



2. c is derived either directly or indirectly from the current
   instance. c is derived directly from the current instance if it
   inherits from the current instance; c is derived indirectly from the
   current instance if it inherits from a succession of one or more
   classes that inherit from the current instance.




3. The current instance is an interface that c implements.




4. c is a generic type parameter, and the current instance represents
   one of the constraints of c.

and false if none of these conditions are true, or if c is null.

In your case, none of the above mentioned conditions will result in true as: (1) they are not the same type. (2) They cannot be derived from each other as they are open types: their generic type parameters are unknown (unknown != unknown). The List<> implements the closed IEnumerable<T> type and not the open IEnumerable<> type (3). They aren't generic type parameters (4).

To find out if two generic types have a relationship, you would need to inspect their type definitions (and their nested interfaces/base types) and validate that they have a relationship:

public static bool IsAssignableToOpenGenericType(Type givenType, Type genericType)

{

    var interfaceTypes = givenType.GetInterfaces();



    foreach (var it in interfaceTypes)

    {

        if (it.IsGenericType && it.GetGenericTypeDefinition() == genericType)

            return true;

    }



    if (givenType.IsGenericType && givenType.GetGenericTypeDefinition() == genericType)

        return true;



    Type baseType = givenType.BaseType;

    if (baseType == null) return false;



    return IsAssignableToGenericType(baseType, genericType);

}

(source)

Will result in:

    var typ1 = typeof(List<>);

    var typ2 = typeof(IEnumerable<>);



    // true, List<>'s type definition contains an IEnumerable<>

    Console.WriteLine(IsAssignableToOpenGenericType(typ1, typ2));

    // false, IEnumerable<>'s type definition does not contain List<>

    Console.WriteLine(IsAssignableToOpenGenericType(typ2, typ1));