我希望将一个事件传递给一个辅助函数。这个函数将向事件附加一个方法。然而，我在正确传递事件方面遇到了麻烦。我尝试过传递EventHandler<TEventArgs>，它能编译通过，但是事件没有被附加（但仍然被添加；似乎是事件处理程序的副本被创建了）。
举例来说，如果我有这个：
public event EventHandler<EventArgs> MyEvent;
并且这个帮助函数：
public static void MyHelperFunction<TEventArgs>(EventHandler<TEventArgs> eventToAttachTo)
{
eventToAttachTo += (sender, e) => { Console.WriteLine("Hello world"); };
}
同时调用方：
MyHelperFunction(MyEvent);
MyEvent(null, new EventArgs()); // Does nothing.
+= 操作符应用于委托类型时会创建一个新的委托，该委托是旧委托和新委托结合而成的，它不会修改现有的委托，因此这就是为什么它不能正常工作的原因。
要使其正常工作，您需要通过引用传递委托。
public static void Helper(ref EventHandler<EventArgs> e)
{
e+= (x,y) => {};
}
这段代码在方法外运行正常的原因是 LHS 仍然是实际字段。因此，+= 将创建一个新的委托并分配回成员字段。
我刚刚想到了这个小帮手。如果它是你自己创建的事件，你可以使用这样的包装器。你可以像平常一样使用 += 操作符来附加处理程序，但是可以将包装器传递并甚至从其他地方触发事件。
public class GenericEvent<T> where T:EventArgs
{
public event EventHandler<T> Source = delegate { };
public void Raise(object sender, T arg = default(T))
{
Source(sender, arg);
}
public void Raise(T arg = default(T))
{
Source(this, arg);
}
public void AddHandler(EventHandler<T> handler)
{
Source += handler;
}
public void RemoveHandler(EventHandler<T> handler)
{
Source -= handler;
}
public static GenericEvent<T> operator +(GenericEvent<T> genericEvent, EventHandler<T> handler)
{
genericEvent.AddHandler(handler);
return genericEvent;
}
}
创建事件的方式如下：
public GenericEvent<EventArgs> MyEvent = new GenericEvent<EventArgs>();
附加处理程序：
MyEvent += (s,e) => {};
触发事件：
MyEvent.Raise();
虽然不太好，但您可以使用反射来完成此操作。
public EventMonitor(object eventObject, string eventName)
{
_eventObject = eventObject;
_waitEvent = eventObject.GetType().GetEvent(eventName);
_handler = new EventHandler(SetEvent);
_waitEvent.AddEventHandler(eventObject, _handler);
}
当 eventObject 是包含事件的对象，eventName 是事件的名称时，SetEvent 是您的事件处理程序。
我还有一个像这样的 dispose 方法：
public void Dispose()
{
_waitEvent.RemoveEventHandler(_eventObject, _handler);
}
public static void MyHelperFunction<TEventArgs>(ref EventHandler<TEventArgs> eventToAttachTo)
MyHelperFunction(ref MyEvent);
正如许多人指出的那样，将事件传递给方法要么不可能，要么不简单。
请澄清一下，但我怀疑您的预期用法将类似于：
void Register()
{
var super = new SuperHandler();
//not valid syntax:
super.HandleEvent(MyEvent1);
super.HandleEvent(MyEvent2);
super.HandleEvent(MyEvent3);
super.HandleEvent(MyEvent4);
}
您可以通过使您预期的通用事件处理程序公开访问（如果需要，也可以是内部访问）来轻松实现此目的：
public static class GenericHandler
{
public static void HandleAnyEvent(object sender, EventArgs e)
{
//handle
}
}
public class SomeClass
{
void RegisterEvents()
{
var r = new EventRaiser();
r.ImportantThingHappened += GenericHandler.HandleAnyEvent;
}
}
在此示例中，我的全捕获处理程序位于静态类中，但您也可以使用非静态类。 此外，我看到您在示例中使方法成为泛型（TEventArgs）。 由于所有EventHandler派生类（例如CancelEventHandler）都与基本EventHandler匹配，因此您不需要涉及泛型（也不会有帮助）。
如果注册逻辑复杂或必须保持EventHandler私有，请考虑使用接口事件。 这可能无法满足您减少代码量的预期目标，但它将允许您创建一个可以可预测地处理特定类型的所有事件的类。
interface IRaiseEvents
{
event EventHandler ConnectionCreated;
event EventHandler ConnectionLost;
}
public class SuperHandler
{
void RegisterEvents(IRaiseEvents raiser)
{
raiser.ConnectionCreated += (sender, args) => Console.WriteLine("Connected.");
raiser.ConnectionLost += (sender, args) => Console.WriteLine("Disconnected.");
}
}