Introduce 'const'ness from C++

[SteveDunn]

const in C++ is great for immutability. It would be valuable in C# too.

[huoyaoyuan]

Note: const in C++ maps to readonly in C#. const in C# maps to constexpr in C++.

[SteveDunn]

Understood, although const relates to more than just fields and, even for fields, isn't a one to one match for read-only. I'd like to see multiple aspects of const in C#, e.g. const methods, const return types, const parameters...

[huoyaoyuan]

Shallow immutability is widely supported in C#:

readonly fields are already there.
readonly locals and parameters are proposed in #188

Deep immutability for structs are also supported:
readonly struct ensures member immutability. readonly field of mutable structs also ensures immutability.

The lacking capacity is instance immutability for classes, proposed in #3885 .

[DavidArno]

Deep immutability for structs are also supported:
readonly struct ensures member immutability. readonly field of mutable structs also ensures immutability.

That's not quite right. Read-only structs only offer shallow immutability, ie the members' values are constant. But if e.g that value is a ref to an object, there's no guarantee the object's members are immutable.

[foxesknow]

I've long wanted to to see better const support in C#. For example, I'd like to initialize a local variable and specify that it cannot change. For example:

    public static void Main() 
    {
        const int delta = GetDelta();
        Console.WriteLine(delta);
    } 
    
    static int GetDelta()
    {
        return 1;
    }

However, this isn't allowed, it generates the error:

error CS0133: The expression being assigned to 'delta' must be constant

Needless to say, readonly doesn't work either.

If you want to get more functional about it I'd settle for using the let keyword:

let int delta = GetDelta();

[HaloFour]

See #188

In C# a const is specifically a value that can be embedded directly into the assembly metadata at compile-time so it can only be initialized with expressions that can be evaluated by the compiler, which are fairly limited. The identifier itself doesn't exist, the compiler replaces all uses of it with the constant value.

The above proposal does intend to allow the use of readonly for parameters and locals which would enable shallow immutability of those locals.

[foxesknow]

Surely within a method the "const-ness"of something can be enforced by the compiler without requiring metadata?

[HaloFour]

Definitely, the compiler could enforce that a parameter or local is readonly without any additional metadata. My point was more that a const isn't a local at all. If you write:

const string FOO = "FOO";
A(FOO);
B(FOO);
C(FOO);

That literally becomes:

A("FOO");
B("FOO");
C("FOO");

You couldn't even tell a constant existed by looking at the IL that the compiler emits. You could argue that this is an implementation detail, and you wouldn't be wrong. 😄

[ufcpp]

see also #2379