[C#] Come determinare se un tipo implementa un'interfaccia con riflessione C #


Answers

Usa Type.IsAssignableFrom :

typeof(IMyInterface).IsAssignableFrom(typeof(MyType));
Question

La riflessione in C# offre un modo per determinare se alcuni tipi di tipi System.Type un'interfaccia?

public interface IMyInterface {}

public class MyType : IMyInterface {}

// should yield 'true'
typeof(MyType)./* ????? */MODELS_INTERFACE(IMyInterface);



Come già detto da qualcun altro: Benjamin, 10 aprile 13 alle 22:21 "

È stato facile non prestare attenzione e ottenere gli argomenti per IsAssignableFrom all'indietro. Vado con GetInterfaces ora: p -

Beh, un altro modo per creare un metodo di estensione breve che soddisfi, in una certa misura, il modo di pensare "più normale" (e ha convenuto che si tratta di una scelta personale minima per renderla leggermente "più naturale" in base alle proprie preferenze ):

public static class TypeHelpers
{
    public static Boolean IsAssignableTo(Type type, Type assignableType)
    {
        return assignableType.IsAssignableFrom(type);
    }
}

public static class TypeExtensions
{
    public static Boolean IsAssignableTo(this Type type, Type assignableType)
    {
        return TypeHelpers.IsAssignableTo(type, assignableType);
    }
}

E perché non andare un po 'più generico (beh, non sono sicuro che sia davvero così interessante, beh, suppongo di aver appena passato un altro pizzico di zucchero "sintassi"):

public static class TypeHelpers
{
    public static Boolean IsAssignableTo(Type type, Type assignableType)
    {
        return assignableType.IsAssignableFrom(type);
    }

    public static Boolean IsAssignableTo<TAssignable>(Type type)
    {
        return TypeHelpers.IsAssignableTo(type, typeof(TAssignable));
    }
}

public static class TypeExtensions
{
    public static Boolean IsAssignableTo(this Type type, Type assignableType)
    {
        return TypeHelpers.IsAssignableTo(type, assignableType);
    }

    public static Boolean IsAssignableTo<TAssignable>(this Type type)
    {
        return TypeHelpers.IsAssignableTo<TAssignable>(type);
    }
}

Penso che potrebbe essere molto più naturale in questo modo, ma ancora una volta solo una questione di opinioni molto personali:

var isTrue = michelleType.IsAssignableTo<IMaBelle>();



che dire

if(MyType as IMyInterface != null)

?




    public static bool ImplementsInterface( this Type type, Type ifaceType ) {
        Type[] intf = type.GetInterfaces();
        for ( int i = 0; i < intf.Length; i++ ) {
            if ( intf[ i ] == ifaceType ) {
                return true;
            }
        }
        return false;
    }

Penso che questa sia la versione corretta, per tre motivi:

1) Utilizza GetInterfaces e non IsAssignableFrom, è più veloce poiché IsAssignableFrom alla fine dopo diversi controlli chiama GetInterfaces.
2) Iterates sopra la matrice locale, quindi non ci saranno controlli di limiti.
3) Usa l'operatore == che è definito per Type, quindi probabilmente è più sicuro del metodo Equals (che la chiamata Contains, alla fine userà).




Una risposta corretta è

typeof(MyType).GetInterface(nameof(IMyInterface)) != null;

Però,

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

potrebbe restituire un risultato errato, come mostra il codice seguente con string e IConvertible:

    static void TestIConvertible()
    {
        string test = "test";
        Type stringType = typeof(string); // or test.GetType();

        bool isConvertibleDirect = test is IConvertible;
        bool isConvertibleTypeAssignable = stringType.IsAssignableFrom(typeof(IConvertible));
        bool isConvertibleHasInterface = stringType.GetInterface(nameof(IConvertible)) != null;

        Console.WriteLine($"isConvertibleDirect: {isConvertibleDirect}");
        Console.WriteLine($"isConvertibleTypeAssignable: {isConvertibleTypeAssignable}");
        Console.WriteLine($"isConvertibleHasInterface: {isConvertibleHasInterface}");
    }

risultati:

 isConvertibleDirect: True
 isConvertibleTypeAssignable: False
 isConvertibleHasInterface: True



Links