A GC API that would be convenient

Indeed integrating SOS is a bit complicated. But when we combine the ideas given by others, here is what will work:
1. Create a base class that will register itself on construction and deregister itself on finalization to a GarbageTracker.
2. Let types you want to track inherit from that base class (but only in test builds).
3. Implement a GarbageTracker that manages a list of WeakReference objects that point to the registered classes.

Here is a working example. It only seems to work in release builds and when ran outside the VS IDE.

Usage:

public class MyTrackableClass
#if TEST
: TrackableObject
#endif
{
}

static void Main()
{
var c = new MyTrackableClass();

int countBeforeCollect = GarbageTracker.GetAliveInstancesOf().Length;
Console.WriteLine(“alive instances: ” + countBeforeCollect);

GC.Collect(2);
GC.WaitForPendingFinalizers();
GC.Collect(2);
GC.WaitForPendingFinalizers();

int countAfterCollect = GarbageTracker.GetAliveInstancesOf().Length;
Console.WriteLine(“alive instances: ” + countAfterCollect);
}

// Implementation

public abstract class TrackableObject
{
private int reference;

public TrackableObject()
{
this.reference = GarbageTracker.StartTracking(this);
}

~TrackableObject()
{
if (this.reference != 0)
{
GarbageTracker.StopTracking(reference);
this.reference = 0;
}
}
}

public static class GarbageTracker
{
private static readonly Dictionary references;
private static readonly object locker = new object();

static GarbageTracker()
{
references = new Dictionary();
}

public static T[] GetAliveInstancesOf() where T : TrackableObject
{
lock (locker)
{
var instances =
from reference in references.Values
let instance = reference.TrackableObject
where instance is T
select (T)instance;

return instances.ToArray();
}
}

internal static int StartTracking(TrackableObject obj)
{
TrackableObjectReference reference = new TrackableObjectReference(obj);

Console.WriteLine(“Starting tracking: ” + reference.Id + “, ” + obj.ToString());

lock (locker)
{
references[reference.Id] = reference;
}

return reference.Id;
}

internal static void StopTracking(int reference)
{
lock (locker)
{
references.Remove(reference);
}

Console.WriteLine(“Stopped tracking: ” + reference);
}

class TrackableObjectReference
{
private static int GlobalCount = 0;
private WeakReference weakReference;
private readonly int id;

public TrackableObjectReference(TrackableObject obj)
{
this.id = Interlocked.Increment(ref GlobalCount);
this.weakReference = new WeakReference(obj);
}

public TrackableObject TrackableObject
{
get { return (TrackableObject)this.weakReference.Target; }
}

public int Id { get { return this.id; } }
}
}

Patrick, it doesn’t have to be a base class. It’s just more convenient that way.

Sasha, indeed WeakReference seems to be the good solution as long as it is not proposed by default be the .NET Fx.

The drawback of the implementation is that it requires InstanceTracker to be a base class, which doesn’t work in the general case. But still it is better than nothing and the community can benefit from your effort. Thanks!

Here here! This is something that would be really helpful in debugging scenarios and help cut down memory leaks in managed apps.

How about a list of WeakReference ? http://msdn.microsoft.com/en-us/library/system.weakreference.aspx

If you really need something like that, you can bake it into your objects using a finalizer that is compiled only into the Debug build and a static list that threads all the objects of the same type together.

Kristian, no I don’t want a debugger with manual intervention, I want to use some kind of contract like:
Debug.Assert(there is no rooted instances of the type T)

Tommy, I didn’t know that Smalltalk has that feature, good to know )

That sounds more like the job for a debugger or similar. I’ve used YourKit profiler (www.yourkit.com) to do things like what you want, it also gives you easy access to dependency graphs to find out what’s keeping your objects alive.