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<T> to give you a strongly typed version so it's somewhat puzzling why .NET doesn't.

Here is my attempt at a WeakReference<T> 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<T> : 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.

[)amien