“ as”和可为空的类型带来的性能惊喜

我只是在修改C＃中有关可空类型的第4章，并添加了有关使用“ as”运算符的部分，该部分允许您编写：

object o = ...;
int? x = o as int?;
if (x.HasValue)
{
    ... // Use x.Value in here
}

我认为这确实很整洁，并且可以使用“ is”后跟强制类型转换来提高C＃1等效项的性能-毕竟，这种方式我们只需要进行一次动态类型检查，然后进行简单的值检查。

但是，情况似乎并非如此。我在下面提供了一个示例测试应用程序，该应用程序基本上将对象数组中的所有整数相加-但该数组包含许多空引用和字符串引用以及装箱的整数。该基准测试可测量您在C＃1中必须使用的代码，这些代码使用“ as”运算符，并且仅用于启动LINQ解决方案。令我惊讶的是，在这种情况下，C＃1代码的速度提高了20倍-甚至LINQ代码（考虑到涉及的迭代器，我希望它也会更慢）击败了“ as”代码。

isinst可为空的类型的.NET实现真的很慢吗？是unbox.any导致问题的其他因素吗？对此还有其他解释吗？目前，感觉就像我将不得不警告不要在性能敏感的情况下使用此功能...

结果：

演员：10000000：121
身份：10000000：2211
LINQ：10000000：2143

码：

using System;
using System.Diagnostics;
using System.Linq;

class Test
{
    const int Size = 30000000;

    static void Main()
    {
        object[] values = new object[Size];
        for (int i = 0; i < Size - 2; i += 3)
        {
            values[i] = null;
            values[i+1] = "";
            values[i+2] = 1;
        }

        FindSumWithCast(values);
        FindSumWithAs(values);
        FindSumWithLinq(values);
    }

    static void FindSumWithCast(object[] values)
    {
        Stopwatch sw = Stopwatch.StartNew();
        int sum = 0;
        foreach (object o in values)
        {
            if (o is int)
            {
                int x = (int) o;
                sum += x;
            }
        }
        sw.Stop();
        Console.WriteLine("Cast: {0} : {1}", sum, 
                          (long) sw.ElapsedMilliseconds);
    }

    static void FindSumWithAs(object[] values)
    {
        Stopwatch sw = Stopwatch.StartNew();
        int sum = 0;
        foreach (object o in values)
        {
            int? x = o as int?;
            if (x.HasValue)
            {
                sum += x.Value;
            }
        }
        sw.Stop();
        Console.WriteLine("As: {0} : {1}", sum, 
                          (long) sw.ElapsedMilliseconds);
    }

    static void FindSumWithLinq(object[] values)
    {
        Stopwatch sw = Stopwatch.StartNew();
        int sum = values.OfType<int>().Sum();
        sw.Stop();
        Console.WriteLine("LINQ: {0} : {1}", sum, 
                          (long) sw.ElapsedMilliseconds);
    }
}

显然，JIT编译器可以为第一种情况生成的机器代码效率更高。一个真正有帮助的规则是，对象只能被取消装箱到与装箱值具有相同类型的变量。这使JIT编译器可以生成非常有效的代码，而无需考虑值转换。

将是运营商的测试很容易，只要检查对象是不是null，而是预期的类型的，但需要一些机器代码指令。转换也很容易，JIT编译器知道值位在对象中的位置并直接使用它们。没有复制或转换发生，所有机器代码都是内联的，只需要十几条指令。当装箱很普遍时，这在.NET 1.0中必须非常有效。

转换为int？需要做更多的工作。装箱整数的值表示形式与的内存布局不兼容Nullable<int>。需要进行转换，并且由于可能的装箱枚举类型不同，因此代码很棘手。JIT编译器生成对名为JIT_Unbox_Nullable的CLR帮助器函数的调用，以完成工作。这是任何值类型的通用函数，其中有许多代码可用于检查类型。并复制该值。由于此代码被锁定在mscorwks.dll中，因此难以估计成本，但是可能会出现数百条机器代码指令。

Linq OfType（）扩展方法还使用is运算符和强制类型转换。但是，这是强制转换为通用类型。JIT编译器会生成对辅助函数JIT_Unbox（）的调用，该函数可以将类型转换为任意值类型。Nullable<int>考虑到需要的工作量较少，我对此没有很好的解释。我怀疑ngen.exe可能会在这里引起麻烦。

在我看来，isinst对于可空类型而言，这真的很慢。在方法上FindSumWithCast我改变了

if (o is int)

至

if (o is int?)

这也大大降低了执行速度。我能看到的IL的唯一区别是

isinst     [mscorlib]System.Int32

被更改为

isinst     valuetype [mscorlib]System.Nullable`1<int32>

最初，这是对Hans Passant出色答案的评论，但由于时间太长，因此我想在此处添加一些内容：

首先，C＃as运算符将发出一条isinstIL指令（运算符也将发出is）。（另一个有趣的指令是castclass，当您执行直接强制转换并且编译器知道不能忽略运行时检查时发出。）

这是做什么的isinst（ECMA 335 Partition III，4.6）：

格式：isinst 类型

typeTok是元数据令牌（一个typeref，typedef或typespec），这表明所期望的类。

如果typeTok是不可为空的值类型或通用参数类型，则将其解释为“盒装” typeTok。

如果typeTok是可为空的类型，Nullable<T>则将其解释为“装箱”T

最重要的是：

如果obj的实际类型（不是验证者跟踪的类型）是可验证者可分配给 typeTok的类型，则isinst成功，并且obj（作为结果）不变地返回，而验证将其跟踪为typeTok。与强制（§1.6）和转换（§3.27）不同，isinst永远不要更改对象的实际类型并保留对象标识（请参阅分区I）。

因此，性能杀手不是isinst这种情况，而是其他杀手unbox.any。从Hans的回答中并不清楚，因为他只看了JITed代码。通常，C＃编译器会在unbox.any之后发出一个after isinst T?（但isinst T如果T是引用类型，则将其省略）。

为什么这样做呢？isinst T?永远不会有明显的效果，即返回a T?。相反，所有这些说明都确保您"boxed T"可以将拆箱T?。为了获得一个实际的T?，我们仍然需要拆箱我们"boxed T"来T?，这就是为什么编译器发出unbox.any后isinst。如果您考虑一下，这是有道理的，因为for的“框格式” T?仅仅是a，"boxed T"并且制作castclass和isinst执行unbox会不一致。

使用标准中的一些信息来备份Hans的发现，结果如下：

（ECMA 335 Partition III，4.33）： unbox.any

当应用于值类型的框式形式时，unbox.any指令将提取obj（类型为O）中包含的值。（等效于unbox后跟ldobj。）当应用于引用类型时，该unbox.any指令与castclasstypeTok 具有相同的效果。

（ECMA 335 Partition III，4.32）： unbox

通常，unbox仅计算盒装对象内部已经存在的值类型的地址。将可空值类型装箱时，这种方法是不可能的。因为在box操作期间将Nullable<T>值转换为boxed Ts，所以实现通常必须Nullable<T>在堆上制造新的对象并计算到新分配的对象的地址。

有趣的是，我传递了关于操作员支持的反馈dynamic，其速度降低了一个数量级Nullable<T>（类似于此早期测试）-我怀疑原因非常相似。

要爱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;
    }
}

这是上面的FindSumWithAsAndHas的结果：

这是FindSumWithCast的结果：

发现：

• 使用as，它首先测试一个对象是否是Int32的实例；它在后台使用isinst Int32（类似于手写代码：if（o is int））。并使用as，也可以无条件地将对象拆箱。调用属性（它仍然是函数）是一个真正的性能杀手，IL_0027

• 使用强制转换，首先测试object是否为int if (o is int); 在引擎盖下使用isinst Int32。如果它是int的实例，则可以安全地将值IL_002D拆箱。

简而言之，这是using as方法的伪代码：

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方法不能说同一件事。

为了使此答案保持最新，值得一提的是，此页面上的大部分讨论现在都与C＃7.1和.NET 4.7一起进行，而后者支持一种苗条的语法，该语法还可以生成最佳的IL代码。

OP的原始示例...

object o = ...;
int? x = o as int?;
if (x.HasValue)
{
    // ...use x.Value in here
}

变得简单...

if (o is int x)
{
    // ...use x in here
}

我发现新语法的一种常见用法是在编写实现（大多数情况下）的.NET 值类型时（即struct在C＃中IEquatable<MyStruct>）。在实现强类型Equals(MyStruct other)方法之后，您现在可以按如下所示正常地将未类型的Equals(Object obj)替代（从继承Object）重定向到它：

public override bool Equals(Object obj) => obj is MyStruct o && Equals(o);

附录：此处分别给出了此答案中上面显示的前两个示例函数的Release构建IL代码。尽管新语法的IL代码确实小了1个字节，但通过进行零次调用（相对于两次调用）并unbox在可能的情况下完全避免该操作，它通常会大获成功。

// static void test1(Object o, ref int y)
// {
//     int? x = o as int?;
//     if (x.HasValue)
//         y = x.Value;
// }

[0] valuetype [mscorlib]Nullable`1<int32> x
        ldarg.0
        isinst [mscorlib]Nullable`1<int32>
        unbox.any [mscorlib]Nullable`1<int32>
        stloc.0
        ldloca.s x
        call instance bool [mscorlib]Nullable`1<int32>::get_HasValue()
        brfalse.s L_001e
        ldarg.1
        ldloca.s x
        call instance !0 [mscorlib]Nullable`1<int32>::get_Value()
        stind.i4
L_001e: ret

// static void test2(Object o, ref int y)
// {
//     if (o is int x)
//         y = x;
// }

[0] int32 x,
[1] object obj2
        ldarg.0
        stloc.1
        ldloc.1
        isinst int32
        ldnull
        cgt.un
        dup
        brtrue.s L_0011
        ldc.i4.0
        br.s L_0017
L_0011: ldloc.1
        unbox.any int32
L_0017: stloc.0
        brfalse.s L_001d
        ldarg.1
        ldloc.0
        stind.i4
L_001d: ret

有关进一步证明我对新C＃7语法性能超过先前可用选项的评论的进一步测试，请参见此处（特别是示例“ D”）。

进一步剖析：

using System;
using System.Diagnostics;

class Program
{
    const int Size = 30000000;

    static void Main(string[] args)
    {
        object[] values = new object[Size];
        for (int i = 0; i < Size - 2; i += 3)
        {
            values[i] = null;
            values[i + 1] = "";
            values[i + 2] = 1;
        }

        FindSumWithIsThenCast(values);

        FindSumWithAsThenHasThenValue(values);
        FindSumWithAsThenHasThenCast(values);

        FindSumWithManualAs(values);
        FindSumWithAsThenManualHasThenValue(values);



        Console.ReadLine();
    }

    static void FindSumWithIsThenCast(object[] values)
    {
        Stopwatch sw = Stopwatch.StartNew();
        int sum = 0;
        foreach (object o in values)
        {
            if (o is int)
            {
                int x = (int)o;
                sum += x;
            }
        }
        sw.Stop();
        Console.WriteLine("Is then Cast: {0} : {1}", sum,
                            (long)sw.ElapsedMilliseconds);
    }

    static void FindSumWithAsThenHasThenValue(object[] values)
    {
        Stopwatch sw = Stopwatch.StartNew();
        int sum = 0;
        foreach (object o in values)
        {
            int? x = o as int?;

            if (x.HasValue)
            {
                sum += x.Value;
            }
        }
        sw.Stop();
        Console.WriteLine("As then Has then Value: {0} : {1}", sum,
                            (long)sw.ElapsedMilliseconds);
    }

    static void FindSumWithAsThenHasThenCast(object[] values)
    {
        Stopwatch sw = Stopwatch.StartNew();
        int sum = 0;
        foreach (object o in values)
        {
            int? x = o as int?;

            if (x.HasValue)
            {
                sum += (int)o;
            }
        }
        sw.Stop();
        Console.WriteLine("As then Has then Cast: {0} : {1}", sum,
                            (long)sw.ElapsedMilliseconds);
    }

    static void FindSumWithManualAs(object[] values)
    {
        Stopwatch sw = Stopwatch.StartNew();
        int sum = 0;
        foreach (object o in values)
        {
            bool hasValue = o is int;
            int x = hasValue ? (int)o : 0;

            if (hasValue)
            {
                sum += x;
            }
        }
        sw.Stop();
        Console.WriteLine("Manual As: {0} : {1}", sum,
                            (long)sw.ElapsedMilliseconds);
    }

    static void FindSumWithAsThenManualHasThenValue(object[] values)
    {
        Stopwatch sw = Stopwatch.StartNew();
        int sum = 0;
        foreach (object o in values)
        {
            int? x = o as int?;

            if (o is int)
            {
                sum += x.Value;
            }
        }
        sw.Stop();
        Console.WriteLine("As then Manual Has then Value: {0} : {1}", sum,
                            (long)sw.ElapsedMilliseconds);
    }

}

输出：

Is then Cast: 10000000 : 303
As then Has then Value: 10000000 : 3524
As then Has then Cast: 10000000 : 3272
Manual As: 10000000 : 395
As then Manual Has then Value: 10000000 : 3282

从这些数字中我们可以得出什么？

• 首先，是-然后铸造方法是显著的速度比为的做法。303和3524
• 其次，.value比强制转换慢一点。3524和3272
• 第三，.HasValue比使用手动has稍慢（即使用is）。3524和3282
• 第四，在模拟方式和真实方式之间进行苹果对苹果的比较（即同时分配模拟的HasValue和转换模拟值都发生），我们可以看到模拟方式仍然比真实方式快得多。395和3524
• 最后，基于第一和第四个结论，有一些错误的 实现^ _ ^

我没有时间尝试，但是您可能想要：

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

如

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

您每次都在创建一个新对象，虽然不能完全解释问题，但可能会有所帮助。

我尝试了确切的类型检查构造

typeof(int) == item.GetType()，其执行速度与item is int版本一样快，并且始终返回数字（强调：即使您Nullable<int>向数组写入了a ，也需要使用typeof(int)）。您还需要null != item在此处进行其他检查。

然而

typeof(int?) == item.GetType()保持快速状态（与相对item is int?），但始终返回false。

在我看来，typeof-construct是使用RuntimeTypeHandle 进行准确类型检查的最快方法。由于这种情况下的确切类型与nullable不匹配，因此我想is/as必须在此进行额外的繁琐工作，以确保它实际上是Nullable类型的实例。

老实说：您is Nullable<xxx> plus HasValue买了什么？没有。您总是可以直接转到基础（值）类型（在这种情况下）。您要么得到值，要么是“否，不是您要查询的类型的实例”。即使您写入(int?)null数组，类型检查也将返回false。

using System;
using System.Diagnostics;
using System.Linq;

class Test
{
    const int Size = 30000000;

    static void Main()
    {
        object[] values = new object[Size];
        for (int i = 0; i < Size - 2; i += 3)
        {
            values[i] = null;
            values[i + 1] = "";
            values[i + 2] = 1;
        }

        FindSumWithCast(values);
        FindSumWithAsAndHas(values);
        FindSumWithAsAndIs(values);


        FindSumWithIsThenAs(values);
        FindSumWithIsThenConvert(values);

        FindSumWithLinq(values);



        Console.ReadLine();
    }

    static void FindSumWithCast(object[] values)
    {
        Stopwatch sw = Stopwatch.StartNew();
        int sum = 0;
        foreach (object o in values)
        {
            if (o is int)
            {
                int x = (int)o;
                sum += x;
            }
        }
        sw.Stop();
        Console.WriteLine("Cast: {0} : {1}", sum,
                          (long)sw.ElapsedMilliseconds);
    }

    static void FindSumWithAsAndHas(object[] values)
    {
        Stopwatch sw = Stopwatch.StartNew();
        int sum = 0;
        foreach (object o in values)
        {
            int? x = o as int?;
            if (x.HasValue)
            {
                sum += x.Value;
            }
        }
        sw.Stop();
        Console.WriteLine("As and Has: {0} : {1}", sum,
                          (long)sw.ElapsedMilliseconds);
    }


    static void FindSumWithAsAndIs(object[] values)
    {
        Stopwatch sw = Stopwatch.StartNew();
        int sum = 0;
        foreach (object o in values)
        {
            int? x = o as int?;
            if (o is int)
            {
                sum += x.Value;
            }
        }
        sw.Stop();
        Console.WriteLine("As and Is: {0} : {1}", sum,
                          (long)sw.ElapsedMilliseconds);
    }







    static void FindSumWithIsThenAs(object[] values)
    {
        // Apple-to-apple comparison with Cast routine above.
        // Using the similar steps in Cast routine above,
        // the AS here cannot be slower than Linq.



        Stopwatch sw = Stopwatch.StartNew();
        int sum = 0;
        foreach (object o in values)
        {

            if (o is int)
            {
                int? x = o as int?;
                sum += x.Value;
            }
        }
        sw.Stop();
        Console.WriteLine("Is then As: {0} : {1}", sum,
                          (long)sw.ElapsedMilliseconds);
    }

    static void FindSumWithIsThenConvert(object[] values)
    {
        Stopwatch sw = Stopwatch.StartNew();
        int sum = 0;
        foreach (object o in values)
        {            
            if (o is int)
            {
                int x = Convert.ToInt32(o);
                sum += x;
            }
        }
        sw.Stop();
        Console.WriteLine("Is then Convert: {0} : {1}", sum,
                          (long)sw.ElapsedMilliseconds);
    }



    static void FindSumWithLinq(object[] values)
    {
        Stopwatch sw = Stopwatch.StartNew();
        int sum = values.OfType<int>().Sum();
        sw.Stop();
        Console.WriteLine("LINQ: {0} : {1}", sum,
                          (long)sw.ElapsedMilliseconds);
    }
}

输出：

Cast: 10000000 : 456
As and Has: 10000000 : 2103
As and Is: 10000000 : 2029
Is then As: 10000000 : 1376
Is then Convert: 10000000 : 566
LINQ: 10000000 : 1811

[编辑：2010-06-19]

注意：先前的测试是在VS内部进行的，使用VS2009，Core i7（公司开发机器）进行配置调试。

以下操作是在我的计算机上使用VS2010在Core 2 Duo上完成的

Inside VS, Configuration: Debug

Cast: 10000000 : 309
As and Has: 10000000 : 3322
As and Is: 10000000 : 3249
Is then As: 10000000 : 1926
Is then Convert: 10000000 : 410
LINQ: 10000000 : 2018




Outside VS, Configuration: Debug

Cast: 10000000 : 303
As and Has: 10000000 : 3314
As and Is: 10000000 : 3230
Is then As: 10000000 : 1942
Is then Convert: 10000000 : 418
LINQ: 10000000 : 1944




Inside VS, Configuration: Release

Cast: 10000000 : 305
As and Has: 10000000 : 3327
As and Is: 10000000 : 3265
Is then As: 10000000 : 1942
Is then Convert: 10000000 : 414
LINQ: 10000000 : 1932




Outside VS, Configuration: Release

Cast: 10000000 : 301
As and Has: 10000000 : 3274
As and Is: 10000000 : 3240
Is then As: 10000000 : 1904
Is then Convert: 10000000 : 414
LINQ: 10000000 : 1936