Sprawdź, czy obiekt implementuje interfejs

Jaki jest najprostszy sposób sprawdzenia, czy obiekt implementuje dany interfejs w języku C #? (Odpowiedz na to pytanie w Javie )

if (object is IBlah)

lub

IBlah myTest = originalObject as IBlah

if (myTest != null)

Używanie operatorów islub asjest poprawnym sposobem, jeśli znasz typ interfejsu w czasie kompilacji i masz instancję testowanego typu. Coś, o czym nikt inny nie wspomniał, to Type.IsAssignableFrom:

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

Myślę, że jest to o wiele ładniejsze niż przeglądanie tablicy zwróconej przez GetInterfacesi ma tę zaletę, że działa również dla klas.

Na przykład:

if (obj is IMyInterface) {}

Dla klasy:

Sprawdź, czy typeof(MyClass).GetInterfaces()zawiera interfejs.

Jeśli chcesz użyć obiektu zapisanego po sprawdzeniu:
Od wersji C # 7.0:

if (obj is IMyInterface myObj)

To jest to samo co

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

Zobacz Dokumenty .NET: Dopasowywanie wzorca za pomocą iswzorca # Type

Odmiana odpowiedzi @ AndrewKennan, której ostatnio użyłem do typów uzyskanych w czasie wykonywania:

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

Ten post jest dobrą odpowiedzią.

public interface IMyInterface {}

public class MyType : IMyInterface {}

To prosta próbka:

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

lub

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

Oprócz testowania za pomocą operatora „jest” możesz ozdobić swoje metody, aby upewnić się, że przekazywane do niego zmienne implementują określony interfejs, na przykład:

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

Nie jestem pewien, w której wersji .Net został zaimplementowany, więc może nie działać w twojej wersji.

Dla mnie zadziałało:

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

Ostatnio próbowałem użyć odpowiedzi Andrew Kennana i z jakiegoś powodu nie działało to dla mnie. Użyłem tego zamiast tego i zadziałało (uwaga: może być wymagane wpisanie przestrzeni nazw).

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

użyłem

Assert.IsTrue(myObject is ImyInterface);

dla testu w moim teście jednostkowym, który sprawdza, czy myObject jest obiektem, który zaimplementował mój interfejs ImyInterface.

Miałem sytuację, w której przekazywałem zmienną do metody i nie byłem pewien, czy będzie to interfejs, czy obiekt.

Cele były następujące:

1. Jeśli item jest interfejsem, utwórz obiekt na podstawie tego interfejsu, przy czym interfejs jest parametrem w wywołaniu konstruktora.
2. Jeśli element jest obiektem, zwróć wartość null, ponieważ konstruktor dla moich wywołań oczekuje interfejsu i nie chciałem, aby kod był tankowany.

Osiągnąłem to dzięki:

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

To powinno działać:

MyInstace.GetType().GetInterfaces();

Ale też miłe:

if (obj is IMyInterface)

Lub nawet (niezbyt elegancko):

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