I'm writing a Windows application using C#. Let's say I
create MyObject, and MyObject creates MySubObject,
holding the reference in m_SubObject. MySubObject has an
event, MyEvent, and MyObject implements an event handler
for it. Now let's say I have a form called MyForm, which
consumes MyObject. I finish up with MyObject, setting my
reference to null.

It is my understanding that MyObject still has a
reference to MySubObject in m_SubObject, and MySubObject
has a reference back to MyObject through the event
MyEvent. It seems to me that MyObject and MySubObject
have references to each other (I guess technically the
event's delegate has the reference back to MyObject),
though nobody has a reference to MyObject.

My question is, will the Garbage Collector figure out
that nobody needs MyObject anymore, and get rid of it
along with MySubObject? Or, do I need to manually
disconnect MyObject from MySubObject's event interface?
Thanks for clarifying.

Circular references might be a problem in Reference-Counting GCs (but is
not anymore - see Bacon's paper on this). A Generational Garbage
collector (the CLR GC) does not require reference counts and has a very
simple and elegant way of doing this. Leave everything to the GC.

-Andre

Chris Lyon [MSFT] wrote: