Why does 'y + null' yield an empty string while 'null + null' fails in C#?

When you write:

CSHARPCopied
string y = null;
string x = y + null; // returns the empty string

the compiler infers the type of the first operand as string (because of the variable y) so it selects the predefined string concatenation operator:

CSHARPCopied
public static string operator +(string a, string b)

At run time that operator treats any null operands as empty strings. In other words, when you call y + null, it acts like y + "" and returns an empty string when y is null.

However, in the expression:

CSHARPCopied
string x = null + null;

both operands are the null literal. The null literal isn’t inherently typed—it can convert to any nullable type (including string), but overload resolution needs at least one operand with a known type to determine which operator to use. Without that—since there isn’t a predefined operator+ that accepts two untyped nulls—the compiler cannot resolve the overload and issues a compile‑time error.

Thus, the behavior isn’t “inaccurate” but a consequence of how overload resolution works in C#: the presence of a typed operand (like y in the first example) gives the compiler a target type for the conversion, while two null literals leave the operator call ambiguous.

To force the intended behavior in the second case, you can cast one or both nulls to string:

CSHARPCopied
string x = (string)null + (string)null; // returns ""