Utilisation de IsAssignableFrom et du mot clé "is" en C #

Question

Tout en essayant d'apprendre de l'Unité, je continue à voir le code suivant pour remplacer GetControllerInstance MVC:

if(!typeof(IController).IsAssignableFrom(controllerType)) { ... }

cela me semble être une assez alambiqué façon de l'écrire

if(controllerType is IController) { ... }

J'apprécie qu'il y a de subtiles différences entre is et IsAssignableFrom, c'est à dire IsAssignableFrom n'inclut pas la fonte des conversions, mais j'ai du mal à comprendre les implications de cette différence dans la pratique des scénarios.

Quand est-il imporantant de choisir IsAssignableFrom sur is? Quelle différence cela ferait-il dans l' GetControllerExample?

if (!typeof(IController).IsAssignableFrom(controllerType))
      throw new ArgumentException(...);
return _container.Resolve(controllerType) as IController;

Answer 1

Ce n'est pas la même chose.

 if(controllerType is IController)
 

évaluerait toujours à false puisque controllerType est toujours Type , et Type n'est jamais IController .

L'opérateur is est utilisé pour vérifier si une instance est compatible avec un type donné.

La méthode IsAssignableFrom est utilisée pour vérifier si un Type est compatible avec un type donné.

Answer 2

typeof(IController).IsAssignableFrom(controllerType) teste a Type rapport à l'interface. L'opérateur is teste une instance par rapport à l'interface.

Answer 3

Une différence notable est également que " est " fait sens intuitif pour les tests de l'héritage ou de l'interface de mise en œuvre, alors que IsAssignableFrom fait rien mais le bon sens sur le visage de celui-ci. Le nom du Type.IsAssignableFrom méthode est vague et confus lorsqu'il est appliqué à des tests d'héritage ou de détecter des implémentations d'interface. Le wrapper suivant à ces fins, serait beaucoup plus intuitive, plus lisible le code de l'application:

    public static bool CanBeTreatedAsType(this Type CurrentType, Type TypeToCompareWith)
    {
        // Always return false if either Type is null
        if (CurrentType == null || TypeToCompareWith == null)
            return false;

        // Return the result of the assignability test
        return TypeToCompareWith.IsAssignableFrom(CurrentType);
    }

Ensuite, on peut avoir plus compréhensible client une syntaxe du type:

    bool CanBeTreatedAs = typeof(SimpleChildClass).CanBeTreatedAsType(typeof(SimpleClass));
    CanBeTreatedAs = typeof(SimpleClass).CanBeTreatedAsType(typeof(IDisposable));

L'avantage de cette méthode au lieu de " est "mot-clé est qu'il peut être utilisé au moment de l'exécution pour tester inconnu, Types arbitraires, tandis que le" est " un mot (et un paramètre de Type générique) nécessite au moment de la compilation de connaissances de Types spécifiques.