I know how the scope structure works. But while learning local functions, I didn't understand something. I want to ask my question directly with examples.

This code throws an error:

static void Main(string[] args)
{
    int a = 10;

    if (true)
    {
        int a = 10;
    }
}

This code also throws an error:

static void Main(string[] args)
{
    int a = 10;

    {
        int a = 100;
    }
}

I expected the code shown below to also throw an error, but I was wrong. Why?

static void Main(string[] args)
{
    int a = 10;

    void Local()
    {
        int a = 100;
    }
}

I know how the scope structure works. But while learning local functions, I didn't understand something. I want to ask my question directly with examples.

This code throws an error:

static void Main(string[] args)
{
    int a = 10;

    if (true)
    {
        int a = 10;
    }
}

This code also throws an error:

static void Main(string[] args)
{
    int a = 10;

    {
        int a = 100;
    }
}

I expected the code shown below to also throw an error, but I was wrong. Why?

static void Main(string[] args)
{
    int a = 10;

    void Local()
    {
        int a = 100;
    }
}

• c#

• 4 Okay, so you discovered that local functions create a new declaration space. What don't you understand? – Sweeper Commented Jan 18 at 9:10

1 Answer 1

a local function creates a completely new scope—like a mini-method—so the variable declared inside the local function doesn’t “collide” with the a in the outer scope. On the other hand, simply using braces { } or an if statement in the same method body does not create a new declaration scope for a to be re-declared.

int a = 10;

if(true)
{
    int a = 10; // ❌ Error: a is already defined in this scope
}

the compiler complains because you’re declaring two variables both named a in overlapping scopes. Even though you’re inside braces, the nested block still can “see” the a from the outer block and is not allowed to re-declare it with the same name.

int a = 10;

{
    int a = 100; // ❌ Error: a is already defined
}

Same reason: the new braces { } do not produce a new “method-like” scope for variable declarations. They are just a nested block within the same local variable scope, so re-declaring a is not allowed.

int a = 10;

void Local()
{
    int a = 100; // ✅ Allowed
}

This does not throw an error because a local function has its own scope, just as if you wrote a separate private method:

private static void Local()
{
    int a = 100; // local to the Local() method
}

Inside that local function, you can re-declare a variable named a, and it doesn’t conflict with the a in the outer method. Essentially, the local function is like a new, nested method that just happens to be declared inside Main. so the Conclusion is :

Blocks { } inside a method do not constitute a fresh “method-level” scope, so you cannot re-declare variables with the same name that are already in scope. A local function does create a completely separate scope (just like a nested method), so re-declaring a variable with the same name is allowed.