Pattern-based using on mutable ref struct doesn't allow the struct to be passed by ref

[huoyaoyuan]

When trying to convert this into using:

https://github.com/dotnet/runtime/blob/5aef85ae3da23dfd49f95be1c9336f1bad2e0123/src/libraries/System.Private.CoreLib/src/System/ApplicationId.cs#L38-L72

ValueStringBuilder must be passed as ref, because it's method may acquire new resource that requires dispose.
The assignment protection for using variable is sure for reference types, but not for value types.

Can we modify the rule to allowing ref for this case?

[Phantonia]

I'm not sure if I understand you correctly, sorry if I don't.
using variables are readonly, so they cannot be assigned to. Thus, passing a using variable by ref is not safe, because the other method might change the content of the variable. However, C# has in parameters that are basically passed by ref, but the other method cannot change the content of that variable. This might solve your problem.

[huoyaoyuan]

using was designed for classes. The limitation is not suitable for structs.

The class object is free to mutate it's inner state. It just cannot be replaced with another object. This isn't true for mutable struct.

The struct must be mutated when used. using doesn't prevent method called on the instance to mutate it's content. sharplab It shouldn't prevent passing by ref and assignment too.

[TheUnlocked]

If you're only interested in calling methods on the struct, you can use an in parameter. Reassignment is no more safe for value types than it is for reference types.

[huoyaoyuan]

If you're only interested in calling methods on the struct

No. The state must be mutated, and the mutation result is related to Dispose.

[huoyaoyuan]

In other words, the struct must not be copied.

[carlreinke]

The spec says "Local variables declared in a resource_acquisition are read-only," but then goes on to specify restrictions that make the variables pretend to be read-only.

The spec does not require that a copy be made when invoking members on a using variable, so in the case of a mutable struct, the variable is not actually read-only.

I think the "read-only" using variable restrictions should be removed for value types. They don't live up to the promise of making the variables read-only, and they prevent the use of using with mutable (usually ref) structs.

[Tinister]

I have to imagine the rationale here is that developers can see the using right next to how the variable is initialized and be certain it's that exact instance that gets disposed.

In fact, if you use legacy using on a pre-initialized variable, but re-assign it, the compiler takes great care to make sure it is in fact the original instance disposed: sharplab

There's no way to tell if a struct being passed by ref is merely being mutated or being re-assigned entirely.

You'll just have to type out the try/finally explicitly.

[timcassell]

Perhaps C# needs a new mutable pass by ref but disallow re-assign. Something like const ref to not be confused with ref readonly (which is basically the same as in)?

[Edit] Looks like #7842 had the same idea.