Brain Teaser #3

re: Brain Teaser #3

Anonymous — Thu, 08 May 2008 01:15:32 GMT

Make your struct to a class and it should work as expected. Structs are copy by value and not reference.

re: Brain Teaser #3

benmartens — Thu, 08 May 2008 01:36:46 GMT

Thanks for the reply. You are correct that a class does not exhibit this behavior, but the brain teaser here is WHY. You mention a copy, but where/why does that copy happen?

Answer will be posted on Tuesday.

re: Brain Teaser #3

Ryan Heaney — Thu, 08 May 2008 01:53:36 GMT

The using statements seem to do everything on local copies of the structs, so it would probably make their copies right at the start of the using block (but after the new). The copies are disposed and not the outside declared foo.

In the second example, it actually seems as if calling the dispose explicitly is calling it on the original instance made by the second new, but then the using's call to dispose calls it on its local copy of foo.

Looking at the IL code for this, it does look like stack space for three instances of Foo are allocated and foo2 and foo3 are using within the first and second using's respectively.

Seems like structs and usings are quite unpredictable when it comes to situations like this.

C# Brain Teaser #3

DotNetKicks.com — Thu, 08 May 2008 02:12:19 GMT

You've been kicked (a good thing) - Trackback from DotNetKicks.com

re: Brain Teaser #3

Unai — Thu, 08 May 2008 18:25:53 GMT

In the adcquisition phase of the using de disposable element is a new Structure Foo, the call to Dispose Method is not in foo.

In the second using, you use de foo in using try phase and set dispose to TRUE..

This code is similar to

Foo foo;

Foo newfoo = new Foo();

using(foo = newfoo)

{}

//Call to newfoo.Dispose()

using(foo = new Foo())

{

foo.Dispose();//set disposed = true

}

Unai

re: Brain Teaser #3

Raj Kaimal — Fri, 09 May 2008 06:28:23 GMT

To call IDisposable, foo is boxed resulting in the heap instance changing its "disposed" value. The value on the stack is not affected.

Similar to this:

int i = 5;

object o = i;

o = ((int)o) + 1;

Console.WriteLine(o.ToString());

Console.WriteLine(i.ToString());

Raj

re: Brain Teaser #3

Chris — Fri, 09 May 2008 19:56:27 GMT

Raj, your explanation is great, but it does not explain why the last time the value of foo.disposed is displayed it is 'true'. If the boxed instances are the only instances affected, then why does the non-boxed foo change?

re: Brain Teaser #3

benmartens — Fri, 09 May 2008 20:04:57 GMT

Boxing is not the answer. If it was boxing, this code would print “Hits: 2” but it doesn’t:

using System;

struct Foo : IDisposable

{

int hitCounter;

public void HitMe()

{

hitCounter++;

}

public void Dispose()

{

Console.WriteLine("Hits: " + hitCounter);

}

static void Main(string[] args)

{

Foo foo;

using (foo = new Foo())

{

foo.HitMe();

}

re: Brain Teaser #3

Raj Kaimal — Sat, 10 May 2008 00:59:42 GMT

Chris,

My intial thinking was that since the using statement

Foo foo;

using (foo = new Foo())

{

}

translates to the following:

Foo foo = new Foo();

try

{

foo.Dispose();

}

finally {

((IDisposable)foo).Dispose();

}

I thought that foo would get boxed. But that is apparently not the case as Ben posted above. The complier will call Dispose directly without boxing it.

My thinking now, after reading the C# specs, is that, because of a resource aqcuisition, the foo in

using (foo = new Foo()) is readonly and is not accessible to the embedded statement. Therefore the compiler makes an extra copy of foo on the stack before the embeded statement is first hit.

Ultram.

Ultram. — Tue, 22 Jul 2008 08:19:04 GMT

Ultram. Can you snort ultram. Ultram side effects.