C# 局部函数赋值变量

我想知道写一个本地函数返回一个值并将其赋值给“父”函数中的变量的“正确”或“推荐”方法是什么。（本地功能的“主机”的实际名称是什么？）

我看到以下3种可能性（可能还有更多）：

• 在局部函数中使用一个变量，并在末尾返回该变量

  private void Foo()
  {
      int sum = Sum(1, 2);
  
      int Sum(int a, int b)
      {
          int localSum = a + b;
          return localSum;
          //I know I could write return a + b; but its just a simple demonstration
          //imagine something more complex, where you intialize an object and work with it in the "Sum" method and than want to return it
      }
  }
  

• 使用“parent”函数的变量，只需设置它并使用void函数即可

  private void Foo()
  {
      int sum;
      Sum(1, 2);
  
      void Sum(int a, int b)
      {
          sum = a + b;
      }
  }
  

• 将以上两者结合起来，以便更容易理解

  Sum

  正在设置Sum变量，但在局部函数中删除变量声明

  private void Foo()
  {
      int sum = Sum(1, 2);
  
      int Sum(int a, int b)
      {
          sum = a + b;
          return sum;
      }
  }
  

---

第一种方式似乎最合法，因为它不违反查询命令分离原则。如果一个方法的返回类型是

Int32

（第三个示例），我希望该方法不会改变任何状态，但是它确实会改变超出其范围的变量值。第二个例子更好，但仍然过于含蓄。如果你的目标是退货，那就退货。关心接下来会发生什么不是你的责任。
简单的答案是：如果你可以编写函数，这样它们就不需要修改成员变量，那么你会发现它们更容易测试，也不太可能以意外的方式影响程序的其余部分。

---

对于您的示例，我能想到的将计算结果存储在成员变量中的几个好理由之一是，如果这样做特别昂贵，并且您需要在将来的各个未指定点使用结果。
如果我们将您的前两个代码示例放入SharpLab，我们可以看到编译器将代码降低为：
:

公共C类
{
私人文件
{
C.g|u Sum|0|0（1,2）；
}
[编译生成]
内部静态整数g__|0_0（整数a，整数b）
{
返回a+b；
}
}

:

公共C类
{
[编译生成]
[StructLayout（LayoutKind.Auto）]
私有结构c\uuu显示类0\u0
{
公共整数和；
}
私人文件
{
C.C_uuu显示类0_u0 C_uuuu显示类0_uuu；
C.g_uu和| 0_0（1，2，参考C_u显示类别0）；
}
[编译生成]
内部静态无效g__|0_0（内部a、内部b、参考C.C__显示类0_0 ptr）
{
ptr.sum=a+b；
}
}

在第二个示例中，创建一个存储了

sum

的结构稍微有点开销
除此之外，哪一个是“最好的”，这确实是主观的。在我看来，示例1更容易理解。不过，你是否同意，纯粹是意见问题

---

我唯一要表达强烈意见的是不要做选项3。在我看来，重复使用同一个名字，

sum

简直令人困惑。同样，这是纯粹的观点。
这是非常基于观点的。但我肯定不会接受最后一个——两者都做会让人困惑。选择一个或另一个-返回或变异。我肯定更喜欢第一个。第二种情况类似于使用全局变量共享状态。如果该函数将不再存在，那么如果不深入挖掘其源代码，您就不知道它实际具有什么效果。

public class C
{
    private void Foo()
    {
        C.<Foo>g__Sum|0_0(1, 2);
    }

    [CompilerGenerated]
    internal static int <Foo>g__Sum|0_0(int a, int b)
    {
        return a + b;
    }
}

public class C
{
    [CompilerGenerated]
    [StructLayout(LayoutKind.Auto)]
    private struct <>c__DisplayClass0_0
    {
        public int sum;
    }

    private void Foo()
    {
        C.<>c__DisplayClass0_0 <>c__DisplayClass0_;
        C.<Foo>g__Sum|0_0(1, 2, ref <>c__DisplayClass0_);
    }

    [CompilerGenerated]
    internal static void <Foo>g__Sum|0_0(int a, int b, ref C.<>c__DisplayClass0_0 ptr)
    {
        ptr.sum = a + b;
    }
}