Observable Property Pattern

Is there something like this in the standard libraries? And if not, why not?

public class Observable<T>
{
    private T _value;

    public class ChangedEventArgs : EventArgs
    {
        public T OldValue { get; set; }
        public T NewValue { get; set; }
    }

    public EventHandler<ChangedEventArgs> Changed;

    public T Value
    {
        get { return _value; }

        set
        {
            if (!value.Equals(_value))
            {
                T oldValue = _value;
                _value = value;

                EventHandler<ChangedEventArgs> handler = Changed;
                if (handler != null)
                    handler(this, new ChangedEventArgs
                                  {
                                      OldValue = oldValue, 
                                      NewValue = value
                                  });
            }
        }
    }
}

That is, the observable property pattern as a reusable class.

This should be in the System namespace for all to enjoy. It's a great thing when what used to be a "pattern" can now be captured in code using language features (the enabling feature in this case being generics, obviously).

Tracking down CLR memory leaks

CLR programs have memory leaks, just like unmanaged ones, but for a different reason. There are lots of opportunities to add your object to a list - the major example being enlisting for events. If the event source lives for the lifetime of the program, then any objects listening for that event will also last for the lifetime of the program. So if you accidentally leave an object enlisted on such an event, you have created a memory leak - much like forgetting to call delete after calling new in C++.

But what is far better about the CLR is that it can pretty much tell you exactly what is causing a leak, although the technique is only documented on a few blog posts here and there. Also, they seem to be written by people who prefer using windbg. But after some fooling around, I've made it work in Visual Studio, which is a lot more convenient.

Run your program in the Visual Studio 2008 debugger, and get it into the state where you think something has leaked. Somehow make it break into the debugger in some CLR code. Then type the magic words into the Immediate Window.

These are the magic words:

.load C:\Windows\Microsoft.NET\Framework\v2.0.50727\sos.dll

GC.Collect()

!DumpHeap -type <some-type-name>

!gcroot <some-address>

The path to sos.dll varies. The way to find out the correct path is to look for mscorwks.dll in the Modules pane. Wherever that is loaded from is the correct path for sos.dll.

(There's supposed to be a command .loadby that would be easier to use, but it doesn't appear to exist in Visual Studio 2008 - this is the part that I didn't see documented anywhere).

The incantation GC.Collect() will force a garbage collection. If your object survives after that, then something is keeping it alive, and you want to know what.

First you need to know the type name of your object, including the namespace qualification. You use that !DumpHeap incantation to find instances of your object. Here's what good news looks like (i.e. no objects found):

!DumpHeap -type MyNamespace.MyCrazyClass
 Address       MT     Size
total 0 objects
Statistics:
      MT    Count    TotalSize Class Name
Total 0 objects

And here's what bad news looks like:

!DumpHeap -type MyNamespace.MyCrazyClass
 Address       MT     Size
02f768b0 06412a64      468     
02fcdba0 06412a64      468     
total 2 objects
Statistics:
      MT    Count    TotalSize Class Name
06412a64        2          936 MyNamespace.MyCrazyClass
Total 2 objects

So here I have two objects hanging around - why?

Note that the output above starts with a table of all the instances. The first column is the address of each object. You pass one of those addresses to !gcroot and it dumps out a trace of at least one route via which the object is being kept alive.

!gcroot 02f768b0

That is, starting from somewhere on the stack and working through all the objects that hold references to other objects, until it gets to your object.

Each line of the !gcroot output starts with the object address, so if you search for occurrences of your object's address, you may find more than one line that is the end of a route to your object. So it's useful to paste the output into notepad and insert line breaks after each of these lines, so you can see the separate routes.

Then from your object, work your way back to see who's keeping who alive.

The output starts with a warning:

Note: Roots found on stacks may be false positives. Run "!help gcroot" for more info.

So I just fix the issues that I can figure out the cause of, until the leak goes away. I figure this means that the things I didn't fix were false positives (which seems reasonable).