我有一个需要快速运行的程序。在其中一个内部循环中，我需要测试对象的类型，以查看它是否继承自某个接口。
一种方法是使用CLR内置的类型检查功能。最优雅的方法可能是使用 'is' 关键字：
if (obj is ISpecialType)
另一种方法是给基类自己定义一个虚拟的GetType()函数，它返回预定义的枚举值（在我的情况下，实际上只需要一个布尔值）。 这种方法会很快，但不够优雅。
我听说有一个针对'is'关键字的IL指令，但这并不意味着在转换成本地汇编时它执行得很快。 有人能分享一些关于'is'与其他方法性能的见解吗？
更新：感谢所有明智答案！答案中有几个有用的要点：Andrew提到的'is'自动执行强制类型转换是必要的，而Binary Worrier和Ian收集的性能数据也非常有用。 如果其中一个答案被编辑以包含所有这些信息将会很好。
如果你在使用 is 后转换为已检查过的类型，那么会影响性能。实际上，is 会将对象强制转换为你正在检查的类型，因此任何后续的转换都是多余的。
如果你仍然要进行转换，以下是更好的方法：
ISpecialType t = obj as ISpecialType;
if (t != null)
{
// use t here
}
asж“ҚдҪңе’Ңisеҹәжң¬дёҠжү§иЎҢзӣёеҗҢзҡ„ж“ҚдҪңпјҲеҚізұ»еһӢжЈҖжҹҘпјүпјҢе”ҜдёҖзҡ„еҢәеҲ«жҳҜе®ғиҝ”еӣһnullиҖҢдёҚжҳҜfalseгҖӮ - Konrad Rudolphif (obj is ISpecialType t) { t.DoThing(); }。请注意，这是一种编程语言中的语法结构。 - Licht我同意Ian的观点，你可能不想这样做。
不过，只是让你知道，在10,000,000次迭代中，两者之间的差别很小。
个人而言，我不会用这种方式解决这个问题，但如果必须选择一种方法，我会选择内置的IS检查，因为性能差异不值得考虑编码开销。
我的基类和派生类
class MyBaseClass
{
public enum ClassTypeEnum { A, B }
public ClassTypeEnum ClassType { get; protected set; }
}
class MyClassA : MyBaseClass
{
public MyClassA()
{
ClassType = MyBaseClass.ClassTypeEnum.A;
}
}
class MyClassB : MyBaseClass
{
public MyClassB()
{
ClassType = MyBaseClass.ClassTypeEnum.B;
}
}
JubJub：根据要求提供更多测试信息。
我从控制台应用程序（调试版本）中运行了两个测试，每个测试看起来像以下内容：
static void IsTest()
{
DateTime start = DateTime.Now;
for (int i = 0; i < 10000000; i++)
{
MyBaseClass a;
if (i % 2 == 0)
a = new MyClassA();
else
a = new MyClassB();
bool b = a is MyClassB;
}
DateTime end = DateTime.Now;
Console.WriteLine("Is test {0} miliseconds", (end - start).TotalMilliseconds);
}
在发布模式下运行，我和Ian一样得到了60-70毫秒的差异。
进一步更新-2012年10月25日
离开几年后，我注意到关于这个问题的一些事情，编译器可以选择在发布模式下省略bool b = a is MyClassB，因为b没有在任何地方使用。
此代码...
public static void IsTest()
{
long total = 0;
var a = new MyClassA();
var b = new MyClassB();
var sw = new Stopwatch();
sw.Start();
for (int i = 0; i < 10000000; i++)
{
MyBaseClass baseRef;
if (i % 2 == 0)
baseRef = a;//new MyClassA();
else
baseRef = b;// new MyClassB();
//bool bo = baseRef is MyClassB;
bool bo = baseRef.ClassType == MyBaseClass.ClassTypeEnum.B;
if (bo) total += 1;
}
sw.Stop();
Console.WriteLine("Is test {0} miliseconds {1}", sw.ElapsedMilliseconds, total);
}
这段代码一直显示is检查大约需要57毫秒，而枚举比较则只需要29毫秒。
注意：我仍然更喜欢使用is检查，因为差异太小了，不值得关心。
好的，我刚刚与某人聊天并决定更多地测试这个内容。据我所知，与测试自己的成员或函数以存储类型信息相比，as和is性能都非常好。
我使用了Stopwatch，但我刚学会它可能不是最可靠的方法，所以我还尝试了UtcNow。后来，我也尝试了处理器时间方法，这似乎类似于UtcNow，包括不可预测的创建时间。我还尝试使基类非抽象且没有虚拟函数，但似乎没有显著影响。
我在一台带有16GB RAM的Quad Q6600上运行了50百万次迭代，即使这样，数字仍然在+/- 50或如此毫秒之间反弹，因此我不会从小差异中读取太多内容。
有趣的是看到x64创建更快，但执行as/is却比x86慢。
x64 Release Mode:
Stopwatch:
As: 561ms
Is: 597ms
Base property: 539ms
Base field: 555ms
Base RO field: 552ms
Virtual GetEnumType() test: 556ms
Virtual IsB() test: 588ms
创建时间 : 10416ms
UtcNow:
As: 499ms
Is: 532ms
Base property: 479ms
Base field: 502ms
Base RO field: 491ms
Virtual GetEnumType(): 502ms
Virtual bool IsB(): 522ms
创建时间 : 285ms (使用UtcNow时这个数字似乎不可靠。我也得到了109ms和806ms。)
x86 Release Mode:
Stopwatch:
As: 391ms
Is: 423ms
Base property: 369ms
Base field: 321ms
Base RO field: 339ms
Virtual GetEnumType() test: 361ms
Virtual IsB() test: 365ms
创建时间 : 14106ms
UtcNow:
As: 348ms
Is: 375ms
Base property: 329ms
Base field: 286ms
Base RO field: 309ms
Virtual GetEnumType(): 321ms
Virtual bool IsB(): 332ms
创建时间 : 544ms (使用UtcNow时这个数字似乎不可靠。)
这是大部分代码：
static readonly int iterations = 50000000;
void IsTest()
{
Process.GetCurrentProcess().ProcessorAffinity = (IntPtr)1;
MyBaseClass[] bases = new MyBaseClass[iterations];
bool[] results1 = new bool[iterations];
Stopwatch createTime = new Stopwatch();
createTime.Start();
DateTime createStart = DateTime.UtcNow;
for (int i = 0; i < iterations; i++)
{
if (i % 2 == 0) bases[i] = new MyClassA();
else bases[i] = new MyClassB();
}
DateTime createStop = DateTime.UtcNow;
createTime.Stop();
Stopwatch isTimer = new Stopwatch();
isTimer.Start();
DateTime isStart = DateTime.UtcNow;
for (int i = 0; i < iterations; i++)
{
results1[i] = bases[i] is MyClassB;
}
DateTime isStop = DateTime.UtcNow;
isTimer.Stop();
CheckResults(ref results1);
Stopwatch asTimer = new Stopwatch();
asTimer.Start();
DateTime asStart = DateTime.UtcNow;
for (int i = 0; i < iterations; i++)
{
results1[i] = bases[i] as MyClassB != null;
}
DateTime asStop = DateTime.UtcNow;
asTimer.Stop();
CheckResults(ref results1);
Stopwatch baseMemberTime = new Stopwatch();
baseMemberTime.Start();
DateTime baseStart = DateTime.UtcNow;
for (int i = 0; i < iterations; i++)
{
results1[i] = bases[i].ClassType == MyBaseClass.ClassTypeEnum.B;
}
DateTime baseStop = DateTime.UtcNow;
baseMemberTime.Stop();
CheckResults(ref results1);
Stopwatch baseFieldTime = new Stopwatch();
baseFieldTime.Start();
DateTime baseFieldStart = DateTime.UtcNow;
for (int i = 0; i < iterations; i++)
{
results1[i] = bases[i].ClassTypeField == MyBaseClass.ClassTypeEnum.B;
}
DateTime baseFieldStop = DateTime.UtcNow;
baseFieldTime.Stop();
CheckResults(ref results1);
Stopwatch baseROFieldTime = new Stopwatch();
baseROFieldTime.Start();
DateTime baseROFieldStart = DateTime.UtcNow;
for (int i = 0; i < iterations; i++)
{
results1[i] = bases[i].ClassTypeField == MyBaseClass.ClassTypeEnum.B;
}
DateTime baseROFieldStop = DateTime.UtcNow;
baseROFieldTime.Stop();
CheckResults(ref results1);
Stopwatch virtMethTime = new Stopwatch();
virtMethTime.Start();
DateTime virtStart = DateTime.UtcNow;
for (int i = 0; i < iterations; i++)
{
results1[i] = bases[i].GetClassType() == MyBaseClass.ClassTypeEnum.B;
}
DateTime virtStop = DateTime.UtcNow;
virtMethTime.Stop();
CheckResults(ref results1);
Stopwatch virtMethBoolTime = new Stopwatch();
virtMethBoolTime.Start();
DateTime virtBoolStart = DateTime.UtcNow;
for (int i = 0; i < iterations; i++)
{
results1[i] = bases[i].IsB();
}
DateTime virtBoolStop = DateTime.UtcNow;
virtMethBoolTime.Stop();
CheckResults(ref results1);
asdf.Text +=
"Stopwatch: " + Environment.NewLine
+ "As: " + asTimer.ElapsedMilliseconds + "ms" + Environment.NewLine
+"Is: " + isTimer.ElapsedMilliseconds + "ms" + Environment.NewLine
+ "Base property: " + baseMemberTime.ElapsedMilliseconds + "ms" + Environment.NewLine + "Base field: " + baseFieldTime.ElapsedMilliseconds + "ms" + Environment.NewLine + "Base RO field: " + baseROFieldTime.ElapsedMilliseconds + "ms" + Environment.NewLine + "Virtual GetEnumType() test: " + virtMethTime.ElapsedMilliseconds + "ms" + Environment.NewLine + "Virtual IsB() test: " + virtMethBoolTime.ElapsedMilliseconds + "ms" + Environment.NewLine + "Create Time : " + createTime.ElapsedMilliseconds + "ms" + Environment.NewLine + Environment.NewLine+"UtcNow: " + Environment.NewLine + "As: " + (asStop - asStart).Milliseconds + "ms" + Environment.NewLine + "Is: " + (isStop - isStart).Milliseconds + "ms" + Environment.NewLine + "Base property: " + (baseStop - baseStart).Milliseconds + "ms" + Environment.NewLine + "Base field: " + (baseFieldStop - baseFieldStart).Milliseconds + "ms" + Environment.NewLine + "Base RO field: " + (baseROFieldStop - baseROFieldStart).Milliseconds + "ms" + Environment.NewLine + "Virtual GetEnumType(): " + (virtStop - virtStart).Milliseconds + "ms" + Environment.NewLine + "Virtual bool IsB(): " + (virtBoolStop - virtBoolStart).Milliseconds + "ms" + Environment.NewLine + "Create Time : " + (createStop-createStart).Milliseconds + "ms" + Environment.NewLine;
}
}
abstract class MyBaseClass
{
public enum ClassTypeEnum { A, B }
public ClassTypeEnum ClassType { get; protected set; }
public ClassTypeEnum ClassTypeField;
public readonly ClassTypeEnum ClassTypeReadonlyField;
public abstract ClassTypeEnum GetClassType();
public abstract bool IsB();
protected MyBaseClass(ClassTypeEnum kind)
{
ClassTypeReadonlyField = kind;
}
}
class MyClassA : MyBaseClass
{
public override bool IsB() { return false; }
public override ClassTypeEnum GetClassType() { return ClassTypeEnum.A; }
public MyClassA() : base(MyBaseClass.ClassTypeEnum.A)
{
ClassType = MyBaseClass.ClassTypeEnum.A;
ClassTypeField = MyBaseClass.ClassTypeEnum.A;
}
}
class MyClassB : MyBaseClass
{
public override bool IsB() { return true; }
public override ClassTypeEnum GetClassType() { return ClassTypeEnum.B; }
public MyClassB() : base(MyBaseClass.ClassTypeEnum.B)
{
ClassType = MyBaseClass.ClassTypeEnum.B;
ClassTypeField = MyBaseClass.ClassTypeEnum.B;
}
}
Andrew Hare提到的关于在执行is检查和转换时性能损失的观点是正确的，但自从C# 7.0以后，我们可以使用模式匹配来进行is检查，以避免后续的额外转换：
if (obj is ISpecialType st)
{
//st is in scope here and can be used
}
此外，如果您需要在多个类型之间进行检查，C# 7.0模式匹配结构现在允许您在类型上执行switch操作：
public static double ComputeAreaModernSwitch(object shape)
{
switch (shape)
{
case Square s:
return s.Side * s.Side;
case Circle c:
return c.Radius * c.Radius * Math.PI;
case Rectangle r:
return r.Height * r.Length;
default:
throw new ArgumentException(
message: "shape is not a recognized shape",
paramName: nameof(shape));
}
}
您可以在此处的文档中了解有关C#模式匹配的更多信息。
OneOf<T...>这样的库，但它们存在重大缺陷）。 - Dai我进行了两种类型比较的性能比较：
结果是：使用 "is" 大约快10倍！！！
输出:
类型比较用时: 00:00:00.456
"is" 比较用时: 00:00:00.042
我的代码:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
namespace ConsoleApplication3
{
class MyClass
{
double foo = 1.23;
}
class Program
{
static void Main(string[] args)
{
MyClass myobj = new MyClass();
int n = 10000000;
Stopwatch sw = Stopwatch.StartNew();
for (int i = 0; i < n; i++)
{
bool b = myobj.GetType() == typeof(MyClass);
}
sw.Stop();
Console.WriteLine("Time for Type-Comparison: " + GetElapsedString(sw));
sw = Stopwatch.StartNew();
for (int i = 0; i < n; i++)
{
bool b = myobj is MyClass;
}
sw.Stop();
Console.WriteLine("Time for Is-Comparison: " + GetElapsedString(sw));
}
public static string GetElapsedString(Stopwatch sw)
{
TimeSpan ts = sw.Elapsed;
return String.Format("{0:00}:{1:00}:{2:00}.{3:000}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds);
}
}
}
BenchmarkDotNet 的工具，而不是自己编写代码，因为你很可能会被预热效应等问题所困扰。 - Zastaiis X比GetType() == typeof(X)慢得多。参考代码请查看https://gist.github.com/Zastai/1fbaa1e5f290ee46999361adbca6424d - Zastai安德鲁说得对。实际上，通过代码分析，Visual Studio会将此转换视为不必要的。
一个想法（在不知道你在做什么的情况下有点靠感觉），但我一直被建议避免像这样进行检查，而是拥有另一个类。所以，不要进行某些检查，并根据类型执行不同的操作，而是使类知道如何处理自己...
例如，Obj可以是ISpecialType或IType；
它们都定义了DoStuff()方法。对于IType，它可以只返回或执行自定义操作，而对于ISpecialType，则可以执行其他操作。
这样就完全消除了任何转换，使代码更加清晰易于维护，且该类知道如何执行其自身任务。
我一直被建议避免像这样进行检查，而是使用另一个类。因此，不要进行某些检查并根据类型执行不同的操作，而是使类知道如何处理自己...
例如，Obj可以是ISpecialType或IType;
它们都定义了DoStuff()方法。对于IType，它可以只返回或执行自定义操作，而对于ISpecialType，则可以执行其他操作。
这样完全消除了任何强制转换，使代码更清晰、更易于维护，并且类知道如何执行自己的任务。