structs and 'using'

[Nemanja Trifunovic]

A question for C# language experts:

If I have a struct that implements IDisposable:

struct C : IDisposable
{
public int clan;
public void Dispose()
{
Console.WriteLine("Disposing");
}
}
And later in the code something like:
using (C s = new C())
{
s.clan = 1;
}
A compiler error is reported:
error CS0131: The left-hand side of an assignment must be a variable,
property or indexer

Why does that happen?

[Daniel Jin]

the struct is being boxed I believe, therefore the error is generated because
you'd never been able to assign value to the original struct with that line
of code.

"Nemanja Trifunovic" wrote:

A question for C# language experts:

If I have a struct that implements IDisposable:

struct C : IDisposable
{
public int clan;
public void Dispose()
{
Console.WriteLine("Disposing");
}
}
And later in the code something like:
using (C s = new C())
{
s.clan = 1;
}
A compiler error is reported:
error CS0131: The left-hand side of an assignment must be a variable,
property or indexer

Why does that happen?

[Daniel Pratt]

The struct will indeed get boxed when the "using" statement gets a reference
to the IDisposable interface. On the other hand, variable "s" should be the
original unboxed struct and therefore it should be possible to do what is
being done. I say it's a bug. Especially since this will work:

C s = new C();

using (s)
{
s.clan = 1;
}

Regards,
Daniel

"Daniel Jin" <Da*******@discussions.microsoft.com> wrote in message
news:9D**********************************@microsof t.com...

the struct is being boxed I believe, therefore the error is generated because you'd never been able to assign value to the original struct with that line of code.

"Nemanja Trifunovic" wrote:

A question for C# language experts:

If I have a struct that implements IDisposable:

struct C : IDisposable
{
public int clan;
public void Dispose()
{
Console.WriteLine("Disposing");
}
}
And later in the code something like:
using (C s = new C())
{
s.clan = 1;
}
A compiler error is reported:
error CS0131: The left-hand side of an assignment must be a variable,
property or indexer

Why does that happen?

[John Puopolo]

Hmm...

I do not have a quick answer to this. To test this, I wrote a simple
program and disassembled it. The code should expand to the following:

C s;
s = new C();
try { s.clan =1 } finally { s.Dispose(); }

If you hand-code this instead of leveraging the "using" statement, this code
compiles fine. There must be something to the fact that C is a struct vs. a
class (try changing "stuct" to "class" to see everything work fine in your
original). In addition, even if you do not inherit from IDispose (or
anything else, for that matter and leave the struct a plain vanilla struct),
the compiler still complains.

I'd be interested in the reply as well...

John

"Nemanja Trifunovic" <nt*********@hotmail.com> wrote in message
news:82**************************@posting.google.c om...

A question for C# language experts:

If I have a struct that implements IDisposable:

struct C : IDisposable
{
public int clan;
public void Dispose()
{
Console.WriteLine("Disposing");
}
}
And later in the code something like:
using (C s = new C())
{
s.clan = 1;
}
A compiler error is reported:
error CS0131: The left-hand side of an assignment must be a variable,
property or indexer

Why does that happen?

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

Daniel and Daniel,

The structure does not get boxed. The compiler realizes that the
structure has a public Dispose method and calls it directly on the
structure. It is never boxed.

The reason for this is that certain constructs cause the object
mentioned in them to be readonly. The using statement and the foreach
statement are the two offhand that I remember in C# that you can not change.
For most reference types, if you do something like this:

using (MyClass s = new MyClass())
{

}

You can change properties of s, but you can't change s itself. Because
you are using a structure, and it is not a reference, it is not allowed to
be changed.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard.caspershouse.com

"Daniel Pratt" <ko******************@hotmail.com> wrote in message
news:eD**************@TK2MSFTNGP15.phx.gbl...

The struct will indeed get boxed when the "using" statement gets a
reference
to the IDisposable interface. On the other hand, variable "s" should be
the
original unboxed struct and therefore it should be possible to do what is
being done. I say it's a bug. Especially since this will work:

C s = new C();

using (s)
{
s.clan = 1;
}

Regards,
Daniel

"Daniel Jin" <Da*******@discussions.microsoft.com> wrote in message
news:9D**********************************@microsof t.com...

the struct is being boxed I believe, therefore the error is generated

because

you'd never been able to assign value to the original struct with that

line

of code.

"Nemanja Trifunovic" wrote:

> A question for C# language experts:
>
> If I have a struct that implements IDisposable:
>
> struct C : IDisposable
> {
> public int clan;
> public void Dispose()
> {
> Console.WriteLine("Disposing");
> }
> }
>
>
> And later in the code something like:
> using (C s = new C())
> {
> s.clan = 1;
> }
>
>
> A compiler error is reported:
> error CS0131: The left-hand side of an assignment must be a variable,
> property or indexer
>
> Why does that happen?
>

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

John,

The fact that it is only a structure is part of the reason. The target
of a "using" statement and a "foreach" statement can not be modified. In
the case of a reference type, that means the reference. In the case of a
value type, that means the whole structure.

By "target", I mean the instance that is created in the statement. If
you are using an existing variable, then the restriction does not apply.

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

"John Puopolo" <jo**********@fastsearch.com.nospam> wrote in message
news:eE****************@TK2MSFTNGP15.phx.gbl...

Hmm...

I do not have a quick answer to this. To test this, I wrote a simple
program and disassembled it. The code should expand to the following:

C s;
s = new C();
try { s.clan =1 } finally { s.Dispose(); }

If you hand-code this instead of leveraging the "using" statement, this
code
compiles fine. There must be something to the fact that C is a struct vs.
a
class (try changing "stuct" to "class" to see everything work fine in your
original). In addition, even if you do not inherit from IDispose (or
anything else, for that matter and leave the struct a plain vanilla
struct),
the compiler still complains.

I'd be interested in the reply as well...

John

"Nemanja Trifunovic" <nt*********@hotmail.com> wrote in message
news:82**************************@posting.google.c om...

A question for C# language experts:

If I have a struct that implements IDisposable:

struct C : IDisposable
{
public int clan;
public void Dispose()
{
Console.WriteLine("Disposing");
}
}
And later in the code something like:
using (C s = new C())
{
s.clan = 1;
}
A compiler error is reported:
error CS0131: The left-hand side of an assignment must be a variable,
property or indexer

Why does that happen?

[David Browne]

"Daniel Pratt" <ko******************@hotmail.com> wrote in message
news:eD**************@TK2MSFTNGP15.phx.gbl...

The struct will indeed get boxed when the "using" statement gets a
reference
to the IDisposable interface. On the other hand, variable "s" should be
the
original unboxed struct and therefore it should be possible to do what is
being done. I say it's a bug. Especially since this will work:

C s = new C();

using (s)
{
s.clan = 1;
}

First of all, why would you ever have a Disposable struct?

But putting that aside, this is not a bug.

From the C# Language Specification
http://msdn.microsoft.com/library/de...pspec_8_13.asp

Local variables declared in a resource-acquisition are read-only, and must
include an initializer. A compile-time error occurs if the embedded
statement attempts to modify these local variables (by assignment or the ++
and -- operators) or pass them as ref or out parameters.

This works fine:

[Daniel Jin]

as always, you are right Nick. I was just thinking, it wouldn't really had
made sense that a value type will be boxed when an method is called, like
DateTime.AddXXX. so I looked in the IL and there's no box.

"Nicholas Paldino [.NET/C# MVP]" wrote:

Daniel and Daniel,

The structure does not get boxed. The compiler realizes that the
structure has a public Dispose method and calls it directly on the
structure. It is never boxed.

The reason for this is that certain constructs cause the object
mentioned in them to be readonly. The using statement and the foreach
statement are the two offhand that I remember in C# that you can not change.
For most reference types, if you do something like this:

using (MyClass s = new MyClass())
{

}

You can change properties of s, but you can't change s itself. Because
you are using a structure, and it is not a reference, it is not allowed to
be changed.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard.caspershouse.com

"Daniel Pratt" <ko******************@hotmail.com> wrote in message
news:eD**************@TK2MSFTNGP15.phx.gbl...

The struct will indeed get boxed when the "using" statement gets a
reference
to the IDisposable interface. On the other hand, variable "s" should be
the
original unboxed struct and therefore it should be possible to do what is
being done. I say it's a bug. Especially since this will work:

C s = new C();

using (s)
{
s.clan = 1;
}

Regards,
Daniel

"Daniel Jin" <Da*******@discussions.microsoft.com> wrote in message
news:9D**********************************@microsof t.com...

the struct is being boxed I believe, therefore the error is generated

because

you'd never been able to assign value to the original struct with that

line

of code.

"Nemanja Trifunovic" wrote:

> A question for C# language experts:
>
> If I have a struct that implements IDisposable:
>
> struct C : IDisposable
> {
> public int clan;
> public void Dispose()
> {
> Console.WriteLine("Disposing");
> }
> }
>
>
> And later in the code something like:
> using (C s = new C())
> {
> s.clan = 1;
> }
>
>
> A compiler error is reported:
> error CS0131: The left-hand side of an assignment must be a variable,
> property or indexer
>
> Why does that happen?
>

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

David,

I would never implement Dispose on a struct, but I would have a struct
that has a public dispose method to do scope cleanup. For example, I have a
struct that performs an operation like a data adapter, where it will take a
connection, and if it is closed, will close it, and if open, will keep it
open. When it disposes, it will leave the connection state the way it found
it.

It is placed in a struct specifically to be used in a using statement as
a perf enhancement. Having an object do this would require the object to be
cleaned up at a later time, instead of being wiped away with the stack.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard.caspershouse.com

"David Browne" <davidbaxterbrowne no potted me**@hotmail.com> wrote in
message news:u7*************@TK2MSFTNGP10.phx.gbl...

"Daniel Pratt" <ko******************@hotmail.com> wrote in message
news:eD**************@TK2MSFTNGP15.phx.gbl...

The struct will indeed get boxed when the "using" statement gets a
reference
to the IDisposable interface. On the other hand, variable "s" should be
the
original unboxed struct and therefore it should be possible to do what is
being done. I say it's a bug. Especially since this will work:

C s = new C();

using (s)
{
s.clan = 1;
}

First of all, why would you ever have a Disposable struct?

But putting that aside, this is not a bug.

From the C# Language Specification

http://msdn.microsoft.com/library/de...pspec_8_13.asp

Local variables declared in a resource-acquisition are read-only, and must
include an initializer. A compile-time error occurs if the embedded
statement attempts to modify these local variables (by assignment or the
++ and -- operators) or pass them as ref or out parameters.

This works fine:

[Daniel Jin]

"Daniel Pratt" wrote:

The struct will indeed get boxed when the "using" statement gets a reference
to the IDisposable interface. On the other hand, variable "s" should be the
original unboxed struct and therefore it should be possible to do what is
being done. I say it's a bug. Especially since this will work:

C s = new C();

using (s)
{
s.clan = 1;
}

this works because apparently right after initobj of 's', a second copy is
made, and Dispose method is called off of this second copy, leaving the
original copy of 's' free to be modified.
Regards,
Daniel

"Daniel Jin" <Da*******@discussions.microsoft.com> wrote in message
news:9D**********************************@microsof t.com...

the struct is being boxed I believe, therefore the error is generated

because

you'd never been able to assign value to the original struct with that

line

of code.

"Nemanja Trifunovic" wrote:

A question for C# language experts:

If I have a struct that implements IDisposable:

struct C : IDisposable
{
public int clan;
public void Dispose()
{
Console.WriteLine("Disposing");
}
}
And later in the code something like:
using (C s = new C())
{
s.clan = 1;
}
A compiler error is reported:
error CS0131: The left-hand side of an assignment must be a variable,
property or indexer

Why does that happen?

[Scott Allen]

I rather like IanG's TimedLock struct which implements IDisposable:

http://www.interact-sw.co.uk/iangblo.../03/23/locking

and EricGu's comments here:

http://blogs.msdn.com/ericgu/archive.../24/95743.aspx

--
Scott
http://www.OdeToCode.com/blogs/scott/
On Fri, 29 Oct 2004 15:33:39 -0400, "Nicholas Paldino [.NET/C# MVP]"
<mv*@spam.guard.caspershouse.com> wrote:

David,

I would never implement Dispose on a struct, but I would have a struct
that has a public dispose method to do scope cleanup. For example, I have a
struct that performs an operation like a data adapter, where it will take a
connection, and if it is closed, will close it, and if open, will keep it
open. When it disposes, it will leave the connection state the way it found
it.

It is placed in a struct specifically to be used in a using statement as
a perf enhancement. Having an object do this would require the object to be
cleaned up at a later time, instead of being wiped away with the stack.

[Nemanja Trifunovic]

Thanks, Nicholas.

This makes perfect sense.