是否可以一次将相同的方法分配给多个委托？
public class Hoge
{
public event Action EventA;
public event Action EventB;
public event Action EventC;
public Hoge()
{
EventA += () => FugaMethod();
EventB += () => FugaMethod();
EventC += () => FugaMethod();
}
private void FugaMethod()
{
Console.WriteLine("Hello.");
}
}
我想简化 FugaMethod() 的分配。
因为事件不能作为参数......不幸的是......没有
如果我们谈论的是一大堆事件，反思将是要走的路……但我不会真正称之为“简化”
编辑：
为了澄清：
您可以作为参数传递的内容：
当前附加到特定对象上的静态或特定事件的事件处理程序列表（在这种情况下传递的不是事件，而是 a MulticastDelegate）
您不能作为参数传递的内容：事件本身...
您无法以允许附加另一个事件处理程序的直接方式传递事件……因为您可能希望传递特定的对象实例、EventInfo描述事件本身和新的处理程序。 ..
关于“简化”：
你需要做的是：
- 使用反射获取EventInfo所需事件的对象 - 对于每个实例和每个 EventInfo 调用 EventInfo.AddEventHandler，将实例作为目标传递，将事件处理程序作为处理程序传递
由于您无法将事件作为参数传递，因此您无法提取简单且类型安全的方法来获取所需的 EventInfo 对象。您将不得不按名称使用某些选择，或使用 Type.getEvent 或 Type.getEvents 将实例类型分开的其他逻辑
所以，如果你没有处理大量的事件，比如几百个，像你一样写它似乎是最好的方法……反射方法不会更简单或更短
有一种方法可以一次分配多个事件处理程序，不需要反射，但它不是微不足道的，并且需要一些编程。如果你想在循环中初始化它们，你可以使用字典来存储你的事件。
附带说明：按照惯例，event仅当委托类型为 时才应使用关键字EventHandler。当其他人尝试使用它时，它可能会而且很可能会混淆。
Hoge班级：
public class Hoge
{
// A dictionary to store your events.
private Dictionary<string, EventHandler> events = new Dictionary<string, EventHandler>()
{
{ "EventA", null },
{ "EventB", null },
{ "EventC", null }
};
// Event add/remove accessors.
public event EventHandler EventA
{
add
{
lock (events)
{
events["EventA"] += (EventHandler)events["EventA"] + value;
}
}
remove
{
lock (events)
{
events["EventA"] += (EventHandler)events["EventA"] - value;
}
}
}
// You can do the same for other events.
public event EventHandler EventB;
public event EventHandler EventC;
public Hoge()
{
// Initialize events in a loop.
foreach (var key in events.Keys.ToList())
{
events[key] += FugaMethod;
}
}
// Raises EventA.
public void RaiseEventA()
{
EventHandler handler;
if (null != (handler = (EventHandler)events["EventA"]))
{
handler(this, EventArgs.Empty);
}
}
// Event handler.
private void FugaMethod(object sender, EventArgs e)
{
Console.WriteLine("Hello.");
}
}
用法：
class Program
{
static void Main(string[] args)
{
new Hoge().RaiseEventA();
}
}