Un IList générique n'est-il pas assignable à partir d'une liste générique?

Question

bool IsTypeAGenericList(Type listType) 
{ 
    typeof(IList<>).IsAssignableFrom(listType.GetGenericTypeDefinition()) 
} 

renvoie la valeur false lorsqu'elle est donnée typeof(List<int>). Je suppose que c'est parce que les deux types de paramètres peuvent être différents, corrects?

Answer 1

en fait, cela fonctionne:

public static bool IsGenericList(Type type) 
{ 
    if (!type.IsGenericType) 
    return false; 
    var genericArguments = type.GetGenericArguments(); 
    if (genericArguments.Length != 1) 
    return false; 

    var listType = typeof (IList<>).MakeGenericType(genericArguments); 
    return listType.IsAssignableFrom(type); 
} 

Answer 2

Je suppose que la méthode n'a pas vraiment de sens, car une instance est jamais du type générique - elle est toujours construite avec un argument de type particulier. En d'autres termes, vous ne pourriez jamais avoir une variable "ouverte" à assigner dans, ni une référence à une instance ouverte à utiliser comme valeur pour l'assignation.

Comme vous le dites, vous ne savez pas si les paramètres de type seront les mêmes - si (par exemple), vous pouvez définir:

class BizarreList<T> : IList<int> 

Il se sent comme il devrait y avoir une certaine façon d'exprimer la relation si ...

Answer 3

cela a vraiment à voir avec les types ouverts construits.

Quand vous dites:

class List<T> : IList<T> 

Vous êtes en train de dire: ma classe est appelée Liste, il a un paramètre de type appelé T, et il implémente l'interface qui est construit à partir IList <> en utilisant la même T. Ainsi, le T dans la partie définition et le T dans la partie "implémente" font tous deux référence au même paramètre de type - vous le déclarez avant le signe deux-points, puis vous le référenciez immédiatement après le signe deux-points.

Cela devient confus car le paramètre de type IList<> est également appelé T - mais c'est un paramètre de type différent entièrement. Donc, nous allons re-proclamons notre classe concrète comme ceci:

class List<U> : IList<U> 

Ceci est tout à fait équivalent à ce qui précède, que maintenant nous pouvons dire « U » lorsque l'on se réfère au paramètre de type de liste, et T lorsque nous parlons de celui de IList. Ils sont différents types.

Maintenant, il devient plus facile de voir pourquoi la définition de type générique List<U> (qui est ce que vous voulez dire quand vous dites typeof(List<>)) ne met pas en œuvre la définition de type generifc IList<T> (qui est ce que vous voulez dire quand vous dites typeof(IList<>)), mais plutôt implémente le type construit générique ouvert IList<U> (c'est-à-dire, IList construit avec le propre type de parémètre de List). Donc, fondamentalement, les définitions de types génériques n'héritent ou n'implémentent jamais d'autres définitions de types génériques - elles implémentent généralement des types construits ouverts en utilisant leurs propres paramètres de type avec d'autres définitions de types génériques.

La réponse de Ripper234 montre comment gérer ce cas particulier en utilisant Reflection, donc je ne vais pas le répéter; Je voulais juste clarifier la relation entre ces types, et j'espère que cela est sorti au moins quelque peu intelligible.

Answer 4

Voici la méthode d'extension de AutoMapper:

public static bool IsCollectionType(this Type type) 
    { 
     if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ICollection<>)) 
     { 
      return true; 
     } 

     IEnumerable<Type> genericInterfaces = type.GetInterfaces().Where(t => t.IsGenericType); 
     IEnumerable<Type> baseDefinitions = genericInterfaces.Select(t => t.GetGenericTypeDefinition()); 

     var isCollectionType = baseDefinitions.Any(t => t == typeof(ICollection<>)); 

     return isCollectionType; 
    }