Local constant initialised to null reference

Question

I have read that C# allows local constants to be initialised to the null reference, for example:

const string MyString = null;

Is there any point in doing so however? What possible uses would this have?

Answer 1

My guess is because null is a valid value that can be assigned to reference types and nullable values types. I can't see any reason to forbid this.

There might be some far off edge cases where this can be useful, for example with multi targeting and conditional compilation. IE you want to define a constant for one platform but define it as null for another due to missing functionality.

Ex, of possible usefull usage:

#IF (SILVELIGHT)
    public const string DefaultName = null;
#ELSE
    public const string DefaultName = "Win7";
#ENDIF 

Answer 2

Indeed, you can initialize local const strings and readonly reference types to null, even though it seems to be redundant since their default value is null anyway.

However, the fact remains that null is a compile-time constant suitable enough to initialize strings and reference types. Therefore, the compiler would have to go out of its way in order to consider, identify and reject this special case, even though it's still perfectly valid from a language standpoint.

The merits of doing that would be disputable, and it probably wouldn't be worth the effort in the first place.

Answer 3

It could be used if you want to write code without keywords, if that strikes your fancy:

const string UninitializedSetting = null;

if (mySetting == UninitializedSetting)
{
    Error("mySetting string not initialized");
}

Answer 4

Choosing to name a value (rather than using an in-place magic constant), using const, and setting to null are more or less orthogonal issues, although I agree that the venn diagram might have a very small area of overlap for the three :)

A case that I can think of is when you have as much or more throw-away data than you do code, but you want to ensure the values don't accidentally get changed while writing or maintaining your code. This situation is fairly common in unit tests:

[Test]
public void CtorNullUserName()
{
    const string expectedUserName = null;

    var user = new User(expectedUserName);

    Assert.AreEqual(expectedUserName, user.Name, "Expected user name to be unchanged from ctor");
}

You could arguably structure such code in a plethora of ways that didn't involve assigning null to a const, but this is still a valid option.

This might also be useful to help resolve method overloading issues:

public class Something
{
    public void DoSomething(int? value) { Console.WriteLine("int?"); }
    public void DoSomething(string value) { Console.WriteLine("string"); }
}

// ...

new Something().DoSomething(null); // This is ambiguous, and won't compile

const string value = null;
new Something().DoSomething(value); // Not ambiguous