Charlie Calvert's Community Blog

The garbage collector was touted as being a foolproof mechanism to prevent us poor dumb programmers from creating memory leaks because we forget to free resources we allocate.  It seems the C++ model is much easier - you just always free resources - kind of like you include the closing curly brace.  Now, with C# and the gc, a programmer must know which objects must be disposed and under what circumstances - it has become a convoluted mess.  Microsoft should either elevate the role of the destructor in C# or, better yet, drop the gc altogether.  

Drop the GC is not an option.

But you are right, that releasing objects in C# it is a real mess. However, this problem is not critical problem like it is in C++ for most cases.

My personal opinion is that the root of the problem lies in the fact that most modern-day (upcoming) programmers are spoiled with an abundance of computing resources. My personal experience dictates that junior programmers should really be introduced to programming through the use of limited resource devices like micro-controllers. Programming micro-controllers in ASM whilst using the minimal amount of resources (=make code as efficient as possible), programmers seem to learn to think out of the box when it comes to the use of resources.

The most common everyday cause for managed objects being leaked remains the Observer pattern, ie, the event subscription which is never removed.

It's absolutely incredible that the CLR team has not implemented a true weak delegate to fix this problem.  Ian Griffiths tried to fix this issue and messed up the implementation.

At the moment there are no good workarounds to this.  The WeakEvent pattern is klutzy and only works in WPF applications anyway.  The simplest general-purpose solutions use tons of "helper classes" and require lots of code just to hook up and unhook.  And they still depend on some sort of message pumping to free dead listeners on events which aren't firing.

This whole mess stems from the lack of a true Delegate class which holds a weak reference to its target.  The CLR gives us a WeakReference, but no WeakDelegate and no way to create one.

It's unbelievable that this wasn't added to the 4.0 framework -- this problem has been around for years and no one at Microsoft seems to notice or care about it.  Instead we got the System.IObserver<T> which requires lots custom code on the part of the observed, and doesn't mesh with existing event properties at all.

Can anyone from Microsoft comment on this mess?  Is it ever going to be fixed?