Проверка типа: typeof, GetType или есть?

Все разные.

• typeof принимает имя типа (которое вы указываете во время компиляции).
• GetType получает тип среды выполнения экземпляра.
• is возвращает истину, если экземпляр находится в дереве наследования.

Пример

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

А что насчет typeof(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"

Используйте typeof, если хотите получить тип во время компиляции. Используйте GetType, если хотите получить тип во время выполнения. Редко бывает, что is используется, так как он выполняет приведение, и в большинстве случаев вы все равно приводите переменную.

Есть четвертый вариант, который вы не рассматривали (особенно если вы также собираетесь преобразовать объект в найденный вами тип); то есть использовать as.

Foo foo = obj as Foo;

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

Здесь используется только одно приведение , тогда как этот подход:

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

требуется два.

Обновление (январь 2020 г.):

• Начиная с C # 7+, теперь вы можете выполнять встроенное преобразование, поэтому подход« есть »теперь может быть реализован и в одном преобразовании.

Пример:

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

Это недопустимо, потому что typeof работает только с типами, а не с переменными. Я предполагаю, что obj1 - это переменная. Таким образом, typeof статичен и выполняет свою работу во время компиляции, а не во время выполнения.

2.

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

Это true, если obj1 точно относится к типу int. Если obj1 является производным от int, условием if будет false.

3.

if (obj1 is int)

Это true, если obj1 является int, или если он является производным от класса с именем int, или если он реализует интерфейс с именем int.

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

Это ошибка. Оператор typeof в C # может принимать только имена типов, но не объекты.

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

Это сработает, но, возможно, не так, как вы ожидали. Для типов значений, как вы показали здесь, это приемлемо, но для ссылочных типов оно вернет истину только в том случае, если тип будет точно таким же типом, а не чем-то другим в иерархии наследования. Например:

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

Это напечатает "o is something else", потому что тип o - Dog, а не Animal. Однако вы можете добиться этого, если используете метод IsAssignableFrom класса Type.

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

Однако этот метод по-прежнему оставляет серьезную проблему. Если ваша переменная равна нулю, вызов GetType() вызовет исключение NullReferenceException. Итак, чтобы он работал правильно, вам нужно сделать:

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

При этом у вас есть эквивалентное поведение ключевого слова is. Следовательно, если это именно то поведение, которое вы хотите, вы должны использовать ключевое слово is, которое более читабельно и более эффективно.

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

Однако в большинстве случаев ключевое слово is по-прежнему не то, что вам нужно, потому что обычно недостаточно просто знать, что объект относится к определенному типу. Обычно вы хотите фактически использовать этот объект как экземпляр этого типа, что тоже требует его приведения. И поэтому вы можете написать такой код:

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

Но это заставляет CLR проверять тип объекта до двух раз. Он проверит его один раз, чтобы удовлетворить оператора is, и если o действительно Animal, мы заставим его проверить еще раз, чтобы подтвердить приведение.

Вместо этого более эффективно сделать это:

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

Оператор as - это приведение, которое не генерирует исключение в случае сбоя, вместо этого возвращает null. Таким образом, CLR проверяет тип объекта только один раз, а после этого нам просто нужно выполнить нулевую проверку, что более эффективно.

Но будьте осторожны: многие люди попадают в ловушку с as. Поскольку он не генерирует исключений, некоторые люди думают о нем как о «безопасном» приведении и используют исключительно его, избегая обычных приведений. Это приводит к таким ошибкам:

(o as Animal).Speak();

В этом случае разработчик явно предполагает, что o всегда будет Animal, и пока их предположение верно, все работает нормально. Но если они ошибаются, то в итоге они получают NullReferenceException. При обычном приведении вместо этого они получили бы InvalidCastException, что позволило бы более правильно определить проблему.

Иногда эту ошибку бывает сложно найти:

class Foo{
    readonly Animal animal;

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

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

Это еще один случай, когда разработчик явно ожидает, что o будет каждый раз Animal, но это не очевидно в конструкторе, где используется as приведение. Это не очевидно, пока вы не дойдете до метода Interact, где ожидается, что поле animal будет положительно назначено. В этом случае вы не только получите вводящее в заблуждение исключение, но и не сгенерируете его до тех пор, пока возможно намного позже, чем когда произошла фактическая ошибка.

В итоге:

• Если вам нужно только знать, принадлежит ли объект к какому-либо типу, используйте is.

• Если вам нужно рассматривать объект как экземпляр определенного типа, но вы не знаете наверняка, будет ли объект этого типа, используйте as и проверьте null.

• Если вам нужно рассматривать объект как экземпляр определенного типа, и объект должен быть этого типа, используйте обычное приведение.

Если вы используете C # 7, то пришло время обновить отличный ответ Эндрю Хейра. В сопоставлении с образцом появился удобный ярлык, который дает нам типизированную переменную. в контексте оператора if, не требуя отдельного объявления / приведения и проверки:

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

Это выглядит довольно неутешительно для одного такого приведения, но действительно хорошо, когда в вашу рутину входит много возможных типов. Ниже приведен старый способ избежать двойного преобразования:

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

Меня всегда беспокоило стремление максимально сжать этот код, а также избежать дублирования приведений одного и того же объекта. Вышеупомянутое красиво сжато с сопоставлением с образцом до следующего:

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

EDIT: обновлен более длинный новый метод для использования переключателя в соответствии с комментарием Palec.

У меня было свойство Type для сравнения, и я не мог использовать is (например, my_type is _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

Я предпочитаю это

Тем не менее, если вы используете is, вы, скорее всего, не правильно используете наследование.

Предположим, что это лицо: сущность и животное: сущность. Feed - это виртуальный метод в Entity (чтобы сделать Нила счастливым)

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
    }
  }
}

Скорее

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

Я считаю, что последний также рассматривает наследование (например, Dog is Animal == true), что в большинстве случаев лучше.

Это зависит от того, что я делаю. Если мне нужно значение типа bool (скажем, чтобы определить, приведу ли я к типу int), я буду использовать is. Если мне действительно нужен тип по какой-то причине (скажем, для перехода к другому методу), я буду использовать GetType().

Последний вариант чище, очевиднее и также проверяет подтипы. Остальные не проверяют полиморфизм.

Используется для получения объекта System.Type для типа. Выражение typeof принимает следующую форму:

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
    */

В этом примере используется метод GetType для определения типа, который используется для хранения результата числового вычисления. Это зависит от требований к хранению полученного числа.

    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
    */

Вы можете использовать оператор typeof () в C #, но вам нужно вызвать пространство имен с помощью System.IO; Вы должны использовать ключевое слово "is", если хотите проверить тип.

Тест производительности 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();
    }
}

Результаты в режиме отладки:

00:00:08.4096636
00:00:10.8570657

Результаты в режиме выпуска:

00:00:02.3799048
00:00:07.1797128