Question

我想知道＆＃34;正确＆＃34;或者＃34;推荐＆＃34;编写一个返回值的本地函数的方法，并将其赋值给＆＃34; parent＆＃34;功能。（＆＃34;本地函数的主机＆＃34;的实际名称是什么？）

我看到以下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
    }
}

使用＆＃34; parent＆＃34;的变量函数，只需设置它并使用空函数

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

Answer 1

简单的答案是：如果你可以编写你的函数，这样他们就不需要修改成员变量，你会发现它们更容易测试，并且不太可能影响你程序其余部分的行为。意外的方式。对于像你的例子这样的事情，我可以想到的将计算结果存储在成员变量中的几个很好的理由之一就是它的成本特别高，并且你需要在未来的各个未指定的点使用结果

Answer 2

如果我们将前两个代码示例放入SharpLab，我们可以看到编译器将代码降低到：

For code sample 1：

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

For code sample 2：

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

在第二个例子中，创建一个结构有一点点开销，其中存储了sum。

除此之外，哪个是“最佳”的确是主观的。在我看来，样本1更容易理解。你是否同意，纯粹是一个意见问题。

我唯一表达强烈意见的是不做选项3.重新使用相同的名称，sum在我看来简直令人困惑。同样，这是纯粹的意见。

Answer 3

第一种方式似乎最合法，因为它不违反查询命令分离原则。如果方法的返回类型是Int32（第三个例子），我希望该方法不会改变任何状态，但它确实会将变量的值更改为其范围。第二个例子更好，但仍然太含蓄。如果你的目标是返回一些东西 - 返回它。关心接下来发生的事情并不是你的责任。

本地功能 - 分配变量

3 个答案: