3

Given the method

ref readonly State GetState();

where State is a struct, the following code accesses State.SimTime without copying State:

ref readonly var state = ref GetState();
var t = state.SimTime;

Meanwhile this code does copy State:

var start = GetState();
var t =  state.SimTime;

My question is whether the following copies State:

var t = GetState().SimTime;

My hope is that it doesn't, since the result of GetState() is a ref and never assigned, but I don't know for sure and don't know how I would test for it.

As a bonus, is there a way to inspect code staticcally to determine whether memory is copied?

Improve this question
1
  • To be explicit: the current accepted answer is ... well, not strictly "wrong", but incomplete - it only works because it uses an auto-prop and auto-prop marks the get as readonly, and that makes a huge difference to the answer. Commented Dec 14, 2024 at 8:56

3 Answers 3

Reset to default
2

GetState().SimTime does not create a copy of State. You can see this by looking at the generated IL on SharpLab or some other tool.

GetState().SimTime gets compiled to two call instructions:

// IL pseudocode
call GetState
call get_SimTime

The code snippet that uses a ref readonly var compiles to the same two call instructions.

On the other hand, the code snippet that does not use ref readonly var compiles to:

// IL pseudocode
call GetState
ldobj State
stloc.0
ldloca.s 0
call get_SimTime

The key instruction here is ldobj - this is what turns the reference that GetState returns, into an actual struct value (i.e. the copy of State). If you don't see an instruction like ldobj after calling a ref-return method, that means the code is operating on the reference returned by the method, and not a struct value.

As Marc Gravell's answer says, the runtime would create a defensive copy if the getter of SimTime has side effects.

Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

Compelling argument, but misleading. There can still be runtime a defensive copy: sharplab.io/…
@MarcGravell Wow I did not think of putting side effects in a getter! That is such "evil" :-)
The runtime doesn't know about side effects; it looks for "readonly", which your code lacks
@MarcGravell I don't quite understand your point about side effects, because regardless of readonly the JIT is the same. But since you showed a counterexample, I guess you are right.
I checked deeper; the "get_XXXX" method on an autoprop (at least on struct) gets marked readonly ([IsReadOnly]), so yes: an auto-prop will behave as we expect, but: we don't know whether OP is using an auto-prop (they actually say "field", which is different again); however, to see the difference in IL more clearly, I created this for you: gist.github.com/mgravell/49854023b349e5762db59c23be7f50ae - now you should be able to clearly see the defensive copy in the Il (a pair like stloc.3 + ldloca.s 3)
|
2

No, it won't be copied.

From docs:

To use a value returned from a method, the calling method can use the method call itself anywhere a value of the same type would be sufficient.

Using the GetValue() method call is equivalent to using a ref local variable/parameter, i.e. byRefParameter.

If we didn't have the readonly modifier we could easily demonstrate this by writing:

GetState().SimTime = 42; // byRefParameter.SimTime = 42

And since accessing a field of a byref argument/local variable, doesn't involve copying the struct

var t = byRefParameter.SimTime;

the same holds for your case with

var t = GetState().SimTime;
Improve this answer

Comments

1

For a field? No. However, for completeness, we should note that fields should usually not be exposed on the public API surface, and it should usually be a property getter, which is still compatible with the code in your question:

ref readonly var state = ref GetState();
var t = state.SimTime;

Now things get more interesting!

If the property getter is known to be side-effect free, then this is fine, but otherwise there is a defensive copy here to protect the fact that state is meant to be ref readonly. Normally, property getters can do anything, so fetching .SimTime is not by itself reliably side-effect free. But we can make it!

There are two ways:

  1. Mark the entire struct as readonly
  2. Mark the specific property accessor as readonly

For example;

readonly struct Foo
{
    public int SimTime => // some code
}

readonly struct Bar
{
    public readonly int SimTime => // some code
}

Note that nothing is ever truly readonly, and while the compiler will enforce rules, code can still bypass those rules if you try hard enough.

Finally, note that in the case of automatically implemented properties (things like public int X {get; ...} on struct types, the get is treated as readonly automatically. This means that auto-props behave without an additional copy.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.