Why are readonly fields able to be assigned in init accessors but not in with expressions?

[jnm2]

It's keeping me from being able to move classes to records, because I'm having a hard time stomaching the idea of replacing all readonly fields (or all the ones that need it) with private int a { get; init; }-style properties.

record R
{
    private readonly int a;
        
    // ❌ CS0191 A readonly field cannot be assigned to (except in a constructor or init-only setter of the type in which
    // the field is defined or a variable initializer)
    //                             ↓ 
    public R Test() => this with { a = 42 };
}

And yet the compiler is happy with this:

record R
{
    private readonly int a;
    
    private int aAccessor { init => a = value; }
    
    public R Test() => this with { aAccessor = 42 };
}

If there is a logical difference between these two things, what is it?

Is this a runtime limitation? If so, would the C# team consider a proposal to enable initializing readonly fields in with expressions by synthesizing private unspeakable accessors to do the job, like I did manually in the previous code snippet?

[RikkiGibson]

The decision to only relax the limitation for init accessors and not for readonly fields was deliberate. I do not think it is a runtime limitation. It's possible that a sufficiently compelling use case exists to allow this. We'd have to search the proposals and meeting notes for records and init accessors.

[jnm2]

That's interesting to know. Out of everything in https://github.com/dotnet/csharplang/search?q=readonly&type=code, there are only two pieces I found:

https://github.com/dotnet/csharplang/blob/main/meetings/2020/LDM-2020-04-13.md#should-we-have-init-only-fields

https://github.com/dotnet/csharplang/blob/main/meetings/2020/LDM-2020-06-15.md#initializing-readonly-fields-in-same-type

We still think readonly fields are interesting, but we're not sure of the scenarios yet. Let's keep this on the table, but leave it for a later design meeting.

[jnm2]

I would like there to be a conceptual equivalence between readonly fields and private init; properties, in terms of which places you can initialize them. @333fred said (DotNetEvolution discord) that a proposal would go a long way towards helping make this happen, but an implementation would not help at the moment because they will need to think carefully about the connection with required members. I plan to write up a proposal issue soon.

[TheUnlocked]

To me, readonly should mean read only, and the ability to assign readonly from outside of the class feels wrong, and could lead developers to mistakenly believe that their readonly fields, even if non-private, cannot be touched from the outside (this would be particularly problematic with existing code which correctly made that assumption, only for that assumption to be invalidated with a later change). Allowing the init keyword on fields, or even combining them to get init readonly, would be a better approach in my opinion.

[jnm2]

Yes. The motivation is for immutable classes with private readonly fields and public methods returning updated copies to be able to become records and use with expressions to avoid massive boilerplate, without also having to turn all private readonly fields into private { get; init; } properties.

[RikkiGibson]

It feels to me like the set of members which can be assigned by a with expression should be very similar or equivalent to those which can be assigned in an object initializer block.

[jnm2]

@RikkiGibson I put this in the DotNetEvolution Roslyn channel. Do you have an opinion on it?

Is it too grandiose to propose that readonly fields and private init; properties should be able to be thought of as equivalent in terms of how initialization works, and therefore ask for both with expressions and object initializers to be allowed to set readonly fields, even though the real-world use cases I know about are just for with expressions?

The options in front of me are either to dive in with "[Proposal]: Initialize readonly fields in with expressions and object initializers" or to limit it to "[Proposal]: Initialize readonly fields in with expressions" and leave an open question on whether object initializers should also be made consistent towards that mental model.

I guess the fact that the motivation section only has things to say about with expressions gives me a clue.

[ufcpp]

Readonly fields can already be assigned from outside of the class via init accessors.

var x1 = new Immutable { X = 1 };
var x2 = x1 with { X = 2 };

Console.WriteLine(x1.X);
Console.WriteLine(x2.X);

record Immutable
{
    private readonly int _x;
    public int X
    {
        get => _x;
        init => _x = value; // assign to readonly field
    }
}

[jnm2]

But not directly. The relevant difference is that that owning type has to explicitly provide this avenue to allow a different class to indirectly set the readonly field.

I'm fine with maintaining this concept. I'm not fine with having to use an init accessor in order for the same class to be able to initialize its own readonly field.

[jnm2]

Nested types poke a hole in the concept that people should be able to think of readonly fields as being assignable in all the same places that private init; properties are assignable. I'll continue with the proposal without this concept.

record C
{
    private readonly int readonlyField;
    private int InitOnlyProperty { get; init; }
    
    class NestedType
    {
        void M()
        {
            // Since C# 1, readonly fields of containing types cannot be assigned inside nested types even though private
            // properties can. This is a difference between readonly fields and private init properties that should
            // remain. 
            
            // ❌ CS0191 A readonly field cannot be assigned to (except in a constructor or init-only setter of the type
            // in which the field is defined or a variable initializer)
            //                                       ↓↓↓↓↓↓↓↓↓↓↓↓↓
            _ = new C() with { InitOnlyProperty = 1, readonlyField = 1 };       
            //                                ↓↓↓↓↓↓↓↓↓↓↓↓↓     
            _ = new C { InitOnlyProperty = 1, readonlyField = 1 };
        }
    }
}