在这种情况下，C# 泛型是否会阻止结构的自动装箱？

Question

通常，将结构 S 视为接口 I 将触发结构的自动装箱，如果经常这样做可能会对性能产生影响。但是，如果我编写一个带有类型参数T : I 的泛型方法并使用S 调用它，那么编译器会省略装箱，因为它知道S 的类型并且不必使用接口？

这段代码说明了我的观点：

interface I{
    void foo();
}

struct S : I {
    public void foo() { /* do something */ }
}

class Y {

    void doFoo(I i){
        i.foo();
    }
    void doFooGeneric<T>(T t) where T : I {
        t.foo(); // <--- Will an S be boxed here??
    }

    public static void Main(string[] args){
        S x;
        doFoo(x); // x is boxed
        doFooGeneric(x); // x is not boxed, at least not here, right?
    }

}

doFoo 方法在I 类型的对象上调用foo()，所以一旦我们用S 调用它，S 就会被装箱。 doFooGeneric 方法做同样的事情。然而，一旦我们用S 调用它，就不需要自动装箱，因为运行时知道如何在S 上调用foo()。但这会完成吗？或者运行时会盲目地将S 绑定到I 以调用接口方法？

Answer 1

void doFooGeneric<T>(T t) where T : I {
    t.foo(); // <--- Will an S be boxed here??
}

那里可以避免拳击！

结构类型S 是密封的。对于上面的方法doFooGeneric 的类型参数T 的值类型版本，C# 编译器会提供直接调用相关结构成员的代码，无需装箱。

这很酷。

有关一些技术细节，请参阅 Sameer 的回答。

---

好的，所以我想出了一个例子。如果有人有更好的例子，我会对这些例子感兴趣：

using System;
using System.Collections.Generic;

namespace AvoidBoxing
{
  static class Program
  {
    static void Main()
    {
      var myStruct = new List<int> { 10, 20, 30, }.GetEnumerator();
      myStruct.MoveNext(); // moves to '10' in list

      //
      // UNCOMMENT ONLY *ONE* OF THESE CALLS:
      //

      //UseMyStruct(ref myStruct);
      //UseMyStructAndBox(ref myStruct);

      Console.WriteLine("After call, current is now: " + myStruct.Current); // 10 or 20?
    }

    static void UseMyStruct<T>(ref T myStruct) where T : IEnumerator<int>
    {
      myStruct.MoveNext();
    }

    static void UseMyStructAndBox<T>(ref T myStruct)
    {
      ((IEnumerator<int>)myStruct).MoveNext();
    }
  }
}

这里myStruct 的类型是一个可变值类型，它保存对List<> 的引用，并且还保存“计数器”，它记住我们到目前为止已经达到的List<> 中的索引。

我必须使用ref，否则当传递给任一方法时，值类型将按值复制！

当我取消注释对UseMyStruct 的调用（仅）时，此方法会将值类型内的“计数器”向前移动一个位置。如果它在值类型的盒装副本中这样做，我们将不会在结构的原始实例中看到它。

要了解拳击的不同之处，请尝试拨打UseMyStructAndBox（再次评论UseMyStruct）。它在演员表处创建一个盒子，MoveNext 出现在副本上。所以输出不一样！

---

对于那些对ref 不满意（或对此感到困惑）的人，只需在方法中写出Current。然后我们可以摆脱ref。示例：

static void F<T>(T t) where T : IEnumerator<int>
{
  t.MoveNext(); // OK, not boxed
  Console.WriteLine(t.Current);
}

static void G<T>(T t) where T : IEnumerator<int>
{
  ((IEnumerator<int>)t).MoveNext(); // We said "Box!", it will box; 'Move' happens to a copy
  Console.WriteLine(t.Current);
}

Answer 2

因为Constrained Opcodes在第二种情况下发挥作用，将避免拳击。