Probar si el objeto implementa la interfaz

¿Cuál es la forma más simple de probar si un objeto implementa una interfaz dada en C #? (Respuesta a esta pregunta en Java )

if (object is IBlah)

o

IBlah myTest = originalObject as IBlah

if (myTest != null)

Usar los operadores iso ases la forma correcta si conoce el tipo de interfaz en tiempo de compilación y tiene una instancia del tipo que está probando. Algo que nadie más parece haber mencionado es Type.IsAssignableFrom:

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

Creo que esto es mucho más ordenado que mirar a través de la matriz devuelta GetInterfacesy también tiene la ventaja de trabajar para las clases.

Por ejemplo:

if (obj is IMyInterface) {}

Para la clase:

Compruebe si typeof(MyClass).GetInterfaces()contiene la interfaz.

Si desea usar el objeto con tipografía después de la verificación:
Desde C # 7.0:

if (obj is IMyInterface myObj)

Esto es lo mismo que

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

Consulte Documentos de .NET: coincidencia de patrones con is# Tipo de patrón

Una variación de la respuesta de @ AndrewKennan que terminé usando recientemente para los tipos obtenidos en tiempo de ejecución:

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

Esta publicación es una buena respuesta.

public interface IMyInterface {}

public class MyType : IMyInterface {}

Esta es una muestra simple:

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

o

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

Además de probar con el operador "es", puede decorar sus métodos para asegurarse de que las variables que se le pasen implementen una interfaz particular, de esta manera:

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

No estoy seguro de qué versión de .Net se implementó, por lo que es posible que no funcione en su versión.

Lo que funcionó para mí es:

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

Recientemente intenté usar la respuesta de Andrew Kennan y no me funcionó por alguna razón. Utilicé esto en su lugar y funcionó (nota: podría ser necesario escribir el espacio de nombres).

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

solía

Assert.IsTrue(myObject is ImyInterface);

para una prueba en mi unidad de prueba que prueba que myObject es un objeto que ha implementado mi interfaz ImyInterface.

Tuve una situación en la que estaba pasando una variable a un método y no estaba seguro de si iba a ser una interfaz o un objeto.

Los objetivos fueron:

1. Si item es una interfaz, cree una instancia de un objeto basado en esa interfaz con la interfaz como parámetro en la llamada del constructor.
2. Si el artículo es un objeto, devuelve un valor nulo ya que el constructor de mis llamadas espera una interfaz y no quería que el código se acumulara.

Lo logré con lo siguiente:

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

Esto debería funcionar :

MyInstace.GetType().GetInterfaces();

Pero bueno también:

if (obj is IMyInterface)

O incluso (no muy elegante):

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