C#中未赋值局部变量是否必然触发CS0165编译器错误？

Great question—let’s break this down clearly. First, a quick recap: CS0165 fires when the C# compiler spots a code path where a local variable is read before it’s definitely assigned. Unlike C++ (where this is undefined behavior with unpredictable outcomes), C# uses static data flow analysis to enforce definite assignment rules—but this doesn’t mean every "potential" uninitialized use will trigger the error.

Is CS0165 always triggered for such code? #

No, it’s not. The error only occurs when the compiler cannot prove that every code path leading to the variable’s use includes an assignment to that variable. If the compiler can verify the variable is definitely assigned before being read, no error will be thrown.

When won’t the code trigger CS0165? #

Here are common scenarios where the compiler accepts the code without errors:

1. All code paths initialize the variable #

If every possible branch assigns a value to the variable, the compiler recognizes this and doesn’t flag an error. For example:

int val;
if (something()) {
    val = 10;
} else {
    val = 20; // Every path assigns val a value
}
val++; // No error here

This also applies to switch statements, as long as all cases (including a default case) assign the variable.

2. Uninitialized paths are terminated early #

If a branch where the variable isn’t initialized ends with a return, throw, or unreachable code (like an infinite loop), the compiler knows the variable’s use won’t be reached in that scenario. Example:

int val;
if (!something()) {
    throw new InvalidOperationException("Required condition failed!");
}
val = 10;
val++; // No error—if something() is false, we throw before reaching val++

Or with a return:

int val;
if (!something()) {
    return;
}
val = 10;
val++; // Compiler knows the else path exits early, so val is initialized here

3. Compiler can resolve constant conditions #

If the condition is a compile-time constant the compiler can evaluate, it will only check the relevant code path. For example:

int val;
if (true) { // Compiler knows this branch always runs
    val = 10;
}
val++; // No error—val is definitely assigned

Key difference from C++ #

Unlike C++, where uninitialized local variables lead to undefined behavior (anything from random values to crashes), C#’s definite assignment rules are enforced at compile time to eliminate this risk entirely—whenever the compiler can prove it.

内容的提问来源于stack exchange，提问作者sharptooth