C#中的in参数与性能分析详解

前言

in 修饰符也是从 c# 7.2 开始引入的，它与我们上一篇中讨论的 《c# 中的只读结构体（readonly struct）》1 是紧密相关的。

in 修饰符

in 修饰符通过引用传递参数。 它让形参成为实参的别名，即对形参执行的任何操作都是对实参执行的。 它类似于 ref 或 out 关键字，不同之处在于 in 参数无法通过调用的方法进行修改。

• ref 修饰符，指定参数由引用传递，可以由调用方法读取或写入。
• out 修饰符，指定参数由引用传递，必须由调用方法写入。
• in 修饰符，指定参数由引用传递，可以由调用方法读取，但不可以写入。
  

举个简单的例子：

struct product
{
 public int productid { get; set; }
 public string productname { get; set; }
}

public static void modify(in product product)
{
 //product = new product();   // 错误 cs8331 无法分配到 变量 'in product'，因为它是只读变量
 //product.productname = "测试商品"; // 错误 cs8332 不能分配到 变量 'in product' 的成员，因为它是只读变量
 console.writeline($"id: {product.productid}, name: {product.productname}"); // ok
}

引入 in 参数的原因

我们知道，结构体实例的内存在栈（stack）上进行分配，所占用的内存随声明它的类型或方法一起回收，所以通常在内存分配上它是比引用类型占有优势的。2

但是对于有些很大（比如有很多字段或属性）的结构体，将其作为方法参数，在紧凑的循环或关键代码路径中调用方法时，复制这些结构的成本就会很高。当所调用的方法不修改该参数的状态，使用新的修饰符 in 声明参数以指定此参数可以按引用安全传递，可以避免（可能产生的）高昂的复制成本，从而提高代码运行的性能。

in 参数对性能的提升

为了测试 in 修饰符对性能的提升，我定义了两个较大的结构体，一个是可变的结构体 normalstruct，一个是只读的结构体 readonlystruct，都定义了 30 个属性，然后定义三个测试方法：

• donormalloop 方法，参数不加修饰符，传入一般结构体，这是以前比较常见的做法。
• donormalloopbyin 方法，参数加 in 修饰符，传入一般结构体。
• doreadonlyloopbyin 方法，参数加 in 修饰符，传入只读结构体。
  

代码如下所示：

public struct normalstruct
{
 public decimal number1 { get; set; }
 public decimal number2 { get; set; }
 //...
 public decimal number30 { get; set; }
}

public readonly struct readonlystruct
{
 public readonly decimal number1 { get; }
 public readonly decimal number2 { get; }
 //...
 public readonly decimal number30 { get; }
}

public class benchmarkclass
{
 const int loops = 50000000;
 normalstruct normalinstance = new normalstruct();
 readonlystruct readonlyinstance = new readonlystruct();

 [benchmark(baseline = true)]
 public decimal donormalloop()
 {
  decimal result = 0m;
  for (int i = 0; i < loops; i++)
  {
   result = compute(normalinstance);
  }
  return result;
 }

 [benchmark]
 public decimal donormalloopbyin()
 {
  decimal result = 0m;
  for (int i = 0; i < loops; i++)
  {
   result = computein(in normalinstance);
  }
  return result;
 }

 [benchmark]
 public decimal doreadonlyloopbyin()
 {
  decimal result = 0m;
  for (int i = 0; i < loops; i++)
  {
   result = computein(in readonlyinstance);
  }
  return result;
 }

 public decimal compute(normalstruct s)
 {
  //业务逻辑
  return 0m;
 }

 public decimal computein(in normalstruct s)
 {
  //业务逻辑
  return 0m;
 }

 public decimal computein(in readonlystruct s)
 {
  //业务逻辑
  return 0m;
 }
}

在没有使用 in 参数的方法中，意味着每次调用传入的是变量的一个新副本; 而在使用 in 修饰符的方法中，每次不是传递变量的新副本，而是传递同一副本的只读引用。

使用 benchmarkdotnet 工具测试三个方法的运行时间，结果如下：

|             method |       mean |    error |    stddev |     median | ratio | ratiosd |
|------------------- |-----------:|---------:|----------:|-----------:|------:|--------:|
|       donormalloop | 1,536.3 ms | 65.07 ms | 191.86 ms | 1,425.7 ms |  1.00 |    0.00 |
|   donormalloopbyin |   480.9 ms | 27.05 ms |  79.32 ms |   446.3 ms |  0.32 |    0.07 |
| doreadonlyloopbyin |   581.9 ms | 35.71 ms | 105.30 ms |   594.1 ms |  0.39 |    0.10 |

从这个结果可以看出，如果使用 in 参数，不管是一般的结构体还是只读结构体，相对于不用 in 修饰符的参数，性能都有较大的提升。这个性能差异在不同的机器上运行可能会有所不同，但是毫无疑问，使用 in 参数会得到更好的性能。

在 parallel.for 中使用

在上面简单的 for 循环中，我们看到 in 参数有助于性能的提升，那么在并行运算中呢？我们把上面的 for 循环改成使用 parallel.for 来实现，代码如下：

[benchmark(baseline = true)]
public decimal donormalloop()
{
 decimal result = 0m;
 parallel.for(0, loops, i => compute(normalinstance));
 return result;
}

[benchmark]
public decimal donormalloopbyin()
{
 decimal result = 0m;
 parallel.for(0, loops, i => computein(in normalinstance));
 return result;
}

[benchmark]
public decimal doreadonlyloopbyin()
{
 decimal result = 0m;
 parallel.for(0, loops, i => computein(in readonlyinstance));
 return result;
}

事实上，道理是一样的，在使用 in 参数的方法中，每次调用传入的是变量的一个新副本; 在使用 in 修饰符的方法中，每次传递的是同一副本的只读引用。

使用 benchmarkdotnet 工具测试三个方法的运行时间，结果如下：

|             method |     mean |    error |   stddev | ratio |
|------------------- |---------:|---------:|---------:|------:|
|       donormalloop | 793.4 ms | 13.02 ms | 11.54 ms |  1.00 |
|   donormalloopbyin | 352.4 ms |  6.99 ms | 17.27 ms |  0.42 |
| doreadonlyloopbyin | 341.1 ms |  6.69 ms | 10.02 ms |  0.43 |

同样表明，使用 in 参数会得到更好的性能。

使用 in 参数需要注意的地方

我们来看一个例子，定义一个一般的结构体，包含一个属性 value 和 一个修改该属性的方法 updatevalue。 然后在别的地方也定义一个方法 updatemynormalstruct 来修改该结构体的属性 value。 代码如下：

struct mynormalstruct
{
 public int value { get; set; }

 public void updatevalue(int value)
 {
  value = value;
 }
}

class program
{
 static void updatemynormalstruct(mynormalstruct mystruct)
 {
  mystruct.updatevalue(8);
 }

 static void main(string[] args)
 {
  mynormalstruct mystruct = new mynormalstruct();
  mystruct.updatevalue(2);
  updatemynormalstruct(mystruct);
  console.writeline(mystruct.value);
 }
}

您可以猜想一下它的运行结果是什么呢？ 2 还是 8？

我们来理一下，在 main 中先调用了结构体自身的方法 updatevalue 将 value 修改为 2， 再调用 program 中的方法 updatemynormalstruct， 而该方法中又调用了 mynormalstruct 结构体自身的方法 updatevalue，那么输出是不是应该是 8 呢？ 如果您这么想就错了。

它的正确输出结果是 2，这是为什么呢？

这是因为，结构体和许多内置的简单类型（sbyte、byte、short、ushort、int、uint、long、ulong、char、float、double、decimal、bool 和 enum 类型）一样，都是值类型，在传递参数的时候以值的方式传递。因此调用方法 updatemynormalstruct 时传递的是 mystruct 变量的新副本，在此方法中，其实是此副本调用了 updatevalue 方法，所以原变量 mystruct 的 value 不会发生变化。

说到这里，有聪明的朋友可能会想，我们给 updatemynormalstruct 方法的参数加上 in 修饰符，是不是输出结果就变为 8 了，in 参数不就是引用传递吗？

我们可以试一下，把代码改成：

static void updatemynormalstruct(in mynormalstruct mystruct)
{
 mystruct.updatevalue(8);
}

static void main(string[] args)
{
 mynormalstruct mystruct = new mynormalstruct();
 mystruct.updatevalue(2);
 updatemynormalstruct(in mystruct);
 console.writeline(mystruct.value); 
}

运行一下，您会发现，结果依然为 2 ！这……就让人大跌眼镜了……

用工具查看一下 updatemynormalstruct 方法的中间语言：

.method private hidebysig static 
 void updatemynormalstruct (
 [in] valuetype consoleapp4intest.mynormalstruct& mystruct
 ) cil managed 
{
 .param [1]
 .custom instance void [system.runtime]system.runtime.compilerservices.isreadonlyattribute::.ctor() = (
 01 00 00 00
 )
 // method begins at rva 0x2164
 // code size 18 (0x12)
 .maxstack 2
 .locals init (
 [0] valuetype consoleapp4intest.mynormalstruct
 )

 il_0000: nop
 il_0001: ldarg.0
 il_0002: ldobj consoleapp4intest.mynormalstruct 
 il_0007: stloc.0
 il_0008: ldloca.s 0
 il_000a: ldc.i4.8
 il_000b: call instance void consoleapp4intest.mynormalstruct::updatevalue(int32)
 il_0010: nop
 il_0011: ret
} // end of method program::updatemynormalstruct

您会发现，在 il_0002、il_0007 和 il_0008 这几行，仍然创建了一个 mynormalstruct 结构体的防御性副本(defensive copy)。虽然在调用方法 updatemynormalstruct 时以引用的方式传递参数，但在方法体中调用结构体自身的 updatevalue 前，却创建了一个该结构体的防御性副本，改变的是该副本的 value。这就有点奇怪了，不是吗？

google 了一些资料是这么解释的：c# 无法知道当它调用一个结构体上的方法(或getter)时，是否也会修改它的值/状态。于是，它所做的就是创建所谓的“防御性副本”。当在结构体上运行方法(或getter)时，它会创建传入的结构体的副本，并在副本上运行方法。这意味着原始副本与传入时完全相同，调用者传入的值并没有被修改。

有没有办法让方法 updatemynormalstruct 调用后输出 8 呢？您将参数改成 ref 修饰符试试 :stuck_out_tongue_winking_eye: :grin: :joy:

综上所述，最好不要把 in 修饰符和一般（非只读）结构体一起使用，以免产生晦涩难懂的行为，而且可能对性能产生负面影响。

in 参数的限制

不能将 in、ref 和 out 关键字用于以下几种方法：

• 异步方法，通过使用 async 修饰符定义。
• 迭代器方法，包括 yield return 或 yield break 语句。
• 扩展方法的第一个参数不能有 in 修饰符，除非该参数是结构体。
• 扩展方法的第一个参数，其中该参数是泛型类型（即使该类型被约束为结构体。）
  

总结

使用 in 参数，有助于明确表明此参数不可修改的意图。

当只读结构体（readonly struct）的大小大于 intptr.size 3 时，出于性能原因，应将其作为 in 参数传递。

不要将一般（非只读）结构体作为 in 参数，因为结构体是可变的，反而有可能对性能产生负面影响，并且可能产生晦涩难懂的行为。

到此这篇关于c#中的in参数与性能分析的文章就介绍到这了,更多相关c#中in参数与性能内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！