GC with memory leaks?

  
public class WeakDelegate
{
	public WeakDelegate(Delegate d)
	{
		referance = new WeakReference(d);
	}

	public object Invoke(object[] args)
	{
		return ((Delegate referance.Target).DynamicInvoke(args);
	}

	private WeakReference referance;
}
  

  
using System;
using System.Reflection;
using System.Collections;

namespace /*NAMESPACE NAME HERE*/
{
	/// <summary>Delegate that will not prevent garbage collection</summary>

	public class WeakDelegate
	{
		/// <summary>Construct a WeakDelegate</summary>

		/// <param name="d">"Strong" Delegate to copy from</param>

		public WeakDelegate(Delegate d)
		{
			referance = new WeakReference(d.Target);
			methodName = d.Method.Name;
		}

		/// <summary>Construct a WeakDelegate</summary>

		/// <param name="o">Object to invoke method on</param>

		/// <param name="m">Method to invoke</param>

		public WeakDelegate(object obj, string methodName)
		{
			this.referance = new System.WeakReference(obj);
			this.methodName = methodName;
		}

		/// <summary>Call the method referanced by this WeakDelegate</summary>

		/// <param name="args">Arguments to pass called method</param>

		/// <returns>Results of method call</returns>

		public object Invoke(object[] args)
		{
			return referance.Target.GetType().InvokeMember(methodName, BindingFlags.InvokeMethod, null, referance.Target, args);
		}

		/// <summary>Determins if the object to invoke the method on is alive</summary>

		public bool IsAlive
		{ get { return referance.IsAlive; } }

		/// <summary>Compare WeakDelegates for equality</summary>

		/// <param name="obj">Compare this to "obj"</param>

		/// <returns>True if WeakDelegates are equivialent</returns>

		public override bool Equals(object obj)
		{
			if(obj == null || GetType() != obj.GetType())
				return false;
			WeakDelegate d = (WeakDelegate)obj;
			return ((this.referance.Target == d.referance.Target) && (this.methodName == d.methodName));
		}

		/// <summary>Get the hash code of this WeakReferance</summary>

		/// <returns>Hash code</returns>

		public override int GetHashCode()
		{
			return methodName.GetHashCode() + referance.Target.GetHashCode();
		}

		private string methodName;
		private WeakReference referance;
	}

	/// <summary>Multicast Delegate which does not prevent garbage collection</summary>

	public class WeakMulticastDelegate
	{
		/// <summary>Call all methods referanced by this WeakMulticastDelegate.

		/// Also removes any delegates that point to dead objects</summary>

		/// <param name="args">Arguments to pass all invoked methods</param>

		public void InvokeAll(object[] args)
		{
			WeakDelegate current;
			for(int i = 0; i < delegates.Count; i++)
			{
				current = delegates[i] as WeakDelegate;
				if(current.IsAlive)
					current.Invoke(args);
				else
				{
					delegates.RemoveAt(i);
					i--;
				}
			}
		}

		/// <summary>Add a WeakDelegate to the invokation list</summary>

		/// <param name="d">WeakDelegate to add</param>

		public void AddDelegate(WeakDelegate d)
		{
			delegates.Add(d);
		}

		/// <summary>Remove a WeakDelegate from the invokation list</summary>

		/// <param name="d">WeakDelegate to remove</param>

		public void RemoveDelegate(WeakDelegate d)
		{
			delegates.Remove(d);
		}

		private ArrayList delegates = new ArrayList(10);
	}
}