<p>Tous sont differents.</p>
<ul>
<li>
<p><code>typeof</code> prend un nom de type (que vous specifiez a la compilation).</p>
</li>
<li>
<p><code>GetType</code> obtient le type a l’execution d’une instance.</p>
</li>
<li>
<p><code>is</code> retourne vrai si une instance est dans l’arbre d’heritage.</p>
</li>
</ul>
<p>Exemple</p>
<pre><code class="lang-auto">class Animal { }
class Dog : Animal { }
void PrintTypes(Animal a) {
Console.WriteLine(a.GetType() == typeof(Animal)); // false
Console.WriteLine(a is Animal); // true
Console.WriteLine(a.GetType() == typeof(Dog)); // true
Console.WriteLine(a is Dog); // true
}
Dog spot = new Dog();
PrintTypes(spot);
</code></pre>
<p>Qu’en est-il de <code>typeof(T)</code> ? Est-il egalement resolu a la compilation ?</p>
<p>Oui. T est toujours le type de l’expression. Rappelez-vous, une methode generique est fondamentalement tout un ensemble de methodes avec le type appropriate. Exemple :</p>
<pre><code class="lang-auto">string Foo<T>(T parameter) { return typeof(T).Name; }
Animal probably_a_dog = new Dog();
Dog definitely_a_dog = new Dog();
Foo(probably_a_dog); // ceci appelle Foo<Animal> et retourne "Animal"
Foo<Animal>(probably_a_dog); // ceci est exactement la meme chose que ci-dessus
Foo<Dog>(probably_a_dog); // !!! Ceci ne compilera pas. Le parametre attend un Dog, vous ne pouvez pas passer un Animal.
Foo(definitely_a_dog); // ceci appelle Foo<Dog> et retourne "Dog"
Foo<Dog>(definitely_a_dog); // ceci est exactement la meme chose que ci-dessus.
Foo<Animal>(definitely_a_dog); // ceci appelle Foo<Animal> et retourne "Animal".
Foo((Animal)definitely_a_dog); // ceci fait la meme chose que ci-dessus, retourne "Animal"
</code></pre>
