具有LINQ和委托约束的WeakEventHandler

Question

How can a C# generic weak event handler be made for predefined system events using LINQ? Solution 4 of Daniel Grunwald's article on Weak Events in C# shows a reusable wrapper, ie

eventWrapper = WeakEventHandler.Register(
    eventSource,
    (s, eh) => s.Event += eh, // registering code
    (s, eh) => s.Event -= eh, // deregistering code
    this, // event listener
    (me, sender, args) => me.OnEvent(sender, args) // forwarding code
);

However, an attempt to apply this to a generic event such as the UnhandledExceptionHandler results in a compile error: Cannot implicitly convert type 'System.EventHandler' to 'System.UnhandledExceptionEventHandler' .

        WeakEventHandler.Register(AppDomain.CurrentDomain, 
            (s, eh) => s.UnhandledException += eh, 
            (s, eh) => s.UnhandledException -= eh, 
            this, 
            (me, sender, ea) => me.UnhandledExceptionHandler(sender, ea));

ConvertTo in Jacob Carpenter's article on Delegate Conversion may provide a clue, but I currently do not see how to use that with Daniel Grunwald's code.

Answer 1

I am not familiar with what you are trying to do here but I did experiment some to get this to compile.

WeakEventHandler can work with either EventHandler or EventHandler<TEventArgs> . The signature for an event handler of EventHandler<UnhandledExceptionEventArgs> matches the signature for UnhandledExceptionEventHandler .

Because the 2 signatures are identical, we can convert one to the other using the TransformHandler function below.

public static UnhandledExceptionEventHandler TransformHandler(EventHandler<UnhandledExceptionEventArgs> handler)
{
    return new UnhandledExceptionEventHandler(handler);
}

WeakEventHandler<UnhandledExceptionEventArgs>.Register(
    AppDomain.CurrentDomain,
    (s, eh) => s.UnhandledException += TransformHandler(eh),
    (s, eh) => s.UnhandledException -= TransformHandler(eh),
    this,
    (me, sender, ea) => me.UnhandledExceptionHandler(sender, ea)
);

You will have to try this out and see if it actually works for what you need.

Answer 2

Combining CastDelegate as ConvertDelegate into WeakEventHandler did the trick.

/// <summary>
/// Helper class to add weak handlers to events of predefined event handler, i.e. PropertyChagnedEventHandler
/// </summary>
public static class WeakEventHandler<TEventHandler, TEventArgs>
    where TEventHandler : class // delegate
    // where TEventArgs : EventArgs // work with structs not derived from EventArgs, i.e. DependencyPropertyChangedEventArgs
{
    /// <summary>
    /// Registers an predefined event handler that works with a weak reference to the target object.
    /// Access to the event and to the real event handler is done through lambda expressions.
    /// The code holds strong references to these expressions, so they must not capture any
    /// variables!
    /// </summary>
    /// </example>
    public static WeakEventHandler Register<TEventSource, TEventListener>(
        TEventSource senderObject,
        Action<TEventSource, TEventHandler> registerEvent,
        Action<TEventSource, TEventHandler> deregisterEvent,
        TEventListener listeningObject,
        Action<TEventListener, object, TEventArgs> forwarderAction
    )
        where TEventSource : class
        where TEventListener : class
    {
        if (senderObject == null)  throw new ArgumentNullException("senderObject");
        if (listeningObject == null)  throw new ArgumentNullException("listeningObject");
        WeakEventHandler.VerifyDelegate(registerEvent, "registerEvent");
        WeakEventHandler.VerifyDelegate(deregisterEvent, "deregisterEvent");
        WeakEventHandler.VerifyDelegate(forwarderAction, "forwarderAction");

        WeakEventHandler weh = new WeakEventHandler(listeningObject);
        TEventHandler eh = MakeDeregisterCodeAndWeakEventHandler(weh, senderObject, deregisterEvent, forwarderAction);
        registerEvent(senderObject, eh);
        return weh;
    }

    static TEventHandler MakeDeregisterCodeAndWeakEventHandler
        <TEventSource, TEventListener>
        (
            WeakEventHandler weh,
            TEventSource senderObject,
            Action<TEventSource, TEventHandler> deregisterEvent,
            Action<TEventListener, object, TEventArgs> forwarderAction
        )
        where TEventSource : class
        where TEventListener : class
    {
        Action<object, TEventArgs> eventHandler = (sender, args) =>
        {
            TEventListener listeningObject = (TEventListener)weh.listeningReference.Target;
            if (listeningObject != null) forwarderAction(listeningObject, sender, args);
            else weh.Deregister();
        };

        weh.deregisterCode = delegate
        {
            deregisterEvent(senderObject, ConvertDelegate(eventHandler));
        };

        return ConvertDelegate(eventHandler);
    }

    static TEventHandler ConvertDelegate(Delegate source)
    {
        if (source == null) return null;
        Delegate[] delegates = source.GetInvocationList();
        if (delegates.Length == 1) return Delegate.CreateDelegate(typeof(TEventHandler), delegates[0].Target, delegates[0].Method) as TEventHandler;
        for (int i = 0; i < delegates.Length; i++) delegates[i] = Delegate.CreateDelegate(typeof(TEventHandler), delegates[i].Target, delegates[i].Method);
        return Delegate.Combine(delegates) as TEventHandler;
    }
}

Example usage witih PropertyChangedEventHandler would be as follows:

WeakEventHandler<PropertyChangedEventHandler, PropertyChangedEventArgs>.Register(
    textDocument,
    (d, eh) => d.PropertyChanged += eh,
    (d, eh) => d.PropertyChanged -= eh,
    this,
    (me, sender, args) => me.OnPropertyChanged(sender, args)
    );