Can't modify non-variable compiler bug

[Alexander Arlievsky]

Hi,
C# compiler issues error message on the following lines:
GetStruct().Dep th = 10;
if GetStruct() returns structure (value type). It seems to be correct - else
you will modify temporary value on the stack.
It still allows to call method, so GetStruct().Set Depth(10) compiles
perfectly, although obviosly still modifies only temporary value on the
stack.
But in our case "Depth" is property, and its "set" implementation modifies
some external object - our structure is just wrapper around
reference to other object. We made this wrapper value type to prevent
excessive memory allocations for each GetStruct() call.
So in our case it makes sense to write GetStruct().Set Depth(10) - it
modifies non-temporary object,
and if you write on the next line Assert(GetStruc t().Depth == 10) -
assertion isn't failed.

It looks like compiler should threat property call here as method call, not
as simple field assignment.

Any ideas ?

Alexander Arlievsky
C.T.O. mPrest Ltd.
__***********@b la.mprest.spam. com.nospam

[Nicholas Paldino [.NET/C# MVP]]

Alexander,

I don't quite understand why you don't use a reference type for this.
In doing something like this:

// Set the value on the structure.
GetStruct().Dep th = 10;

You are actually allocating the memory on the stack for the structure.
Then, you are boxing the structure. The reason the structure is boxed (a
new object instance is created on the heap anyways) is because you are doing
a property access, and not a simple field access.

I would make your type that is returned a reference type, since you are
going to have to allocate memory on the heap regardless of whether or not
you use a value type or reference type.

Hope this helps.

--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Alexander Arlievsky" <__*******@bla. mprest.spam.com .nospam> wrote in
message news:OV******** *****@TK2MSFTNG P11.phx.gbl...

Hi,
C# compiler issues error message on the following lines:
GetStruct().Dep th = 10;
if GetStruct() returns structure (value type). It seems to be correct - else you will modify temporary value on the stack.
It still allows to call method, so GetStruct().Set Depth(10) compiles
perfectly, although obviosly still modifies only temporary value on the
stack.
But in our case "Depth" is property, and its "set" implementation modifies
some external object - our structure is just wrapper around
reference to other object. We made this wrapper value type to prevent
excessive memory allocations for each GetStruct() call.
So in our case it makes sense to write GetStruct().Set Depth(10) - it
modifies non-temporary object,
and if you write on the next line Assert(GetStruc t().Depth == 10) -
assertion isn't failed.

It looks like compiler should threat property call here as method call, not as simple field assignment.

Any ideas ?

Alexander Arlievsky
C.T.O. mPrest Ltd.
__***********@b la.mprest.spam. com.nospam

[100]

Nicholas,

// Set the value on the structure.
GetStruct().Dep th = 10;

You are actually allocating the memory on the stack for the structure.
Then, you are boxing the structure. The reason the structure is boxed (a
new object instance is created on the heap anyways) is because you are doing a property access, and not a simple field access.

I don't see any reason for the structure to be boxed. Calling methods on
value types doesn't cause any boxing even (at least with c#) if the method
is virtual.
Alexander is right. This won't allocate anything on the heap.
The problem is (IMHO) that the value types are ment to be used to hold
values and not references. Keeping references as a members of value types is
error prone. Anyway, it's legal.
Hence reporting GetStruct().Dep th = 10 as an error is overkill. It should've
been reported as warning instead. Had the compiler reported those cases as
warnings we would've had some way to suppress that warnings as well. Like
*new* keyword when hiding inherited methods.

Anyway, to go arround this the following can be used:
WrapperStruct ws = GetStruct();
ws.Depth() = 10;
This won't use more memory we just gave name of the returned value. This
will make the compiler happy because if we want to we can use the new value
of the property.

[bullshark]

On Thu, 16 Oct 2003 08:22:21 -0400, "Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c om> wrote:

Alexander,

I don't quite understand why you don't use a reference type for this.
In doing something like this:

// Set the value on the structure.
GetStruct().De pth = 10;

You are actually allocating the memory on the stack for the structure.
Then, you are boxing the structure. The reason the structure is boxed (a
new object instance is created on the heap anyways) is because you are doing
a property access, and not a simple field access.

I would make your type that is returned a reference type, since you are
going to have to allocate memory on the heap regardless of whether or not
you use a value type or reference type.

What do you mean by that? i.e. enclose the struct in a class proxy?
I fooled around with this a little, and could not figure a way to make
GetStruct() return a reference without resorting to unsafe and
pointers...is there some syntax to do that directly?