我知道这个关键字的功能，但我想知道它在更低层次上是如何工作的。
哪个更快？它们总是产生相同的结果吗？如果是，为什么有两种不同的方法？
// Is there an overhead? An internal try catch?
Class123 obj = someobject as Class123;
if (Class123 != null)
{
//OK
}
或者
Class123 obj = null;
if (someobject is Class123)
{
obj = (Class123)someobject;
}
as运算符类似于转换操作。但是，如果转换不可能，as将返回null而不是引发异常。考虑以下表达式：
expression as type
它与以下表达式等价，只是该表达式仅被评估一次。
expression is type ? (type)expression : (type)null
第一个变量（作为操作数）...
string str1 = strAsObject as string;
if (str1 != null)
{
this.blabla(str1);
}
...编译成以下IL代码：
L_0009: ldloc.1
L_000a: isinst string
L_000f: stloc.2
L_0010: ldloc.2
L_0011: ldnull
L_0012: ceq
L_0014: stloc.s CS$4$0000
L_0016: ldloc.s CS$4$0000
L_0018: brtrue.s L_0024
L_001a: nop
L_001b: ldarg.0
L_001c: ldloc.2
L_001d: call instance void TestWinFormsApplication001.Form1::blabla(string)
L_0022: nop
L_0023: nop
...和第二种变体（是操作数+转换）...
if (strAsObject is string)
{
string str2 = (string) strAsObject;
this.blabla(str2);
}
...编译成以下IL代码：
L_0024: ldloc.1
L_0025: isinst string
L_002a: ldnull
L_002b: cgt.un
L_002d: ldc.i4.0
L_002e: ceq
L_0030: stloc.s CS$4$0000
L_0032: ldloc.s CS$4$0000
L_0034: brtrue.s L_0047
L_0036: nop
L_0037: ldloc.1
L_0038: castclass string
L_003d: stloc.3
L_003e: ldarg.0
L_003f: ldloc.3
L_0040: call instance void TestWinFormsApplication001.Form1::blabla(string)
L_0045: nop
L_0046: nop
... 所以你可以看到唯一的区别是第L_0038行额外的castclass转换代码。
as 关键字时，没有内部的try-catch发生。据我所知，这个功能是内置在编译器/CLR中的，因此类型检查是隐式和自动化的。
简单规则：
当您始终期望对象具有已知类型（因此如果不小心使用了错误类型，将收到一个有用的错误提示）时，请使用直接转换。而使用 as 关键字时，则表示对象总是属于已知类型。
存在 as 关键字的原因纯粹是为了程序员方便（尽管您正确地指出了try-catch会更慢）。您可以像下面这样手动实现它：
var castObj = (obj is NewType) ? (NewType)obj : null;
这凸显了关键字“as”主要是为了简洁而存在的事实。
现在，两者之间的性能差异很可能是微不足道的。由于类型检查，“as”关键字可能略慢一些，但这不太可能影响到绝大多数情况下的代码。就像经常说的那样，过早地优化永远不是明智的做法。如果你真的想要进行基准测试，但我建议只使用更方便/适合您情况的方法，不需要担心性能问题（或者如果您确实必须担心性能问题，请稍后处理）。
为了澄清一些事情：
类型转换应该在您确定对象是要转换的类型时进行。它可以为空（在这种情况下，将返回null，除非您要转换为值类型）。
当您不确定时，可以使用“as”运算符。当对象无法转换或对象为空时，将返回null。
“as”运算符被翻译为专用的IL语句（isinst），而类型转换被翻译为castclass IL语句，因此它内置于运行时。编译器只需发出正确的IL语句。
这个问题已经得到了很好的回答，但是目前缺少硬性数据。
Over 100000000 iterations
AS : Failure 00:00:00.9282403
Cast : Failure 00:00:00.9868966
AS : Success 00:00:00.9350227
Cast : Success 00:00:01.1382759
Over 100000000 iterations
Catch : Failure 05.05:00:00 // approximately, because I didn't hang around
Catch : Success 00:00:01.4000952
class Program
{
const int ITERATION_COUNT = 100000000;
private static UInt64 stringCount = 0;
private static UInt64 objectCount = 0;
static void Main(string[] args)
{
Console.WriteLine("Over {0} iterations ", ITERATION_COUNT);
string s = "Hello";
object o = new Int32();
RunTest("AS : Failure {0}", TestAs, o);
RunTest("Cast : Failure {0}", TestIs_And_Cast, o);
RunTest("AS : Success {0}", TestAs, s);
RunTest("Cast : Success {0}", TestIs_And_Cast, s);
Console.WriteLine("Press any key to stop");
Console.ReadKey();
}
private static void RunTest(string testDescription, Action<object> testToRun, object arg)
{
Stopwatch sw = new Stopwatch();
sw.Start();
for (int i = 0; i < ITERATION_COUNT; i++)
testToRun(arg);
sw.Stop();
Console.WriteLine(testDescription, sw.Elapsed);
}
static void TestAs(object obj)
{
string s = obj as string;
if (s != null)
stringCount++;
else
objectCount++;
}
static void TestIs_And_Cast(object obj)
{
string s = null;
if (obj is string)
{
s = (string)obj;
stringCount++;
}
else
objectCount++;
}
}
使用“as”可能更快，因为只需要检查类型一次，而“is + cast”需要检查类型两次。