“答案”
（如果您想了解我是如何得到这个解决方案的，请阅读下文）
用法，给定一个带有普通MouseDown 事件和特定EventHandler<ValueEventArgs> ValueEvent 事件的控件：
// for 'vanilla' events
SetAnyHandler<Subscriber, MouseEventHandler, MouseEventArgs>(
h => (o,e) => h(o,e), //don't ask me, but it works*.
h => control.MouseDown += h,
h => control.MouseDown -= h,
subscriber,
(s, e) => s.DoSomething(e)); //**See note below
// for generic events
SetAnyHandler<Subscriber, ValueEventArgs>(
h => control.ValueEvent += h,
h => control.ValueEvent -= h,
subscriber,
(s, e) => s.DoSomething(e)); //**See note below
（*这是来自Rx 的解决方法）
(** 避免在此处直接调用订阅者对象很重要（例如，如果我们在订阅者类中，则放置subscriber.DoSomething(e) 或直接调用DoSomething(e)。这样做有效地创建了对订阅者，这完全击败了对象...）
注意：在某些情况下，这可以在内存中留下对为 lambdas 创建的包装类的引用，但它们只对字节进行加权，所以我不会太在意。
实施：
//This overload handles any type of EventHandler
public static void SetAnyHandler<S, TDelegate, TArgs>(
Func<EventHandler<TArgs>, TDelegate> converter,
Action<TDelegate> add, Action<TDelegate> remove,
S subscriber, Action<S, TArgs> action)
where TArgs : EventArgs
where TDelegate : class
where S : class
{
var subs_weak_ref = new WeakReference(subscriber);
TDelegate handler = null;
handler = converter(new EventHandler<TArgs>(
(s, e) =>
{
var subs_strong_ref = subs_weak_ref.Target as S;
if(subs_strong_ref != null)
{
action(subs_strong_ref, e);
}
else
{
remove(handler);
handler = null;
}
}));
add(handler);
}
// this overload is simplified for generic EventHandlers
public static void SetAnyHandler<S, TArgs>(
Action<EventHandler<TArgs>> add, Action<EventHandler<TArgs>> remove,
S subscriber, Action<S, TArgs> action)
where TArgs : EventArgs
where S : class
{
SetAnyHandler<S, EventHandler<TArgs>, TArgs>(
h => h, add, remove, subscriber, action);
}
细节
我的出发点是Egor 的出色回答（有关带有 cmets 的版本，请参阅链接）：
public static void Link(Publisher publisher, Control subscriber) {
var subscriber_weak_ref = new WeakReference(subscriber);
EventHandler<ValueEventArgs<bool>> handler = null;
handler = delegate(object sender, ValueEventArgs<bool> e) {
var subscriber_strong_ref = subscriber_weak_ref.Target as Control;
if (subscriber_strong_ref != null) subscriber_strong_ref.Enabled = e.Value;
else {
((Publisher)sender).EnabledChanged -= handler;
handler = null;
}
};
publisher.EnabledChanged += handler;
}
困扰我的是事件被硬编码到方法中。所以这意味着对于每个新事件，都有一个新方法可以编写。
我摸索着想出了这个通用的解决方案：
private static void SetAnyGenericHandler<S, T>(
Action<EventHandler<T>> add, //to add event listener to publisher
Action<EventHandler<T>> remove, //to remove event listener from publisher
S subscriber, //ref to subscriber (to pass to action)
Action<S, T> action) //called when event is raised
where T : EventArgs
where S : class
{
var subscriber_weak_ref = new WeakReference(subscriber);
EventHandler<T> handler = null;
handler = delegate(object sender, T e)
{
var subscriber_strong_ref = subscriber_weak_ref.Target as S;
if(subscriber_strong_ref != null)
{
Console.WriteLine("New event received by subscriber");
action(subscriber_strong_ref, e);
}
else
{
remove(handler);
handler = null;
}
};
add(handler);
}
但是该解决方案的问题在于它只是通用的，它无法处理标准的 winforms MouseUp、MouseDown 等...
所以我试着让它更更通用：
private static void SetAnyHandler<T, R>(
Action<T> add, //to add event listener to publisher
Action<T> remove, //to remove event listener from publisher
Subscriber subscriber, //ref to subscriber (to pass to action)
Action<Subscriber, R> action)
where T : class
{
var subscriber_weak_ref = new WeakReference(subscriber);
T handler = null;
handler = delegate(object sender, R e) //<-compiler doesn't like this line
{
var subscriber_strong_ref = subscriber_weak_ref.Target as Subscriber;
if(subscriber_strong_ref != null)
{
action(subscriber_strong_ref, e);
}
else
{
remove(handler);
handler = null;
}
};
remove(handler);
}
但是，正如我所暗示的 here，这不会编译，因为无法将 T 限制为代表。
那时，我几乎放弃了。试图与 C# 规范抗争是没有意义的。
不过，昨天我从Reactive框架中发现了Observable.FromEvent方法，我没有实现，但是用法好像有点熟悉，很有趣：
var mousedown = Observable.FromEvent<MouseEventHandler, MouseDownEventArgs>(
h => new MouseEventHandler(h),
h => control.MouseDown += h,
h => control.MouseDown -= h);
这是引起我注意的第一个论点。这是缺少委托类型约束的解决方法。我们通过传入将创建委托的函数来获取它。
将所有这些放在一起为我们提供了此答案顶部显示的解决方案。
事后考虑
我完全建议花时间了解反应式框架（或任何它最终被称为的框架）。这很有趣，而且有点令人兴奋。我怀疑它也会使这样的问题变得完全多余。
到目前为止，我看到的最有趣的东西是Channel9 上的视频。