GetType renvoie des informations différentes de celles utilisées par l'opérateur

Question

Impossible d'expliquer ce qui se passe dans le programme suivant. GetType retourne le type que je veux retourner et non l'original. Cela signifie-t-il que nous ne pouvons pas compter sur GetType? l'opérateur a raison cependant. Quelqu'un peut-il l'expliquer en détail?

using System; 

namespace ConsoleApplication2 
{ 
    public class MyClass 
    { 
     public Type GetType() 
     { 
      return typeof(Program); 
     } 

    } 

class Program 
{ 
    static void Main(string[] args) 
    { 
     MyClass mc = new MyClass(); 

     if (mc.GetType() == typeof(Program)) 
     { 
      Console.WriteLine("Confused."); 
     } 
     if(mc is Program) 
     { 
      Console.WriteLine(mc.GetType()); // Don't get inside the if. Why? 
     } 

    } 
} 
} 

Mise à jour: Je lis le CLR livre via C# 3e édition. Dans le chapitre 4 (2ème page) quand il explique les méthodes différentes System.Object il dit

« La méthode GetType est nonvirtual, qui empêche une classe redéfinissant cette méthode et mentir sur son type »

Alors que je suis d'accord sur la première déclaration, je mens sur le type MyClass. n'est-ce pas?

Answer 1

is operator implemented in terms of as operator et enfin d'utiliser l'instruction isinst IL. Et bien sûr, cette instruction ne connaît pas votre méthode GetType virtuelle que vous définissez dans une classe de votre hiérarchie d'héritage.

Pour comprendre ce comportement « confusion » permet de « mettre en œuvre » notre propre version du « opérateur est »:

public class MyClass 
{ 
    public Type GetType() 
    { 
     return typeof(Program); 
    } 

} 

class Program { 

    //this is oversimplified implementation, 
    //but I want to show the main differences 
    public static bool IsInstOf(object o, Type t) 
    { 
     //calling GetType on System.Object 
     return o.GetType().IsAssignableFrom(t); 
    } 

    static void Main(string[] args) 
    { 
     MyClass mc = new MyClass(); 

     //calling MyClass non-virtual version for GetType method 
     if (mc.GetType() == typeof(Program)) 
     { 
      //Yep, this condition is true 
      Console.WriteLine("Not surprised!"); 
     } 

     //Calling System.Object non-virtual version for GetType method 
     if (IsInstOf(mc, typeof(Program))) 
     { 
      //Nope, this condition isn't met! 
      //because mc.GetType() != ((object)mc).GetType()! 
     } 

     Console.ReadLine(); 
    }    
} 

Answer 2

il ne sera vrai si:

if (mc is MyClass) { ... } 

Answer 3

Selon la documentation, le « est » opérateur n'est pas surchargeable. C'est pourquoi il ne va probablement pas entrer dans votre deuxième déclaration «si».

Consultez cette page de MSDN: http://msdn.microsoft.com/en-us/library/8edha89s%28v=VS.80%29.aspx

Answer 4

est vérifie le type d'exécution réelle de votre variable. Le compilateur ne se soucie pas que vous avez défini une méthode appelée GetType() qui renvoie une autre Type. Il sait toujours que le type actuall de votre variable est MyClass.

Qu'est-ce que vous essayez exactement d'accomplir ici? Pourquoi avez-vous besoin de votre classe MyClass pour emprunter l'identité de la classe Program?

Answer 5

Object.GetType n'est pas une méthode virtuelle. Donc mc is MyClass et appelle effectivement Object.GetType et non votre méthode.

Answer 6

Veuillez prendre soin de l'avertissement, tel qu'il existe pour des raisons. Votre code compilé avec l'avertissement suivant:

Warning 1 'ConsoleApplication2.MyClass.GetType()' hides inherited member 'object.GetType()'. Use the new keyword if hiding was intended.

qui signifie GetType() est la méthode non virtuelle et vous écrivez sans rapport avec des nouvelles GetType() que CLR ne sera jamais l'appeler.