An implemention of WeakEvent pattern for WPF/Silverlight/Windows Phone

public class Program
{
    public static void Main(string[] args)
    {
        Program A = new Program();
 
        var oldR = new WeakReference(new ReceiverOld(A));
        var newR = new WeakReference(new ReceiverNew(A));
 
        A.RaiseTestEvent(); //First
 
        //Exec GC
        GC.Collect();
        GC.WaitForPendingFinalizers();
        GC.Collect();
 
        A.RaiseTestEvent(); //Second
 
        //--Result --
        //
        // ReceiverOld Received !
        // ReceiverNew Received !
        // ReceiverOld Received !
        //
 
        Console.ReadLine();
    }
 
    private void RaiseTestEvent()
    {
        var handler = TestEvent;
        if (handler != null)
        {
            handler(this, new RoutedEventArgs());
        }
    }
 
    public event RoutedEventHandler TestEvent;
}
 
//Normal Event Receiver Class
public class ReceiverOld
{
    public ReceiverOld(Program b)
    {
        b.TestEvent += OnTestEvent;
    }
 
    void OnTestEvent(object sender, RoutedEventArgs e)
    {
        Console.WriteLine("ReceiverOld Received ! ");
    }
}
 
//Event Receiver Class With LivetWeakEventListener
public class ReceiverNew
{
    LivetWeakEventListener _listener;//strong reference of listener
 
    public ReceiverNew(Program b)
    {
        _listener = new LivetWeakEventListener(
            h = > new RoutedEventHandler(h),//h is EventHandler
            h = > b.TestEvent += h, //h is RoutedEventHandler
            h = > b.TestEvent -= h, //h is RoutedEventHandler
            OnTestEvent);
    }
 
    void OnTestEvent(object sender, System.Windows.RoutedEventArgs e)
    {
        Console.WriteLine("ReceiverNew Received ! ");
    }
}

public class LivetWeakEventListener : IDisposable where TEventArgs : EventArgs
{
    private bool _disposed = false;
 
    private EventHandler _handler;
    private THandler _resultHandler;
    private Action _remove;
 
    private static void ReceiveEvent(WeakReference listenerWeakReference, object sender, TEventArgs args)
    {
        var listener = listenerWeakReference.Target as LivetWeakEventListener;
 
        if (listener != null)
        {
            var handler = listener._handler;
 
            if (handler != null)
            {
                handler(sender, args);
            }
        }
    }
 
    private static THandler GetStaticHandler(WeakReference listenerWeakReference, Func, THandler> conversion)
    {
        return conversion((sender, e) = > ReceiveEvent(listenerWeakReference, sender, e));
    }
 
    public LivetWeakEventListener(Func, THandler> conversion, Action add, Action remove, EventHandler handler)
    {
        if (conversion == null) throw new ArgumentNullException("conversion");
        if (add == null) throw new ArgumentNullException("add");
        if (remove == null) throw new ArgumentNullException("remove");
        if (handler == null) throw new ArgumentNullException("handler");
 
        _handler = handler;
        _remove = remove;
 
        _resultHandler = GetStaticHandler(new WeakReference(this), conversion);
 
        add(_resultHandler);
    }
 
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
 
    protected virtual void Dispose(bool disposing)
    {
        if (_disposed) return;
 
        if (disposing)
        {
            _remove(_resultHandler);
        }
        _disposed = true;
    }
}