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;
}
}
- 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
Reset to default 1a 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.