Comment déterminer si un type implémente une interface avec la réflexion C #

Est -ce que la réflexion en C#offre un moyen de déterminer si certains étant donné les System.Typemodèles de type une interface?

public interface IMyInterface {}

public class MyType : IMyInterface {}

// should yield 'true'
typeof(MyType)./* ????? */MODELS_INTERFACE(IMyInterface);

Vous avez quelques choix:

1. typeof(IMyInterface).IsAssignableFrom(typeof(MyType))

2. typeof(MyType).GetInterfaces().Contains(typeof(IMyInterface))

Pour une interface générique, c'est un peu différent.

typeof(MyType).GetInterfaces().Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IMyInterface<>))

Utilisation Type.IsAssignableFrom:

typeof(IMyInterface).IsAssignableFrom(typeof(MyType));

typeof(IMyInterface).IsAssignableFrom(someclass.GetType());

ou

typeof(IMyInterface).IsAssignableFrom(typeof(MyType));

public static bool ImplementsInterface(this Type type, Type ifaceType) 
{
    Type[] intf = type.GetInterfaces();
    for(int i = 0; i < intf.Length; i++) 
    {
        if(intf[ i ] == ifaceType) 
        {
            return true;
        }
    }
    return false;
}

Je pense que c'est la version correcte, pour trois raisons:

1. Il utilise GetInterfaces et non IsAssignableFrom, c'est plus rapide car IsAssignableFrom finit par appeler plusieurs fois GetInterfaces après plusieurs vérifications.
2. Il itère sur le tableau local, il n'y aura donc pas de vérification des limites.
3. Il utilise l'opérateur == qui est défini pour Type, il est donc probablement plus sûr que la méthode Equals (que l'appel Contains utilisera éventuellement).

Je viens de faire:

public static bool Implements<I>(this Type source) where I : class
{
  return typeof(I).IsAssignableFrom(source);
}

J'aurais aimé pouvoir dire where I : interface, mais ce interfacen'est pas une option de contrainte de paramètre générique. classest aussi proche que possible.

Usage:

if(MyType.Implements<IInitializable>())
  MyCollection.Initialize();

Je viens de le dire Implementsparce que c'est plus intuitif. Je suis toujours IsAssignableFromretourné.

Modifier la réponse de Jeff pour des performances optimales (grâce au test de performance de Pierre Arnaud):

var type = typeof(MyType);
var implementsInterface = typeof(IMyInterface).IsAssignableFrom(type) && type.IsClass;

Pour trouver tous les types qui implémentent une interface dans un domaine donné Assembly:

var implementations = typeof(TypeInTargetAssembly).Assembly.GetTypes()
                          .Where(t => typeof(IMyInterface).IsAssignableFrom(t) && t.IsClass);

Comme quelqu'un d'autre l'a déjà mentionné: Benjamin 10 avril 13 à 22:21 "

Il était sûr qu'il était facile de ne pas faire attention et de récupérer les arguments pour IsAssignableFrom à l'envers. J'irai avec GetInterfaces maintenant: p -

Eh bien, une autre solution consiste simplement à créer une méthode d'extension courte qui remplit, dans une certaine mesure, la façon de penser "la plus habituelle" (et il a été convenu que c'est un très petit choix personnel pour le rendre légèrement "plus naturel" en fonction de ses préférences). ):

public static class TypeExtensions
{
    public static bool IsAssignableTo(this Type type, Type assignableType)
    {
        return assignableType.IsAssignableFrom(type);
    }
}

Et pourquoi ne pas aller un peu plus générique (eh bien je ne sais pas si c'est vraiment si intéressant, eh bien je suppose que je passe juste une autre pincée de sucre de 'syntaxe'):

public static class TypeExtensions
{
    public static bool IsAssignableTo(this Type type, Type assignableType)
    {
        return assignableType.IsAssignableFrom(type);
    }

    public static bool IsAssignableTo<TAssignable>(this Type type)
    {
        return IsAssignableTo(type, typeof(TAssignable));
    }
}

Je pense que cela pourrait être beaucoup plus naturel de cette façon, mais encore une fois, juste une question d'opinions très personnelles:

var isTrue = michelleType.IsAssignableTo<IMaBelle>();

Si vous avez un type ou une instance, vous pouvez facilement vérifier s'ils prennent en charge une interface spécifique.

Pour tester si un objet implémente une certaine interface:

if(myObject is IMyInterface) {
  // object myObject implements IMyInterface
}

Pour tester si un type implémente une certaine interface:

if(typeof(IMyInterface).IsAssignableFrom(typeof(MyType))) {
  // type MyType implements IMyInterface
}

Si vous avez un objet générique et que vous souhaitez effectuer un cast ainsi qu'une vérification si l'interface vers laquelle vous castez est implémentée, le code est:

 var myCastedObject = myObject as IMyInterface;

    if(myCastedObject != null) {
      // object myObject implements IMyInterface
    }

IsAssignableFromest désormais déplacé vers TypeInfo:

typeof(ISMSRequest).GetTypeInfo().IsAssignableFrom(typeof(T).GetTypeInfo());

Quiconque le recherche peut trouver utile la méthode d'extension suivante:

public static class TypeExtensions
{
    public static bool ImplementsInterface(this Type type, Type @interface)
    {
        if (type == null)
        {
            throw new ArgumentNullException(nameof(type));
        }

        if (@interface == null)
        {
            throw new ArgumentNullException(nameof(@interface));
        }

        var interfaces = type.GetInterfaces();
        if (@interface.IsGenericTypeDefinition)
        {
            foreach (var item in interfaces)
            {
                if (item.IsConstructedGenericType && item.GetGenericTypeDefinition() == @interface)
                {
                    return true;
                }
            }
        }
        else
        {
            foreach (var item in interfaces)
            {
                if (item == @interface)
                {
                    return true;
                }
            }
        }

        return false;
    }
}

tests xunit:

public class TypeExtensionTests
{
    [Theory]
    [InlineData(typeof(string), typeof(IList<int>), false)]
    [InlineData(typeof(List<>), typeof(IList<int>), false)]
    [InlineData(typeof(List<>), typeof(IList<>), true)]
    [InlineData(typeof(List<int>), typeof(IList<>), true)]
    [InlineData(typeof(List<int>), typeof(IList<int>), true)]
    [InlineData(typeof(List<int>), typeof(IList<string>), false)]
    public void ValidateTypeImplementsInterface(Type type, Type @interface, bool expect)
    {
        var output = type.ImplementsInterface(@interface);
        Assert.Equal(expect, output);
    }
}

qu'en est-il de

if(MyType as IMyInterface != null)

?

Qu'en est-il de

typeof(IWhatever).GetTypeInfo().IsInterface

Une bonne réponse est

typeof(MyType).GetInterface(nameof(IMyInterface)) != null;

cependant,

typeof(MyType).IsAssignableFrom(typeof(IMyInterface));

peut renvoyer un résultat incorrect, comme le montre le code suivant avec chaîne et IConvertible:

    static void TestIConvertible()
    {
        string test = "test";
        Type stringType = typeof(string); // or test.GetType();

        bool isConvertibleDirect = test is IConvertible;
        bool isConvertibleTypeAssignable = stringType.IsAssignableFrom(typeof(IConvertible));
        bool isConvertibleHasInterface = stringType.GetInterface(nameof(IConvertible)) != null;

        Console.WriteLine($"isConvertibleDirect: {isConvertibleDirect}");
        Console.WriteLine($"isConvertibleTypeAssignable: {isConvertibleTypeAssignable}");
        Console.WriteLine($"isConvertibleHasInterface: {isConvertibleHasInterface}");
    }

Résultats:

 isConvertibleDirect: True
 isConvertibleTypeAssignable: False
 isConvertibleHasInterface: True

Notez que si vous avez une interface générique, IMyInterface<T>cela retournera toujours false:

  typeof(IMyInterface<>).IsAssignableFrom(typeof(MyType)) /* ALWAYS FALSE */

Cela ne fonctionne pas non plus:

  typeof(MyType).GetInterfaces().Contains(typeof(IMyInterface<>))  /* ALWAYS FALSE */

Cependant, si MyTypeimplémente IMyInterface<MyType>cela fonctionne et retourne true:

  typeof(IMyInterface<MyType>).IsAssignableFrom(typeof(MyType))

Cependant, vous ne connaîtrez probablement pas le paramètre de type Tlors de l'exécution . Une solution quelque peu hacky est:

  typeof(MyType).GetInterfaces()
                .Any(x=>x.Name == typeof(IMyInterface<>).Name)

La solution de Jeff est un peu moins hacky:

  typeof(MyType).GetInterfaces()
         .Any(i => i.IsGenericType 
             && i.GetGenericTypeDefinition() == typeof(IMyInterface<>));

Voici une méthode d'extension Typequi fonctionne dans tous les cas:

public static class TypeExtensions
{
    public static bool IsImplementing(this Type type, Type someInterface)
    {
        return type.GetInterfaces()
             .Any(i => i == someInterface 
                 || i.IsGenericType 
                    && i.GetGenericTypeDefinition() == someInterface);
    }
}

(Notez que ce qui précède utilise linq, qui est probablement plus lent qu'une boucle.)

Vous pouvez alors faire:

   typeof(MyType).IsImplementing(IMyInterface<>)