Teste se o objeto implementa interface

Qual é a maneira mais simples de testar se um objeto implementa uma determinada interface em C #? (Responda a esta pergunta em Java )

if (object is IBlah)

ou

IBlah myTest = originalObject as IBlah

if (myTest != null)

Usar os operadores isou asé a maneira correta se você souber o tipo de interface no momento da compilação e tiver uma instância do tipo que está testando. Algo que ninguém mais parece ter mencionado é Type.IsAssignableFrom:

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

Eu acho que isso é muito melhor do que olhar através da matriz retornada GetInterfacese tem a vantagem de trabalhar para as classes também.

Para a instância:

if (obj is IMyInterface) {}

Para a turma:

Verifique se typeof(MyClass).GetInterfaces()contém a interface.

Se você deseja usar o objeto de conversão de tipo após a verificação:
Desde o C # 7.0:

if (obj is IMyInterface myObj)

É o mesmo que

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

Consulte .NET Docs: correspondência de padrões com o ispadrão # Type

Uma variação na resposta de @ AndrewKennan que acabei usando recentemente para tipos obtidos em tempo de execução:

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

Este post é uma boa resposta.

public interface IMyInterface {}

public class MyType : IMyInterface {}

Este é um exemplo simples:

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

ou

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

Além de testar usando o operador "is", você pode decorar seus métodos para garantir que as variáveis ​​transmitidas a ele implementem uma interface específica, como:

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

Não tenho certeza em qual versão do .Net foi implementada, portanto, pode não funcionar na sua versão.

O que funcionou para mim é:

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

Recentemente, tentei usar a resposta de Andrew Kennan e não funcionou para mim por algum motivo. Eu usei isso em vez disso e funcionou (nota: pode ser necessário escrever o espaço para nome).

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

eu usei

Assert.IsTrue(myObject is ImyInterface);

para um teste no meu teste de unidade que testa que myObject é um objeto que implementou minha interface ImyInterface.

Eu tive uma situação em que estava passando uma variável para um método e não tinha certeza se seria uma interface ou um objeto.

Os objetivos foram:

1. Se item for uma interface, instancie um objeto com base nessa interface, sendo a interface um parâmetro na chamada do construtor.
2. Se o item for um objeto, retorne um valor nulo, pois o construtor de minhas chamadas espera uma interface e eu não quero que o código seja armazenado.

Consegui isso com o seguinte:

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

Isso deve funcionar:

MyInstace.GetType().GetInterfaces();

Mas legal também:

if (obj is IMyInterface)

Ou até (não muito elegante):

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