'答案
（如果您想了解我如何找到这个解决方案，请阅读下面的更多内容）
用法，给定一个香草对照MouseDown事件，以及具体的EventHandler<ValueEventArgs> ValueEvent event:
// 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 类中，则放置subscriber.DoSomething(e)，或者直接调用 DoSomething(e)。这样做有效地创建了对订阅者的引用，该引用完全击败物体...）
Note：在某些情况下，这可以在内存中留下对为 lambda 创建的包装类的引用，但它们只计算字节，所以我不太担心。
执行：
//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的出色答案（请参阅带评论的版本链接）：
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 等...
所以我试着让它变得均匀more通用的：
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.
