Typprüfung: typeof, GetType oder is?

Ich habe viele Leute gesehen, die 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 dieses:

if (obj1 is int)
    // Some code here

Persönlich denke ich, dass der letzte der sauberste ist, aber fehlt mir etwas? Welches ist das beste oder ist es eine persönliche Präferenz?

Alle sind unterschiedlich.

• typeof Nimmt einen Typnamen (den Sie zur Kompilierungszeit angeben).
• GetType Ruft den Laufzeittyp einer Instanz ab.
• is Gibt true zurück, wenn sich eine Instanz im Vererbungsbaum befindet.

Beispiel

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

Was ist mit typeof(T)? Wird es auch beim Kompilieren behoben?

Ja. T ist immer der Typ des Ausdrucks. Denken Sie daran, dass eine generische Methode im Grunde eine ganze Reihe von Methoden mit dem entsprechenden Typ ist. Beispiel:

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); // this calls Foo<Animal> and returns "Animal"
Foo<Animal>(probably_a_dog); // this is exactly the same as above
Foo<Dog>(probably_a_dog); // !!! This will not compile. The parameter expects a Dog, you cannot pass in an Animal.

Foo(definitely_a_dog); // this calls Foo<Dog> and returns "Dog"
Foo<Dog>(definitely_a_dog); // this is exactly the same as above.
Foo<Animal>(definitely_a_dog); // this calls Foo<Animal> and returns "Animal". 
Foo((Animal)definitely_a_dog); // this does the same as above, returns "Animal"

Verwenden typeofSie diese Option, wenn Sie den Typ zur Kompilierungszeit abrufen möchten . Verwenden GetTypeSie diese Option, wenn Sie den Typ zur Ausführungszeit abrufen möchten . Es gibt selten Fälle, die verwendet werden müssen, isda es sich um eine Umwandlung handelt, und in den meisten Fällen wird die Variable trotzdem umgewandelt.

Es gibt eine vierte Option, die Sie nicht in Betracht gezogen haben (insbesondere, wenn Sie ein Objekt in den Typ umwandeln möchten, den Sie ebenfalls finden). das ist zu verwenden as.

Foo foo = obj as Foo;

if (foo != null)
    // your code here

Dies verwendet nur eine Besetzung, während dieser Ansatz:

if (obj is Foo)
    Foo foo = (Foo)obj;

erfordert zwei .

Update (Januar 2020):

• Ab C # 7+ können Sie jetzt Inline-Casting durchführen, sodass der "Ist" -Ansatz jetzt auch in einem Cast ausgeführt werden kann.

Beispiel:

if(obj is Foo newLocalFoo)
{
    // For example, you can now reference 'newLocalFoo' in this local scope
    Console.WriteLine(newLocalFoo);
}

1.

Type t = typeof(obj1);
if (t == typeof(int))

Dies ist unzulässig, da typeofnur Typen und keine Variablen verwendet werden. Ich gehe davon aus, dass obj1 eine Variable ist. Auf diese Weise typeofist es also statisch und erledigt seine Arbeit zur Kompilierungszeit anstatt zur Laufzeit.

2.

if (obj1.GetType() == typeof(int))

Dies ist, truewenn obj1es genau vom Typ ist int. Wenn obj1abgeleitet von int, wird die if-Bedingung sein false.

3.

if (obj1 is int)

Dies ist, truewenn obj1es sich um eine inthandelt oder wenn es von einer aufgerufenen Klasse abgeleitet intist oder wenn eine aufgerufene Schnittstelle implementiert wird int.

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

Dies ist ein Fehler. Der Operator typeof in C # kann nur Typnamen annehmen, keine Objekte.

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

Dies wird funktionieren, aber vielleicht nicht so, wie Sie es erwarten würden. Wie Sie hier gezeigt haben, ist dies für Werttypen akzeptabel. Für Referenztypen wird jedoch nur true zurückgegeben, wenn der Typ genau derselbe Typ ist und nicht etwas anderes in der Vererbungshierarchie. Zum Beispiel:

class Animal{}
class Dog : Animal{}

static void Foo(){
    object o = new Dog();

    if(o.GetType() == typeof(Animal))
        Console.WriteLine("o is an animal");
    Console.WriteLine("o is something else");
}

Dies würde drucken "o is something else", weil die Art der oist Dog, nicht Animal. Sie können dies jedoch zum Laufen bringen, wenn Sie die IsAssignableFromMethode der TypeKlasse verwenden.

if(typeof(Animal).IsAssignableFrom(o.GetType())) // note use of tested type
    Console.WriteLine("o is an animal");

Diese Technik hinterlässt jedoch immer noch ein großes Problem. Wenn Ihre Variable null ist, GetType()löst der Aufruf von eine NullReferenceException aus. Damit es richtig funktioniert, müssen Sie Folgendes tun:

if(o != null && typeof(Animal).IsAssignableFrom(o.GetType()))
    Console.WriteLine("o is an animal");

Damit haben Sie ein gleichwertiges Verhalten des isSchlüsselworts. Wenn dies das gewünschte Verhalten ist, sollten Sie daher das isSchlüsselwort verwenden, das lesbarer und effizienter ist.

if(o is Animal)
    Console.WriteLine("o is an animal");

In den meisten Fällen ist das isSchlüsselwort jedoch immer noch nicht das, was Sie wirklich wollen, da es normalerweise nicht ausreicht, nur zu wissen, dass ein Objekt von einem bestimmten Typ ist. Normalerweise wollen Sie tatsächlich nutzen das Objekt als Instanz dieses Typs, die es auch erfordert Gießen. Und so können Sie feststellen, dass Sie Code wie folgt schreiben:

if(o is Animal)
    ((Animal)o).Speak();

Dadurch überprüft die CLR den Objekttyp bis zu zweimal. Es wird einmal überprüft, um den isBediener zufrieden zu stellen , und wenn dies otatsächlich der AnimalFall ist, wird es erneut überprüft, um die Besetzung zu validieren.

Es ist effizienter, dies stattdessen zu tun:

Animal a = o as Animal;
if(a != null)
    a.Speak();

Der asOperator ist eine Besetzung, die keine Ausnahme auslöst, wenn sie fehlschlägt, sondern zurückkehrt null. Auf diese Weise überprüft die CLR den Objekttyp nur einmal, und danach müssen wir nur noch eine Nullprüfung durchführen, was effizienter ist.

Aber Vorsicht: Viele Menschen geraten mit in eine Falle as. Da es keine Ausnahmen gibt, betrachten einige Leute es als "sichere" Besetzung, und sie verwenden es ausschließlich und meiden reguläre Besetzungen. Dies führt zu solchen Fehlern:

(o as Animal).Speak();

In diesem Fall wird der Entwickler deutlich unter der Annahme , dass owird immer eine sein Animal, und solange ihre Annahme richtig ist, funktioniert alles einwandfrei. Aber wenn sie falsch liegen, dann ist das, was sie hier haben, ein NullReferenceException. Mit einer regulären Besetzung hätten sie InvalidCastExceptionstattdessen eine bekommen , die das Problem genauer identifiziert hätte.

Manchmal ist dieser Fehler schwer zu finden:

class Foo{
    readonly Animal animal;

    public Foo(object o){
        animal = o as Animal;
    }

    public void Interact(){
        animal.Speak();
    }
}

Dies ist ein weiterer Fall, in dem der Entwickler eindeutig erwartet o, dass dies Animaljedes Mal der Fall ist. Dies ist jedoch im Konstruktor, in dem die asBesetzung verwendet wird, nicht offensichtlich . Es ist nicht offensichtlich, bis Sie zu der InteractMethode gelangen, bei der animalerwartet wird, dass das Feld positiv zugewiesen wird. In diesem Fall kommt es nicht nur zu einer irreführenden Ausnahme, sondern sie wird erst viel später ausgelöst, als der eigentliche Fehler aufgetreten ist.

Zusammenfassend:

• Wenn Sie nur wissen müssen, ob ein Objekt von einem Typ ist oder nicht, verwenden Sie is.

• Wenn Sie ein Objekt als Instanz eines bestimmten Typs behandeln müssen, aber nicht sicher sind, ob das Objekt von diesem Typ ist, verwenden Sie es asund suchen Sie nach null.

• Wenn Sie ein Objekt als Instanz eines bestimmten Typs behandeln müssen und das Objekt von diesem Typ sein soll, verwenden Sie eine reguläre Besetzung.

Wenn Sie C # 7 verwenden, ist es Zeit für ein Update von Andrew Hares großartiger Antwort. Der Mustervergleich hat eine nette Verknüpfung eingeführt, die uns eine typisierte Variable im Kontext der if-Anweisung gibt, ohne dass eine separate Deklaration / Besetzung und Prüfung erforderlich ist:

if (obj1 is int integerValue)
{
    integerValue++;
}

Für eine einzelne Besetzung wie diese sieht das ziemlich überwältigend aus, aber es scheint wirklich, wenn viele mögliche Typen in Ihre Routine kommen. Das Folgende ist der alte Weg, um zweimaliges Casting zu vermeiden:

Button button = obj1 as Button;
if (button != null)
{
    // do stuff...
    return;
}
TextBox text = obj1 as TextBox;
if (text != null)
{
    // do stuff...
    return;
}
Label label = obj1 as Label;
if (label != null)
{
    // do stuff...
    return;
}
// ... and so on

Es hat mich immer gestört, diesen Code so weit wie möglich zu verkleinern und doppelte Besetzungen desselben Objekts zu vermeiden. Das Obige ist gut komprimiert und weist folgende Muster auf:

switch (obj1)
{
    case Button button:
        // do stuff...
        break;
    case TextBox text:
        // do stuff...
        break;
    case Label label:
        // do stuff...
        break;
    // and so on...
}

BEARBEITEN: Die längere neue Methode wurde aktualisiert, um einen Schalter gemäß Palecs Kommentar zu verwenden.

Ich hatte eine TypeEigenschaft zum Vergleichen und konnte sie nicht verwenden is(wie my_type is _BaseTypetoLookFor), aber ich konnte diese verwenden:

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

Beachten Sie dies IsInstanceOfTypeund IsAssignableFromkehren Sie zurück, truewenn Sie dieselben Typen vergleichen, wobei IsSubClassOf zurückgibt false. Und IsSubclassOffunktioniert nicht an Schnittstellen, wo die anderen beiden tun. (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

Ich bevorzuge ist

Das heißt, wenn Sie verwenden ist , sind Sie wahrscheinlich nicht Vererbung richtig verwenden.

Angenommen, diese Person: Entität und dieses 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
    }
  }
}

Lieber

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

Ich glaube, der letzte befasst sich auch mit der Vererbung (z. B. Hund ist Tier == wahr), was in den meisten Fällen besser ist.

Es kommt darauf an, was ich mache. Wenn ich einen Bool-Wert benötige (z. B. um festzustellen, ob ich in einen Int umwandle), verwende ich is. Wenn ich den Typ aus irgendeinem Grund tatsächlich brauche (z. B. um zu einer anderen Methode überzugehen), werde ich ihn verwenden GetType().

Der letzte ist sauberer, offensichtlicher und sucht auch nach Subtypen. Die anderen prüfen nicht auf Polymorphismus.

Wird verwendet, um das System.Type-Objekt für einen Typ abzurufen. Ein Ausdruckstyp hat die folgende Form:

System.Type type = typeof(int);

Example:

    public class ExampleClass
    {
       public int sampleMember;
       public void SampleMethod() {}

       static void Main()
       {
          Type t = typeof(ExampleClass);
          // Alternatively, you could use
          // ExampleClass obj = new ExampleClass();
          // Type t = obj.GetType();

          Console.WriteLine("Methods:");
          System.Reflection.MethodInfo[] methodInfo = t.GetMethods();

          foreach (System.Reflection.MethodInfo mInfo in methodInfo)
             Console.WriteLine(mInfo.ToString());

          Console.WriteLine("Members:");
          System.Reflection.MemberInfo[] memberInfo = t.GetMembers();

          foreach (System.Reflection.MemberInfo mInfo in memberInfo)
             Console.WriteLine(mInfo.ToString());
       }
    }
    /*
     Output:
        Methods:
        Void SampleMethod()
        System.String ToString()
        Boolean Equals(System.Object)
        Int32 GetHashCode()
        System.Type GetType()
        Members:
        Void SampleMethod()
        System.String ToString()
        Boolean Equals(System.Object)
        Int32 GetHashCode()
        System.Type GetType()
        Void .ctor()
        Int32 sampleMember
    */

In diesem Beispiel wird mithilfe der GetType-Methode der Typ ermittelt, der das Ergebnis einer numerischen Berechnung enthält. Dies hängt von den Speicheranforderungen der resultierenden Anzahl ab.

    class GetTypeTest
    {
        static void Main()
        {
            int radius = 3;
            Console.WriteLine("Area = {0}", radius * radius * Math.PI);
            Console.WriteLine("The type is {0}",
                              (radius * radius * Math.PI).GetType()
            );
        }
    }
    /*
    Output:
    Area = 28.2743338823081
    The type is System.Double
    */

if (c is UserControl) c.Enabled = enable;

Sie können den Operator "typeof ()" in C # verwenden, müssen jedoch den Namespace mit System.IO aufrufen. Sie müssen das Schlüsselwort "is" verwenden, wenn Sie nach einem Typ suchen möchten.

Leistungstest typeof () vs GetType ():

using System;
namespace ConsoleApplication1
    {
    class Program
    {
        enum TestEnum { E1, E2, E3 }
        static void Main(string[] args)
        {
            {
                var start = DateTime.UtcNow;
                for (var i = 0; i < 1000000000; i++)
                    Test1(TestEnum.E2);
                Console.WriteLine(DateTime.UtcNow - start);
            }
            {
                var start = DateTime.UtcNow;
                for (var i = 0; i < 1000000000; i++)
                    Test2(TestEnum.E2);
                Console.WriteLine(DateTime.UtcNow - start);
            }
            Console.ReadLine();
        }
        static Type Test1<T>(T value) => typeof(T);
        static Type Test2(object value) => value.GetType();
    }
}

Ergebnisse im Debug-Modus:

00:00:08.4096636
00:00:10.8570657

Ergebnisse im Release-Modus:

00:00:02.3799048
00:00:07.1797128