Lorsque l'on travaille avec les Types, il existe tout un tas de méthodes et propriétés pour savoir si par exemple on est en présence d'un Generic, d'un tableau, d'une classe... Il existe aussi une méthode pour savoir si notre Type hérite d'un autre Type.

Cependant, il n'existe aucun méthode permettant de savoir si celui-ci implémente une interface. Je vous propose donc une petite méthode d'extension faisant le travail.

 

Attention, il faut différencier ici le Type et l'instance !
Avec une instance, il suffit d'utiliser le mot clé is.

Exemple : if (myObject is ICollection) { ... }

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
public static class TypesExtensions
{
  /// <summary>
  /// Test si un type implémente une interface 
  /// </summary>
  /// <param name="type"></param>
  /// <param name="interface"></param>
  /// <returns></returns>
  public static bool IsImplementInterface(this Type type, Type @interface) {
    return type.FindInterfaces((t, c) => {
      var tc = c as Type;
      var tt = t as Type;

      if (tc.IsGenericType && tc.ContainsGenericParameters && tt.IsGenericType)
      {
        return tc.GetGenericTypeDefinition() == tt.GetGenericTypeDefinition();
      }
      return tc == tt;
    }, @interface).Length > 0;
  }

}

Voici un exemple d'utilisation :

1
2
3
4
5
6
 
var iInterface = typeof(ICollection);
var type1 = typeof(object);
var type2 = typeof(List<string>);

var tTest1 = type1.IsImplementInterface(iInterface);
var tTest2 = type2.IsImplementInterface(iInterface);

 

En exécutant le code ci-dessus, on constate que tTest1 est égal à false tandis que tTest2 est true.

Update 22/09

Réponse à une question intéressante venue par email : Ne serait-il pas plus simple d'utiliser IsAssignableFrom ?

En fait, la méthode Type.IsAssignableFrom(type) permet de déterminer si l'instance du Type en cours peut être assignée à une instance du type spécifié. Hors dans notre cas, le type spécifié est une interface, ce n'est donc pas un type que l'on peut instancié.

Voici par exemple le résultat des différents appels :

1
2
3
4
5
6
7
8
9
 
var t = typeof(List<string>);
var i = typeof(ICollection<string>);
var i2 = typeof(ICollection<>);

var test1 = t.IsAssignableFrom(i); // ==> false
var test2 = t.IsAssignableFrom(i2); // ==> false

var test3 = t.IsImplementInterface(i); // ==> true
var test4 = t.IsImplementInterface(i2); // ==> true