c# interface interfaces - Come determinare se un tipo implementa un'interfaccia con riflessione C #





5 Answers

Usa Type.IsAssignableFrom :

typeof(IMyInterface).IsAssignableFrom(typeof(MyType));
method using example

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



    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à).




Ho appena fatto:

public static bool Implements<I>(this Type source) where I : class
{
  return typeof(I).IsAssignableFrom(source);
}

Vorrei poter dire where I : interface , ma l' interface non è un'opzione di vincolo parametrico generico. class è il più vicino possibile.

Uso:

if(MyType.Implements<IInitializable>())
  MyCollection.Initialize();

Ho appena detto gli Implements perché è più intuitivo. Ricevo sempre IsAssignableFrom capovolto.




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



che dire

if(MyType as IMyInterface != null)

?




Related