Hardly a memory leak.  This is, as the OP suggested, a reference problem.
The GC can hardly be expected to recycle an object where all references
weren't disposed.

The override of the Dispose method that you suggest is not a workaround...
it is the expectation.  It is normal and expected that a developer who
creates references to an object will be responsible for cleaning them up.

That said, I wonder if the problem isn't easier to handle by seperating the
connection to the UI from the business object itself.

In other words, the object that presents the event should be a seperate
object from the one that holds the data.  When the form closes, the object
can be disposed of as well, thus dropping all references to the form.  This
is a little more in keeping with the notion of Model-View-Controller in that
each object can have an object-level controller that ties the model to the
view.  When the view is disposed, the controller can be tossed and a new one
created for a new view.

Therefore,
when a data item is created, add it to a singleton list where it can be
retrieved.

when a form is opened...
  create a new controller for the data item
  pass a reference to the data item into the controller
  attach the event handler for the controller to the form.

when a form is closed, dispose of the controller as well.
  The controller will drop and therefore, the reference to the form will
drop as well.  However, the data will not be dropped because the singleton
list still points to it.

HTH,

nice paper!!

I just write a simplified class according to their idea ;)

public abstract class WeakContainer<T> : WeakReference
{
   public WeakContainer(object target, EventHandler<T> _delegate)
       : base(_delegate)
   {}

   public void EventHandler(object sender, T eventArgs)
   {
       EventHandler<T> eh = (EventHandler<T>)Target;
       if (eh != null)
           eh(sender, eventArgs);
       else
           Unregister(sender);
   }

   /// <summary>
   /// unregister from the event here
   /// </summary>
   /// <param name="sender">the object sending the event</param>
   abstract void Unregister(object sender);
}

here is a correct version of a nice, leaner implementation (the previous one didn't compile, hum ... )

public abstract class WeakContainer<T> : WeakReference where T : EventArgs
{
   public WeakContainer(object target, EventHandler<T> _delegate)
       : base(_delegate)
   {
   }

   public void EventHandler(object sender, T eventArgs)
   {
       EventHandler<T> eh = (EventHandler<T>)Target;
       if (eh != null)
           eh(sender, eventArgs);
       else
           Unregister(sender);
   }

   /// <summary>
   /// unregister from the event here
   /// </summary>
   /// <param name="sender">the object sending the event</param>
   public abstract void Unregister(object sender);
}