WeakReference

A weak reference lets you hold a reference to an object that will not prevent it from being garbage collected. There are a few scenarios where this might be important - such as listening for events, caching, various MVC patterns.

.NET and Java supports weak references with the aptly named WeakReference class. In .NET it exposes a .Target property of type object that weakly points to whatever you like.

Java also sports a generic WeakReference to give you a strongly typed version so it's somewhat puzzling why .NET doesn't.

Here is my attempt at a WeakReference for .NET. It works fine in the scenarios I've used and performance is close to the non-generic version but a quick glance at the SSCLI code for WeakReference reveals that the standard version is a little more complicated and it's possible there is a reason for that - most likely due to finalizer issues.

using System;
using System.Runtime.InteropServices;

public class WeakReference : IDisposable
{
private GCHandle handle;
private bool trackResurrection;

public WeakReference(T target)
: this(target, false)
{
}

public WeakReference(T target, bool trackResurrection) {
this.trackResurrection = trackResurrection;
this.Target = target;
}

~WeakReference() {
Dispose();
}

public void Dispose() {
handle.Free();
GC.SuppressFinalize(this);
}

public virtual bool IsAlive {
get { return (handle.Target != null); }
}

public virtual bool TrackResurrection {
get { return this.trackResurrection; }
}

public virtual T Target {
get {
object o = handle.Target;
if ((o == null) || (!(o is T)))
return default(T);
else
return (T)o;
}
set {
handle = GCHandle.Alloc(value,
this.trackResurrection ? GCHandleType.WeakTrackResurrection : GCHandleType.Weak);
}
}
}

I've allowed Target to be settable against my better judgement to bring it more in like with WeakReference. It's still not serializable though unlike WeakReference.

Reference URL: http://damieng.com/blog/2006/08/01/implementingweakreferencet