VB.NET/community

@DualBrain

Isn't that what https://tooslowexception.com/pinned-object-heap-in-net-5/ is for?

Keeping instances steady in memory is half the battle. A pinned object heap helps to reduce or eliminate the need for references/pointer-to-pointer computations, which improves performance.

I don't see how having a "readonly" method in a structure addresses what you describe.

The central issue here is the idiom which C# and VB.NET intend to maintain about a value-type when not in a "by-reference" mode: Every access of it is an independent copy. To maintain this "independent copy" idiom, their compilers may employ what has been called "defensive copying".

The "readonly" on a function is a signal to the C# compiler that it can reduce or eliminate the need for "defensive copying", which improves performance and lowers memory pressure. This is really useful for where the structures are going to be only read (e.g. some reference lookup table, the contents of which hardly or never change). This is what makes immutability so darn interesting for some.

(Of course, "readonly" is a contract to not engage in or do anything that may change the state of the structure. Put another way, it is a promise of there being no side-effects as a consequence of calling the "readonly" member. I'm guessing that the C# compiler will do what it can, and issue errors/warnings accordingly, to enforce that contract.)

To see this "defensive copying" for structures in action, checkout this code snippet. Think about what the output will be (the "*_s1" variables), then give it a try. From this one can see how "defensive copying" for a Structure gets results that are quite different from an otherwise equivalent Class.

Structure CoordsStruct

    Public Shared ToStringCount As Integer = 0

    Public Sub New(x As Double, y As Double)
        Me.X = x
        Me.Y = y
    End Sub

    Public Property X As Double
    Public Property Y As Double

    Public Overrides Function ToString() As String
        ToStringCount += 1
        X += 1
        Return $"({X}, {Y}, {ToStringCount})"
    End Function

End Structure

Class CoordsCls

    Public Shared ToStringCount As Integer = 0

    Public Sub New(x As Double, y As Double)
        Me.X = x
        Me.Y = y
    End Sub

    Public Property X As Double
    Public Property Y As Double

    Public Overrides Function ToString() As String
        ToStringCount += 1
        X += 1
        Return $"({X}, {Y}, {ToStringCount})"
    End Function

End Class

Function Foo(ByRef oo As CoordsStruct) As String
    Return $"{oo}  {oo}"
End Function

Function Foo(oo As CoordsCls) As String
    Return $"{oo}  {oo}"
End Function

Sub Main()

    Dim cs As New CoordsStruct(3, 5)
    Dim cs_s1 As String = $"{cs}  {cs}  {Foo(cs)}"
    Dim cs_s2 As String = $"{cs}  {cs}  {Foo(cs)}"
    Dim cs_s3 As String = $"{cs}  {cs}  {Foo(cs)}"

    Dim cc As New CoordsCls(3, 5)
    Dim cc_s1 As String = $"{cc}  {cc}  {Foo(cc)}"
    Dim cc_s2 As String = $"{cc}  {cc}  {Foo(cc)}"
    Dim cc_s3 As String = $"{cc}  {cc}  {Foo(cc)}"

    Stop

End Sub