I think struct should able to made readonly in method parameter, not only in declaration

[martinrhan]

After this article is written I then found out my issue actually dosn't exist. This text is a fault, I want to delete it but can not find the button. Don't read this to waste your time. Admin may just delete this if its posible.

BackGround

we know that we usually have methods including value type as parameter, such as:

void MyMethod(MyValueType v){
//v is copied defensively, any operation made on local v doesn't matter to this method's caller.
}

However the MyValueType struct may be large in size, and copying it whenever the method is called is a waste of computational resource, therefore the idea of ref was introduced.

void MyMethod(ref MyValueType v){
//v is not copied, although benefitial to performance, any operation made on local v will affect this method's caller if v is used by it as well, this is functional sometimes but in other sometimes unintended and mistakenly done. 
}

The ref parameter modifier also provide another convenience, the programmer can define a method that can change the value of a value type parameter. On the other hand, this also produced potential risk: the parameter maybe mistakenly changed, both the reference and the instance's field.
Then we have in parameter modifier, with this modifier, the parameter is passed by reference but cannot be assigned to another reference. But using this only is not enough, as the object's field can still be changed.
Eventually, we got readonly which can be written in a struct declaration. These two C# features are designed to be used in combination:

readonly struct MyValueType {
        readonly long a, b, c, d;
}
void MyMethod(in MyValueType v){
//v is not copied. Reference of v cannot be changed as the parameter is decorated with `in`. Field of v is also not mutable as it is a readonly struct.
}

With such implementation, we got both performance and safe code manner. But a new issue rise.

Issue

Because the struct MyValueType is made readonly the only way to change a field of this type is to create a new instance, as example below:

class MyClass{
        MyValueType myValueType;
        void AnotherMethod(){
               myValueType.a = 1;// not allowed
               myValueType = new MyValueType();// allowed
        }
}

This is actually causing another performance problem, creating a new instance for the whole type's field, which includes even unchanged fields, is abviously costing much more than just changing the value of a single field.
In order to negotiate with this, the programmer should withdraw from readonly struct MyValueType and go back to struct MyValueType. As result, the benefit of immutability assurance is lost in methods using in MyValueType parameter, because although the reference is still secured, the fields with in the instance may be changed by mistake.

Possible Solution

I would be glad to see something like this:

void MyMethod(in readonly MyValueType v){
}

As illustrated above, both reference and fields in instance are secured with immutablity, just like combination of in before parameter and readonly before struct type declaration. But what's different, the readonly is locally written in this method and mutablity of MyValueType instance is still available in other place. Which means, myValueType.a = 1; is going to be allowed in aother method.

[bernd5]

I think there is no delete option - but you can mark it as answered