Clarify `get` inlining

[chucker]

The page says:

The execution of the get accessor is equivalent to reading the value of the field. For example, when you're returning the private variable from the get accessor and optimizations are enabled, the call to the get accessor method is inlined by the compiler so there's no method-call overhead. However, a virtual get accessor method can't be inlined because the compiler doesn't know at compile-time which method may actually be called at run time.

My interpretation is this is correct but slightly confusing. Specifically, the emphasis is on "the call to", as in

• the get accessor method does not get inlined, but
• the call to it may get inlined

This is even more confusing by the "However" sentence afterwards, which is a non sequitor — the get accessor method itself doesn't get inlined regardless.

This is indeed the behavior I observe.

Can we expand this to make it clearer? For example:

For example, when you're returning the private variable from the get accessor and optimizations are enabled, the call to the get accessor method is inlined by the compiler so there's no method-call overhead. However, a get accessor does still get emitted. In addition, a call to a virtual get accessor method can't be inlined because the compiler doesn't know at compile-time which method may actually be called at run time.

[Enter feedback here]

---

Document Details

⚠ Do not edit this section. It is required for learn.microsoft.com ➟ GitHub issue linking.

• ID: 322a60f9-0bd8-b432-653a-069c477a93fe
• Version Independent ID: dbc29edd-b142-f2d7-4824-dec9951f32c7
• Content: Using Properties - C# Programming Guide
• Content Source: docs/csharp/programming-guide/classes-and-structs/using-properties.md
• Product: dotnet-csharp
• Technology: csharp-fundamentals
• GitHub Login: @BillWagner
• Microsoft Alias: wiwagn

---

Associated WorkItem - 230267

[gfoidl]

However, a get accessor does still get emitted.

In sharplab yes, as this will print every method JITed.
In actual running code the get accessor won't be emitted -- it's just used internally by the JIT to be able to inline that piece of code, but it's not emitted nor executed (in that simple case).

For me the original quoted paragraph is correct and not misleading. You suggestion seems off to me.

Was it possible for me to clarify that thing?

[BillWagner]

Good conversation @chucker @gfoidl

These kinds of questions are often tricky to handle well. There are several factors for this:

• The compiler does a minimal amount of optimizations. The JIT compiler does much more. Does that behavior belong in the C# guide?
• The JIT compiler gets continued investment for performance optimizations. Any specific behavior (such as what code is inlined) is an implementation detail. If measurements show that not inlining a construct is faster on some architecture, the JIT behavior may change. That's not too likely in this specific example. However, as a general rule, information about specific JIT behavior can be outdated by new optimizations.

I'd like to push back and ask what details would be useful? @chucker are there decisions you're making based on specific optimizations? Are you looking for general guidance? Learning about the inner workings of the platform?

[chucker]

I'd like to push back and ask what details would be useful? @chucker are there decisions you're making based on specific optimizations? Are you looking for general guidance? Learning about the inner workings of the platform?

For context, this came up on Reddit. Someone relatively new to the language was asking why they should design their class with public properties over public fields, and cited worries of overhead. Someone else pointed out that the getter (if trivial) will be inlined anyway.

This led me to check the documentation and use SharpLab to try and see what the JIT does.

I do think the phrasing could use some work, but both of you make good points.

[BillWagner]

Thanks for the additional information @chucker

That helps.

I'll update this section to include general information about how the C# compiler and JIT compiler work to achieve the best general performance for .NET applications. In this page, I'll point to that new page, and add that property accessors will often be inlined by the JIT compiler.