Typprüfung: typeof, GetType, oder is?

Question

Ich habe gesehen, dass viele Leute den folgenden Code verwenden:

Type t = typeof(obj1);
if (t == typeof(int))
    // Some code here

Aber ich weiß, dass Sie das auch tun können:

if (obj1.GetType() == typeof(int))
    // Some code here

Oder dies:

if (obj1 is int)
    // Some code here

Ich persönlich finde die letzte Variante am saubersten, aber gibt es etwas, das ich übersehe? Welches ist am besten zu verwenden, oder ist das eine persönliche Vorliebe?

Answer 1

Ich hatte eine Type -Eigenschaft zum Vergleich und konnte nicht verwendet werden is (wie my_type is _BaseTypetoLookFor ), aber ich könnte sie gebrauchen:

base_type.IsInstanceOfType(derived_object);
base_type.IsAssignableFrom(derived_type);
derived_type.IsSubClassOf(base_type);

Beachten Sie, dass IsInstanceOfType y IsAssignableFrom return true beim Vergleich der gleichen Typen, wobei IsSubClassOf folgende Ergebnisse liefert false . Und IsSubclassOf funktioniert nicht bei Schnittstellen, während die beiden anderen funktionieren. (Siehe auch diese Frage und Antwort .)

public class Animal {}
public interface ITrainable {}
public class Dog : Animal, ITrainable{}

Animal dog = new Dog();

typeof(Animal).IsInstanceOfType(dog);     // true
typeof(Dog).IsInstanceOfType(dog);        // true
typeof(ITrainable).IsInstanceOfType(dog); // true

typeof(Animal).IsAssignableFrom(dog.GetType());      // true
typeof(Dog).IsAssignableFrom(dog.GetType());         // true
typeof(ITrainable).IsAssignableFrom(dog.GetType()); // true

dog.GetType().IsSubclassOf(typeof(Animal));            // true
dog.GetType().IsSubclassOf(typeof(Dog));               // false
dog.GetType().IsSubclassOf(typeof(ITrainable)); // false

Answer 2

Ich bevorzuge es

Das heißt, wenn Sie Folgendes verwenden es sind Sie wahrscheinlich no Vererbung richtig einsetzen.

Nehmen wir an, dass Person : Entität, und dass Tier : Entität. Feed ist eine virtuelle Methode in Entity (um Neil glücklich zu machen)

class Person
{
  // A Person should be able to Feed
  // another Entity, but they way he feeds
  // each is different
  public override void Feed( Entity e )
  {
    if( e is Person )
    {
      // feed me
    }
    else if( e is Animal )
    {
      // ruff
    }
  }
}

Vielmehr

class Person
{
  public override void Feed( Person p )
  {
    // feed the person
  }
  public override void Feed( Animal a )
  {
    // feed the animal
  }
}

Answer 3

Ich glaube, die letzte Option berücksichtigt auch die Vererbung (z. B. Hund ist Tier == wahr), was in den meisten Fällen besser ist.

Answer 4

Das hängt davon ab, was ich gerade tue. Wenn ich einen bool-Wert benötige (z. B. um festzustellen, ob ich in einen int-Wert casten soll), verwende ich is . Wenn ich den Typ aus irgendeinem Grund benötige (z. B. zur Übergabe an eine andere Methode), verwende ich GetType() .

Answer 5

Die letzte Variante ist sauberer, offensichtlicher und prüft auch auf Subtypen. Die anderen prüfen nicht auf Polymorphismus.