我在下面展示的是一个理论问题。但我对新的 C#7 编译器如何工作和解析本地函数很感兴趣。

在 C#7 中，我可以使用本地函数。例如(您可以在 LinqPad beta 中尝试这些示例):

示例 1: 嵌套 Main()

void Main()
{
    void Main()
    {
        Console.WriteLine("Hello!");
    }
    Main();
}

DotNetFiddle for Example 1

不是以递归方式调用 Main()，而是调用局部函数 Main() 一次，因此输出为:

Hello!

编译器在没有警告和错误的情况下接受它。

示例 2: 在这里，我要更深入一点，例如:

DotNetFiddle for Example 2

在这种情况下，我也希望得到相同的输出，因为调用了最内层的局部函数，然后向上一层 Main() 只是另一个具有局部作用域的局部函数，所以它应该与第一个示例没有太大区别。

但令我惊讶的是，我得到了一个错误:

CS0136 A local or parameter named 'Main' cannot be declared in this scope because that name is used in an enclosing local scope to define a local or parameter

问题: 您能解释一下为什么在示例 2 中会出现此错误，而在示例 1 中不会吗？

我想，每个内部 Main() 都会有一个本地作用域并隐藏在外面。

更新: 感谢迄今为止所有做出贡献的人(无论是回答还是评论)，您所写的内容对于理解 C# 编译器的行为非常有值(value)。

根据我阅读的内容以及在考虑各种可能性之后，我在您的帮助下发现它可能是编译器错误或设计行为。

剧透:

我们得出的结论是这是一个设计选择，而不是错误。

回想一下，C# 有一些与 C++ 等语言不同的设计目标。

如果您对我为进一步调查所做的工作感兴趣: 我已将最里面的函数重命名为 MainL，例如:

示例 2b:

void Main()
{
    void Main()
    {
        void MainL()
        {
            Console.WriteLine("Hello!");
        }
        MainL();
    }
    Main();     
}

此修改后的示例编译并运行成功。

现在当你用 LinqPad 编译它时然后切换到 IL 选项卡，您可以看到编译器做了什么:

它创建了最内层的 MainL 函数作为 g__MainL0_1，封闭的 Main 函数具有标签 g__Main0_0。

这意味着，如果您从 MainL 中删除 L，您会注意到编译器已经以独特的方式重命名了它，因为这样代码看起来像:

IL_0000:  call        UserQuery.<Main>g__Main0_0
IL_0005:  ret         

<Main>g__Main0_0:
IL_0000:  call        UserQuery.<Main>g__Main0_1
IL_0005:  ret         

<Main>g__Main0_1:
IL_0000:  ldstr       "Hello!"
IL_0005:  call        System.Console.WriteLine
IL_000A:  ret         

这仍然会正确解析。由于代码在示例 2 中看起来不像这样，因为编译器因错误而停止，我现在假设该行为是设计使然，它不太可能是编译器错误。

结论: 你们中的一些人写道，在 C++ 中，局部函数的递归解析会导致重构问题，而另一些人则写道，C# 中的这种行为是编译器对局部变量所做的(注意错误消息是相同的)——甚至证实我认为这是设计使然，没有错误。

最佳答案

封闭范围内的参数和局部变量在局部函数内可用。

I thought, each inner Main() would have a local scope and is hidden outside.

C# 不会覆盖父作用域中的名称，因此在当前作用域和父作用域中定义的局部名称 Main 存在歧义。

因此在第二个示例中，void Main() 的两个声明都可用于内部作用域，编译器会向您显示错误。

这是一个包含变量和局部函数 的示例，可以帮助您在熟悉的环境中查看问题。为了清楚地表明这只是范围问题，我修改了示例并向变量添加了函数以使其清楚:

class Test
{
    int MainVar = 0;
    public void Main()
    {
        if (this.MainVar++ > 10) return;
        int MainVar = 10;
        Console.WriteLine($"Instance Main, this.MainVar=${this.MainVar}, MainVar={MainVar}");
        void Main()
        {
            if (MainVar++ > 14) return;
            Console.WriteLine($"Local Main, this.MainVar=${this.MainVar}, MainVar={MainVar}");
            // Here is a recursion you were looking for, in Example 1
            this.Main();
            // Let's try some errors!
            int MainVar = 110; /* Error! Local MainVar is already declared in a parent scope. 
                //  Error CS0136  A local or parameter named 'MainVar' cannot be declared in this scope 
                // because that name is used in an enclosing local scope to define a local or parameter */
            void Main() { } /* Error! The same problem with Main available on the parent scope. 
                // Error CS0136  A local or parameter named 'Main' cannot be declared in this scope 
                // because that name is used in an enclosing local scope to define a local or parameter */
        }
        Main(); // Local Main()
        this.Main(); // Instance Main()
        // You can have another instance method with a different parameters
        this.Main(99);
        // But you can't have a local function with the same name and parameters do not matter
        void Main(int y) { } // Error! Error CS0128  A local variable or function named 'Main' is already defined in this scope
    }
    void Main(int x)
    {
        Console.WriteLine($"Another Main but with a different parameter x={x}");
    }
}

当您尝试覆盖局部变量和局部函数时，甚至会出现相同的错误。

如您所见，这是一个作用域问题，您不能覆盖局部函数或变量。

顺便说一句，在第一个示例中，您可以使用 this.Main(); 进行递归调用:

void Main()
{
    void Main()
    {
        Console.WriteLine("Hello!");
    }
    this.Main(); // call instance method
}

脚注:局部函数并不像某些评论员建议的那样表示为委托(delegate)，这使得局部函数在内存和 CPU 方面都更加精简。

关于c# - 为什么局部函数并不总是隐藏在 C#7 中？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/41288668/