Please consider implementing "final" variables/properties/fields.

[merklegroot]

Init-only setters was a wonderful addition in C# 9.
Please consider taking this a step further by adding "final" variables/properties/fields where the value can only be set in the declaration.

Comparison to other languages

This would match the behavior of the "final" modifier in Java, the "const" modifier in JavaScript/TypeScript, and the default behavior in F# without any modifiers.

(Note that C#'s "const" and JavaScript/TypeScript's "const" have significant differences.)

Example

// This line compiles as the value can be set in the declaration.
final double price = _repo.GetPrice(2);

// This line would cause a syntax error.
price = _repo.GetPrice(3); 

// This line would compile, but const would be a better fit as it's using a compile-time value.
final double pi = 3.1415926d;

Comparison to the "const" modifier

The "const" modifier also enforces that the value only be set in the declaration.
However, "final" would not be restricted to compile time constants.

Comparison to init-only properties and readonly fields

Init-only properties and readonly fields restrict that the values can only be set during construction.
I'm proposing that "final" variables (or properties, fields) restrict the values to being set in their declaration.

---

Thanks for reading!

[HaloFour]

Fields are already covered, the keyword is readonly instead of final. IMO, Having a separate restriction which would further limit the field to only be written in an initializer expression seems unnecessary. Not even Java requires that, you're free to set the field in the constructor.

For readonly parameters and locals, see #188.

[jnm2]

@merklegroot For just the constructor restriction, if you like, you could also achieve a similar thing without convincing people of and waiting for a language change many years from now by creating a custom analyzer:

[Final]
private readonly NonConstantType pi = new(3.1415926d);

You could publish a NuGet package that added an internal source declaration of FinalAttribute to the consuming project and contains a Roslyn analyzer that warns or errors the compilation any time a field marked with your attribute is assigned or used with ref/out in a constructor.

I'd recommend [Const] as a familiar term rather than [Final] for this though. You're saying, "this field would be const if it could be."

[merklegroot]

@HaloFour Thanks for the reply. I was mistaken about Java's "final" restriction - it enforces that the value only be set once and only once but doesn't require that it be set at the declaration.
C#'s readonly fields are slightly less restrictive as you can set their value multiple times so long as it's in the constructor.

What are your thoughts on how to leverage C# to protect against coding mistakes like the one below?

private void RegisterUser()
{
    Console.WriteLine("Please enter your name to use our awesome service:");

    var name = Console.ReadLine();
    if (_userService.IsThatNameTaken(name))
    {
        name = $"{name}1";
        Console.WriteLine($"{name} was already taken. Don't worry though, we took care of it.");
    }

    Console.WriteLine($"Thanks for joining, ${name}!");
}

@jnm2 's suggestion is definitely intriguing. I've never written a Roslyn analyzer before but I might have to give it a shot.