Tester si l'objet implémente l'interface

L'utilisation des opérateurs is ou as est 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 propre que de regarder à travers le tableau retourné par GetInterfaces et a l'avantage de travailler aussi pour les classes.

Pour l'exemple:

if (obj is IMyInterface) {}

Pour la classe:

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

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

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

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 transmises 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 suis pas sûr de la version de.Net dans laquelle cela a été implémenté, donc cela peut ne pas fonctionner dans votre version.

Ce qui a fonctionné pour moi est:

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

Si vous souhaitez utiliser l'objet typecasted 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 les documents. net: Pattern matching with is # Type pattern

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. J'ai utilisé ceci à la place et cela a fonctionné (note: l'écriture de l'espace de noms pourrait être requise).

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.

Ce Post - est une bonne réponse.

public interface IMyInterface {}

public class MyType : IMyInterface {}

Ceci est un exemple simple:

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

Ou

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

J'ai eu une situation où je passais une variable à une méthode et je ne savais pas si ce serait une interface ou un objet.

Les objectifs étaient:

1. Si item est une interface, instanciez un objet basé sur cette interface, l'interface étant un paramètre dans l'appel du constructeur.
2. Si l'élément est un objet, renvoyez un null puisque le constuctor pour mes appels attend une interface et je ne voulais pas que le code soit réservoir.

J'ai réalisé ceci avec ce qui suit:

    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))