Какой из этих фрагментов кода быстрее?
if (obj is ClassA) {}
if (obj.GetType() == typeof(ClassA)) {}
Изменить: я знаю, что они не делают то же самое.
Какой из этих фрагментов кода быстрее?
if (obj is ClassA) {}
if (obj.GetType() == typeof(ClassA)) {}
Изменить: я знаю, что они не делают то же самое.
Это должно ответить на то, что вопрос, а потом еще несколько.
Вторая строка, if (obj.GetType() == typeof(ClassA)) {}
, быстрее для тех, кто не хочет читать статью.
(Имейте в виду, что они не делают то же самое)
typeof(string).TypeHandle
в ldtoken
инструкцию CIL, но похоже, что CLR позаботится об этом в JIT. По-прежнему требуется несколько дополнительных кодов операций, но это более обобщенное применение оптимизации.
- person Sam Harwell; 22.02.2010
GetType
, is
всегда является более безопасным выбором с точки зрения производительности. Конечно, они делают разные вещи.
- person nawfal; 04.08.2014
object obj;
, разве она уже не упакована, когда это, как правило, проверяется? Есть ли случай, когда вам нужно проверить тип чего-то, а он еще не упакован как объект?
- person Rob Parker; 02.11.2016
GetType() == typeof
подход был самым быстрым (наименее расточительным) и FxCop предупреждал не использовать is
(as
лучше, но невозможно для типов структур; FxCop может не предупредили для is
с типом структуры). Возможно, is
более оптимизирован в .NET 4.x, чем раньше в .NET 2.0?
- person Rob Parker; 02.11.2016
object
, тогда вы правы, вызов GetType
не имеет значения. Но я не уверен, что это так в данной ссылке.
- person nawfal; 03.11.2016
IInterfaceForMyStruct myStruct = new MyStruct();
ведет к переменной в рамке. Конечно, все структуры и перечисления наследуются от общего базового класса ValueType
(который, в свою очередь, наследуется от object
, что приводит к унифицированной системе типов), но определяемые пользователем типы значений не могут наследовать что-либо, только реализуют i >.
- person nawfal; 22.11.2016
mystruct is MyStruct
, а не на mystruct.GetType()
, что вызовет бокс. Возможно, полезно в общем контексте.
- person nawfal; 28.11.2016
Имеет ли значение, что быстрее, если они не делают то же самое? Сравнивать эффективность утверждений с разным значением кажется плохой идеей.
is
сообщает вам, реализует ли объект ClassA
где-нибудь в своей иерархии типов. GetType()
расскажет вам о наиболее производном типе.
Не то же самое.
Они не делают то же самое. Первый работает, если obj имеет тип ClassA или некоторый подкласс ClassA. Второй будет соответствовать только объектам типа ClassA. Второй будет быстрее, так как ему не нужно проверять иерархию классов.
Для тех, кто хочет знать причину, но не хочет читать статью, указанную в is vs typeof.
Я провел несколько тестов, где они делают то же самое - закрытые типы.
var c1 = "";
var c2 = typeof(string);
object oc1 = c1;
object oc2 = c2;
var s1 = 0;
var s2 = '.';
object os1 = s1;
object os2 = s2;
bool b = false;
Stopwatch sw = Stopwatch.StartNew();
for (int i = 0; i < 10000000; i++)
{
b = c1.GetType() == typeof(string); // ~60ms
b = c1 is string; // ~60ms
b = c2.GetType() == typeof(string); // ~60ms
b = c2 is string; // ~50ms
b = oc1.GetType() == typeof(string); // ~60ms
b = oc1 is string; // ~68ms
b = oc2.GetType() == typeof(string); // ~60ms
b = oc2 is string; // ~64ms
b = s1.GetType() == typeof(int); // ~130ms
b = s1 is int; // ~50ms
b = s2.GetType() == typeof(int); // ~140ms
b = s2 is int; // ~50ms
b = os1.GetType() == typeof(int); // ~60ms
b = os1 is int; // ~74ms
b = os2.GetType() == typeof(int); // ~60ms
b = os2 is int; // ~68ms
b = GetType1<string, string>(c1); // ~178ms
b = GetType2<string, string>(c1); // ~94ms
b = Is<string, string>(c1); // ~70ms
b = GetType1<string, Type>(c2); // ~178ms
b = GetType2<string, Type>(c2); // ~96ms
b = Is<string, Type>(c2); // ~65ms
b = GetType1<string, object>(oc1); // ~190ms
b = Is<string, object>(oc1); // ~69ms
b = GetType1<string, object>(oc2); // ~180ms
b = Is<string, object>(oc2); // ~64ms
b = GetType1<int, int>(s1); // ~230ms
b = GetType2<int, int>(s1); // ~75ms
b = Is<int, int>(s1); // ~136ms
b = GetType1<int, char>(s2); // ~238ms
b = GetType2<int, char>(s2); // ~69ms
b = Is<int, char>(s2); // ~142ms
b = GetType1<int, object>(os1); // ~178ms
b = Is<int, object>(os1); // ~69ms
b = GetType1<int, object>(os2); // ~178ms
b = Is<int, object>(os2); // ~69ms
}
sw.Stop();
MessageBox.Show(sw.Elapsed.TotalMilliseconds.ToString());
Универсальные функции для проверки универсальных типов:
static bool GetType1<S, T>(T t)
{
return t.GetType() == typeof(S);
}
static bool GetType2<S, T>(T t)
{
return typeof(T) == typeof(S);
}
static bool Is<S, T>(T t)
{
return t is S;
}
Я также пробовал использовать нестандартные типы, и результаты были одинаковыми:
var c1 = new Class1();
var c2 = new Class2();
object oc1 = c1;
object oc2 = c2;
var s1 = new Struct1();
var s2 = new Struct2();
object os1 = s1;
object os2 = s2;
bool b = false;
Stopwatch sw = Stopwatch.StartNew();
for (int i = 0; i < 10000000; i++)
{
b = c1.GetType() == typeof(Class1); // ~60ms
b = c1 is Class1; // ~60ms
b = c2.GetType() == typeof(Class1); // ~60ms
b = c2 is Class1; // ~55ms
b = oc1.GetType() == typeof(Class1); // ~60ms
b = oc1 is Class1; // ~68ms
b = oc2.GetType() == typeof(Class1); // ~60ms
b = oc2 is Class1; // ~68ms
b = s1.GetType() == typeof(Struct1); // ~150ms
b = s1 is Struct1; // ~50ms
b = s2.GetType() == typeof(Struct1); // ~150ms
b = s2 is Struct1; // ~50ms
b = os1.GetType() == typeof(Struct1); // ~60ms
b = os1 is Struct1; // ~64ms
b = os2.GetType() == typeof(Struct1); // ~60ms
b = os2 is Struct1; // ~64ms
b = GetType1<Class1, Class1>(c1); // ~178ms
b = GetType2<Class1, Class1>(c1); // ~98ms
b = Is<Class1, Class1>(c1); // ~78ms
b = GetType1<Class1, Class2>(c2); // ~178ms
b = GetType2<Class1, Class2>(c2); // ~96ms
b = Is<Class1, Class2>(c2); // ~69ms
b = GetType1<Class1, object>(oc1); // ~178ms
b = Is<Class1, object>(oc1); // ~69ms
b = GetType1<Class1, object>(oc2); // ~178ms
b = Is<Class1, object>(oc2); // ~69ms
b = GetType1<Struct1, Struct1>(s1); // ~272ms
b = GetType2<Struct1, Struct1>(s1); // ~140ms
b = Is<Struct1, Struct1>(s1); // ~163ms
b = GetType1<Struct1, Struct2>(s2); // ~272ms
b = GetType2<Struct1, Struct2>(s2); // ~140ms
b = Is<Struct1, Struct2>(s2); // ~163ms
b = GetType1<Struct1, object>(os1); // ~178ms
b = Is<Struct1, object>(os1); // ~64ms
b = GetType1<Struct1, object>(os2); // ~178ms
b = Is<Struct1, object>(os2); // ~64ms
}
sw.Stop();
MessageBox.Show(sw.Elapsed.TotalMilliseconds.ToString());
И виды:
sealed class Class1 { }
sealed class Class2 { }
struct Struct1 { }
struct Struct2 { }
Вывод:
Вызов GetType
на struct
s выполняется медленнее. GetType
определен в object
классе, который не может быть переопределен в подтипах, и поэтому struct
s необходимо поместить в коробку для вызова GetType
.
В экземпляре объекта GetType
быстрее, но очень незначительно.
Для общего типа, если T
равно class
, is
выполняется намного быстрее. Если T
равно struct
, то is
намного быстрее, чем GetType
, но typeof(T)
намного быстрее, чем оба. В случаях, когда T
является class
, typeof(T)
ненадежен, поскольку он отличается от фактического базового типа t.GetType
.
Короче говоря, если у вас есть экземпляр object
, используйте GetType
. Если у вас общий тип class
, используйте is
. Если у вас общий тип struct
, используйте typeof(T)
. Если вы не уверены, является ли универсальный тип ссылочным типом или типом значения, используйте is
. Если вы хотите всегда соответствовать одному стилю (для запечатанных типов), используйте is
..