有趣的是，对于Nullable<T>(类似于早期的测试)，我通过dynamic传递了关于操作符支持的反馈——我怀疑是出于非常相似的原因。

爱上Nullable<T>。另一个有趣的是，即使JIT发现(并删除)非空结构的null，它也会对Nullable<T>使用它:

using System;
using System.Diagnostics;
static class Program {
    static void Main() { 
        // JIT
        TestUnrestricted<int>(1,5);
        TestUnrestricted<string>("abc",5);
        TestUnrestricted<int?>(1,5);
        TestNullable<int>(1, 5);

        const int LOOP = 100000000;
        Console.WriteLine(TestUnrestricted<int>(1, LOOP));
        Console.WriteLine(TestUnrestricted<string>("abc", LOOP));
        Console.WriteLine(TestUnrestricted<int?>(1, LOOP));
        Console.WriteLine(TestNullable<int>(1, LOOP));

    }
    static long TestUnrestricted<T>(T x, int loop) {
        Stopwatch watch = Stopwatch.StartNew();
        int count = 0;
        for (int i = 0; i < loop; i++) {
            if (x != null) count++;
        }
        watch.Stop();
        return watch.ElapsedMilliseconds;
    }
    static long TestNullable<T>(T? x, int loop) where T : struct {
        Stopwatch watch = Stopwatch.StartNew();
        int count = 0;
        for (int i = 0; i < loop; i++) {
            if (x != null) count++;
        }
        watch.Stop();
        return watch.ElapsedMilliseconds;
    }
}

我没有时间尝试，但你可能想要:

foreach (object o in values)
        {
            int? x = o as int?;

as

int? x;
foreach (object o in values)
        {
            x = o as int?;

您每次都在创建一个新对象，这不能完全解释问题，但可能有助于解决问题。

这是上面FindSumWithAsAndHas的结果:

这是FindSumWithCast的结果:

发现:

使用as，它首先测试对象是否是Int32的实例;实际上，它使用isinst Int32(这类似于手写的代码:if (o is int))。使用as，它也无条件地打开对象。调用属性IL_0027是真正的性能杀手(本质上它仍然是一个函数) 使用强制转换，首先测试object是否为int型if (o is int);这是在使用isinst Int32。如果它是int的实例，那么可以安全地将值IL_002D解箱

简单地说，这是使用方法的伪代码:

int? x;

(x.HasValue, x.Value) = (o isinst Int32, o unbox Int32)

if (x.HasValue)
    sum += x.Value;    

这是使用强制转换方法的伪代码:

if (o isinst Int32)
    sum += (o unbox Int32)

所以强制转换((int)a[i]，语法看起来像强制转换，但实际上是解装箱，强制转换和解装箱的语法是一样的，下次我会用正确的术语来研究)方法真的更快，你只需要在对象是int类型时解装箱。同样的事情不能说使用as方法。

显然，JIT编译器为第一种情况生成的机器代码要高效得多。一个真正有用的规则是，一个对象只能被解箱为与被装箱值具有相同类型的变量。这允许JIT编译器生成非常高效的代码，不需要考虑值转换。

is操作符测试很简单，只需检查对象是否为空并且是预期的类型，只需要一些机器代码指令。强制转换也很容易，JIT编译器知道值位在对象中的位置，并直接使用它们。没有复制或转换，所有的机器代码都是内联的，只需要大约十几个指令。这需要在。net 1.0中非常有效，当时装箱很常见。

Casting to int? takes a lot more work. The value representation of the boxed integer is not compatible with the memory layout of Nullable<int>. A conversion is required and the code is tricky due to possible boxed enum types. The JIT compiler generates a call to a CLR helper function named JIT_Unbox_Nullable to get the job done. This is a general purpose function for any value type, lots of code there to check types. And the value is copied. Hard to estimate the cost since this code is locked up inside mscorwks.dll, but hundreds of machine code instructions is likely.

Linq的OfType()扩展方法也使用is操作符和强制转换。然而，这是一个泛型类型的强制转换。JIT编译器生成对辅助函数JIT_Unbox()的调用，该函数可以执行到任意值类型的强制转换。我没有很好的解释为什么它像强制转换为Nullable<int>一样慢，因为应该需要更少的工作。我怀疑ngen.exe可能会在这里造成麻烦。

这最初是对汉斯·帕桑的精彩回答的评论，但它太长了，所以我想在这里添加一些内容:

首先，c#的as操作符将发出一条isinst IL指令(is操作符也是如此)。(另一个有趣的指令是castclass，在执行直接强制转换时发出，编译器知道不能省略运行时检查。)

以下是isinst的功能(ECMA 335 Partition III, 4.6):

格式:isinst typeTok typeTok是一个元数据标记(typeref, typedef或typespec)，指示所需的类。 如果typeTok是非空值类型或泛型参数类型，则将其解释为“盒装”typeTok。 如果typeTok是一个可空类型，nullable <T>，它被解释为“盒装”T

最重要的是:

如果obj的实际类型(不是验证者跟踪的类型)是valider -assignable-to typeTok类型，那么isinst成功，obj(作为结果)不变地返回，而验证者跟踪它的类型为typeTok。与强制(§1.6)和转换(§3.27)不同，isinst永远不会改变对象的实际类型，并保持对象的同一性(见分区I)。

因此，在本例中，性能杀手不是isinst，而是额外的unbox.any。从汉斯的回答来看，这一点并不清楚，因为他只看了JITed代码。一般来说，c#编译器会发出一个解框。isinst T后面有什么?(但当T是引用类型时，如果执行isinst T将省略它)。

为什么会这样?isinst T ?从来没有明显的效果，即你得到了一个T?相反，所有这些说明都确保您有一个“盒装T”，可以打开盒装T?得到一个真正的T?那么，我们还需要把我们的“盒装T”打开吗?，这就是为什么编译器会发出一个解框。任何在isinst之后。如果你仔细想想，这是有道理的，因为T的“盒子格式”?只是一个“被装箱的T”，让castclass和isinst执行unbox将是不一致的。

用标准中的一些信息来支持Hans的发现，下面是:

(ECMA 335 Partition III, 4.33): unbox.any

当应用于值类型的盒装形式时，解盒装。任何指令提取obj中包含的值(类型为O)。(相当于unbox后跟ldobj。)当应用于引用类型时，解框。任何指令都具有与castclass typeTok相同的效果。

(ECMA 335 Partition III, 4.32):开箱

通常，unbox只是计算已装箱对象中已经存在的值类型的地址。当解装箱可空值类型时，这种方法是不可能的。由于在box操作期间Nullable<T>值被转换为盒装的T，因此实现通常必须在堆上生成一个新的Nullable<T>，并计算新分配对象的地址。

我尝试了准确的类型检查结构

typeof(int) == item. gettype()，它的执行速度与项目为int版本一样快，并且总是返回数字(强调:即使你向数组写入了Nullable<int>，你也需要使用typeof(int))。这里还需要一个额外的null !=项检查。

然而

typeof(int?) == item. gettype()保持较快(相对于item is int?)，但总是返回false。

在我看来，typef -construct是精确类型检查的最快方法，因为它使用了RuntimeTypeHandle。由于这种情况下的确切类型与nullable不匹配，我的猜测是，is/as必须在这里做额外的繁重工作，以确保它实际上是nullable类型的实例。

老实说:你的is Nullable<xxx> + HasValue给你买了什么?没什么。您总是可以直接转到基础(值)类型(在本例中)。你要么得到值，要么“不，不是你要的类型的实例”。即使您将(int?)null写入数组，类型检查也将返回false。