Verifica se l'oggetto implementa l'interfaccia

Qual è il modo più semplice di testare se un oggetto implementa una determinata interfaccia in C #? (Rispondi a questa domanda in Java )

if (object is IBlah)

o

IBlah myTest = originalObject as IBlah

if (myTest != null)

L'uso degli operatori iso asè il modo corretto se si conosce il tipo di interfaccia in fase di compilazione e si dispone di un'istanza del tipo che si sta testando. Qualcosa che nessun altro sembra aver menzionato è Type.IsAssignableFrom:

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

Penso che sia molto più semplice che guardare attraverso l'array restituito GetInterfacese ha il vantaggio di lavorare anche per le classi.

Per esempio:

if (obj is IMyInterface) {}

Per la classe:

Controlla se typeof(MyClass).GetInterfaces()contiene l'interfaccia.

Se si desidera utilizzare l'oggetto typecasted dopo il controllo:
Da C # 7.0:

if (obj is IMyInterface myObj)

Questo è lo stesso di

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

Vedi .NET Docs: corrispondenza del modello con il ismodello # Type

Una variazione sulla risposta di @ AndrewKennan ho finito per usare di recente per i tipi ottenuti in fase di esecuzione:

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

Questo post è una buona risposta.

public interface IMyInterface {}

public class MyType : IMyInterface {}

Questo è un semplice esempio:

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

o

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

Oltre al test con l'operatore "is", puoi decorare i tuoi metodi per assicurarti che le variabili passate ad esso implementino una particolare interfaccia, in questo modo:

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

Non sono sicuro in quale versione di .Net sia stata implementata, quindi potrebbe non funzionare nella tua versione.

Ciò che ha funzionato per me è:

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

Di recente ho provato a utilizzare la risposta di Andrew Kennan e per qualche motivo non ha funzionato per me. Ho usato questo invece e ha funzionato (nota: potrebbe essere necessario scrivere lo spazio dei nomi).

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

ero solito

Assert.IsTrue(myObject is ImyInterface);

per un test nel mio unit test che verifica che myObject sia un oggetto che ha implementato la mia interfaccia ImyInterface.

Ho avuto una situazione in cui stavo passando una variabile a un metodo e non ero sicuro che sarebbe stata un'interfaccia o un oggetto.

Gli obiettivi erano:

1. Se l'elemento è un'interfaccia, creare un'istanza di un oggetto in base a tale interfaccia con l'interfaccia come parametro nella chiamata del costruttore.
2. Se l'articolo è un oggetto, restituire un valore null poiché il constuctor per le mie chiamate si aspetta un'interfaccia e non volevo che il codice si accumulasse.

Ho raggiunto questo con il seguente:

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

Questo dovrebbe funzionare:

MyInstace.GetType().GetInterfaces();

Ma anche bello:

if (obj is IMyInterface)

O anche (non molto elegante):

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