Tester si l'objet implémente l'interface

Quelle est la manière la plus simple de tester si un objet implémente une interface donnée en C #? (Réponse à cette question en Java )

if (object is IBlah)

ou

IBlah myTest = originalObject as IBlah

if (myTest != null)

L'utilisation des opérateurs isou asest la bonne façon si vous connaissez le type d'interface au moment de la compilation et avez une instance du type que vous testez. Quelque chose que personne d'autre ne semble avoir mentionné est Type.IsAssignableFrom:

if( typeof(IMyInterface).IsAssignableFrom(someOtherType) )
{
}

Je pense que c'est beaucoup plus net que de regarder à travers le tableau retourné par GetInterfaceset a l'avantage de travailler aussi pour les classes.

Par exemple:

if (obj is IMyInterface) {}

Pour la classe:

Vérifiez si typeof(MyClass).GetInterfaces()contient l'interface.

Si vous souhaitez utiliser l'objet transtypé après la vérification:
Depuis C # 7.0:

if (obj is IMyInterface myObj)

C'est la même chose que

IMyInterface myObj = obj as IMyInterface;
if (myObj != null)

Voir Docs .NET: correspondance de modèle avec ismodèle de type #

Une variante de la réponse de @ AndrewKennan que j'ai fini par utiliser récemment pour les types obtenus lors de l'exécution:

if (serviceType.IsInstanceOfType(service))
{
    // 'service' does implement the 'serviceType' type
}

Ce message est une bonne réponse.

public interface IMyInterface {}

public class MyType : IMyInterface {}

Voici un exemple simple:

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

ou

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

En plus de tester en utilisant l'opérateur "is", vous pouvez décorer vos méthodes pour vous assurer que les variables qui lui sont passées implémentent une interface particulière, comme ceci:

public static void BubbleSort<T>(ref IList<T> unsorted_list) where T : IComparable
{
     //Some bubbly sorting
}

Je ne sais pas dans quelle version de .Net cela a été implémenté, donc cela peut ne pas fonctionner dans votre version.

Ce qui a fonctionné pour moi, c'est:

Assert.IsNotNull(typeof (YourClass).GetInterfaces().SingleOrDefault(i => i == typeof (ISomeInterface)));

Récemment, j'ai essayé d'utiliser la réponse d'Andrew Kennan et cela n'a pas fonctionné pour moi pour une raison quelconque. Je l'ai utilisé à la place et cela a fonctionné (note: l'écriture de l'espace de noms peut être nécessaire).

if (typeof(someObject).GetInterface("MyNamespace.IMyInterface") != null)

j'ai utilisé

Assert.IsTrue(myObject is ImyInterface);

pour un test dans mon test unitaire qui teste que myObject est un objet qui a implémenté mon interface ImyInterface.

J'ai eu une situation où je passais une variable à une méthode et ne savais pas si ça allait être une interface ou un objet.

Les objectifs étaient les suivants:

1. Si item est une interface, instanciez un objet basé sur cette interface avec l'interface étant un paramètre dans l'appel du constructeur.
2. Si l'élément est un objet, retournez une valeur nulle, car le constructeur de mes appels attend une interface et je ne voulais pas que le code soit utilisé.

J'ai atteint cet objectif avec les éléments suivants:

    if(!typeof(T).IsClass)
    {
       // If your constructor needs arguments...
       object[] args = new object[] { my_constructor_param };
       return (T)Activator.CreateInstance(typeof(T), args, null);
    }
    else
       return default(T);

Cela devrait fonctionner:

MyInstace.GetType().GetInterfaces();

Mais sympa aussi:

if (obj is IMyInterface)

Ou même (pas très élégant):

if (obj.GetType() == typeof(IMyInterface))