我见过很多人使用以下代码:

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

但我知道你也可以这样做:

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

或者这个:

if (obj1 is int)
    // Some code here

就我个人而言,我觉得最后一个是最干净的,但我有什么遗漏吗?哪一个最好用,还是个人喜好?


当前回答

最后一个更干净、更明显,还检查子类型。其他的不检查多态性。

其他回答

这取决于我在做什么。如果我需要bool值(例如,确定是否将强制转换为int),我将使用is。如果我确实出于某种原因需要该类型(例如,传递给其他方法),我会使用GetType()。

1.

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

这是非法的,因为typeof只适用于类型,而不适用于变量。我假设obj1是一个变量。这样,typeof是静态的,它在编译时而不是运行时工作。

2.

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

如果obj1完全是int类型,则为true。如果obj2从int派生,则if条件将为false。

3.

if (obj1 is int)

如果obj1是一个int,或者它派生自一个名为int的类,或者它实现了一个称为int的接口,这就是真的。

我相信最后一个也涉及遗传(例如,狗是动物==真),这在大多数情况下更好。

我有一个要比较的Type属性,无法使用它(例如my_Type是_BaseTypetoLookFor),但我可以使用这些属性:

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

请注意,在比较相同类型时,IsInstanceOfType和IsAssignableFrom返回true,其中IsSubClassOf将返回false。IsSubclassOf不适用于接口,而其他两个则适用

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

一切都不同。

typeof采用类型名(您在编译时指定)。GetType获取实例的运行时类型。如果实例在继承树中,则返回true。

实例

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

T型怎么样?它是否也在编译时解决?

对T始终是表达式的类型。请记住,泛型方法基本上是一组具有适当类型的方法。例子:

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"