"Amir Shitrit" <AmirShitrit@discussions.microsoft.com> wrote in message
news:5A7D56BC-FA2B-41BC-9DB1-8F46BC07D1CF@microsoft.com...
> My point is that if the local variables of a method aren't considered as
> root
> references, what prevents the GC from collection local objects
> prematurely?
> Meaning, how does the GC knows (if at all) when do I stop using an object
> inside a method's body?

>
> "Günter Prossliner" wrote:
>
>> Hi Amir!
>>
>>
>> > Is it not possible that the GC will be triggered before I exit the
>> > method?
>>
>> Yes (in Release-Builds).
>>
>> > (Which means all unused objects, defined within the scope of
>> > the method, will still be referenced and will reach generation 1 or
>> > 2).
>>
>> The point is: "Unused" is tracked by Root-References, not be
>> Reference-Counting. So setting an Object-Reference (located on the Stack)
>> to
>> null will not cause the Object behind the Reference to be collected. It
>> may
>> be even later, because setting an Object-Reference is also an Operation
>> with
>> the Reference, so without setting the Reference to null, the Object could
>> have been collected immediatly.
>>
>> Worst Example:
>> try{
>> Foo x = new Foo();
>> x.LastUsage();
>>
>> // some other long-running code
>> } finally {
>> x = null;
>> }
>>
>> In this case you won't help the CLR in any way. Without "x = null" the
>> CLR
>> could collect the Foo - Instance very earlier.
>>
>> Another Example:
>> Foo x = new Foo();
>> x.LastUsage();
>> x = null;
>>
>> // some other long-running code
>>
>> In this case, there is still a (theoretical) time-slide when the GC could
>> act earlier without setting x to null, but (even it will not be
>> significant), you will win nothing in any case, it's just an unnessersary
>> line of code.
>>
>>
>>
>>
>> GP
>>
>>
>>

<"G=FCnter Prossliner" <g.prossliner/gmx/at>> wrote:

> Worst Example:
> try{
> Foo x =3D new Foo();
> x.LastUsage();
>=20
> // some other long-running code
> } finally {
> x =3D null;
> }
>=20
> In this case you won't help the CLR in any way. Without "x =3D null" the =
CLR=20
> could collect the Foo - Instance very earlier.

Amir Shitrit <AmirShitrit@discussions.microsoft.com> wrote:
> My point is that if the local variables of a method aren't considered as root
> references, what prevents the GC from collection local objects prematurely?

> Meaning, how does the GC knows (if at all) when do I stop using an object
> inside a method's body?

> My point is that if the local variables of a method aren't considered
> as root references, what prevents the GC from collection local
> objects prematurely? Meaning, how does the GC knows (if at all) when
> do I stop using an object inside a method's body?

"Jon Skeet [C# MVP]" wrote:

> <"Günter Prossliner" <g.prossliner/gmx/at>> wrote:
>
> <snip>
>
> > Worst Example:
> > try{
> > Foo x = new Foo();
> > x.LastUsage();
> >
> > // some other long-running code
> > } finally {
> > x = null;
> > }
> >
> > In this case you won't help the CLR in any way. Without "x = null" the CLR
> > could collect the Foo - Instance very earlier.
>
> <snip>
>
> No - the CLR detects that the assignment doesn't count as "reading" the
> variable, so it can still collect the instance before the x=null; line
> would be executed.
>
> --
> Jon Skeet - <skeet@pobox.com>
> http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
> If replying to the group, please do not mail me too