C#构造函数事件

我创建了一个类，当我通过表单创建employee对象时，我想给出一条消息

这是我的班级、活动和代表

public delegate void ctorDel(); 

class Employee
{
    private int empID;
    private string empName;

    public event ctorDel myEvent;

    public Employee(int empID,string empName)
    {
        this.empID = empID;
        this.empName = empName;

        **if (myEvent != null)
        {
            myEvent();
        }**
    }

形式上

  int id = Convert.ToInt16(textBox1.Text);
            string name = textBox2.Text;

            Employee emp = new Employee(id, name);
            emp.myEvent += new ctorDel(showMessage);

和功能

 public void showMessage()
        {
            MessageBox.Show("An employee is created");
        }

---

您将在构造函数已经运行之后附加事件。

在构造函数中引发实例事件没有意义，因为实例的初始化尚未完成，因此无法将任何处理程序附加到事件

但是，您可以创建一个静态事件：

public static event ctorDel myEvent;

...

Employee.myEvent += new ctorDel(showMessage);

---

（但不要每次创建

员工时都订阅该事件，否则处理程序将被调用的次数与实例的次数相同…
创建员工时可以传递处理程序：

private Employee(ctorDel construcEvent)
{
    if (construcEvent != null)
        this.myEvent += construcEvent;
}

public Employee(int empID,string empName, ctorDel construcEvent)
    : this(construcEvent)
{
    this.empID = empID;
    this.empName = empName;

    if (myEvent != null)
    {
        myEvent();
    }
}

然后：

Employee emp = new Employee(id, name, new ctorDel(showMessage));

你想达到什么目的？您尝试的方法不起作用的原因是，您正在将代理附加到ctor之后。一旦你给“新员工”打了电话，这个事件早就被解雇了

如果确实需要此类事件，请创建factory类：

public delegate void EmpCreated();
public EmployeeFactory {
  public event EmpCreated myEvent;
  public Employee Create(int empId, string empName){
    var result = new Employee(empId, empName);
    if(myEvent != null) myEvent();
    return result;
  }
}

订阅factory类上的事件，您将获得该事件。
订阅此事件时，实例已经构建。
我建议使用工厂模式来隐藏构造函数

class EmployeeFactory
{
     public Employee Create(int id, string name)
     {
         Employee instance = new Employee(id, name);

         var handler = EmployeeCreated;
         if (handler != null)
         {
              EmployeeEventArgs e = new EmployeeEventArgs(instance);
              handler(e);    
         }

         return instance;
     }

     public event EventHandler<EmployeeEventArgs>  EmployeeCreated;
}

实例构建：

  var emp = factory.Create(id, name);  

解决方案
这里有一个解决问题的通用方法

public class EventFactory
{
    public U Create<U, V>(V constructorArgs)
    {
        var instance = (U)Activator.CreateInstance(typeof(U), constructorArgs);
        OnCreated?.Invoke();
        return instance;
    }

    public delegate void CreatedEventHandler();
    public event CreatedEventHandler OnCreated;
}

公共类事件工厂
{
公共U创建（V构造函数args）
{
var instance=（U）Activator.CreateInstance（typeof（U），constructorArgs）；
OnCreated？.Invoke（）；
返回实例；
}
公共委托void CreatedEventHandler（）；
公共事件CreatedEventHandler OnCreated；
}

然后你就可以做了

var ef = new EventFactory();
ef.OnCreated += myEventHandler; 
var instance = ef.Create<Employee>(employeeArgs);

var ef=new EventFactory（）；
ef.OnCreated+=myEventHandler；
var instance=ef.Create（employeeArgs）；

.. 进一步
当需要传递事件参数或构造函数无参数时，可以调整我的代码以提供更大的灵活性。我还没有测试过它，但它应该看起来像

public class EventFactory<T>
{
    public U Create<U, V>(V constructorArgs, T eventArgs)
    {
        var instance = (U)Activator.CreateInstance(typeof(U), constructorArgs);
        OnCreated?.Invoke(eventArgs);
        return instance;
    }

    public U Create<U>(T eventArgs)
    {
        return Create<U, object>(null, eventArgs);
    }

    public delegate void CreatedEventHandler(T args);
    public event CreatedEventHandler OnCreated;
}

public class EventFactory
{
    public U Create<U, V>(V constructorArgs)
    {
        var instance = (U)Activator.CreateInstance(typeof(U), constructorArgs);
        OnCreated?.Invoke();
        return instance;
    }

    public U Create<U>() where U : new()
    {
        var instance = new U();
        OnCreated?.Invoke();
        return instance;
    }

    public delegate void CreatedEventHandler();
    public event CreatedEventHandler OnCreated;
}

公共类事件工厂
{
公共U创建（V构造函数args、T事件args）
{
var instance=（U）Activator.CreateInstance（typeof（U），constructorArgs）；
OnCreated？.Invoke（eventArgs）；
返回实例；
}
公共U创建（T事件参数）
{
返回Create（null，eventArgs）；
}
公共委托无效CreatedEventHandler（T参数）；
公共事件CreatedEventHandler OnCreated；
}
公共类事件工厂
{
公共U创建（V构造函数args）
{
var instance=（U）Activator.CreateInstance（typeof（U），constructorArgs）；
OnCreated？.Invoke（）；
返回实例；
}
公共U Create（），其中U:new（）
{
var实例=新的U（）；
OnCreated？.Invoke（）；
返回实例；
}
公共委托void CreatedEventHandler（）；
公共事件CreatedEventHandler OnCreated；
}
那么你的问题是什么？您在哪里遇到问题？myEvent将永远不会被解雇，因为它未设置在任何位置。没有人可以附加到事件，因此这毫无意义。我可以在employee构造函数中执行此操作吗？
public class EventFactory<T>
{
    public U Create<U, V>(V constructorArgs, T eventArgs)
    {
        var instance = (U)Activator.CreateInstance(typeof(U), constructorArgs);
        OnCreated?.Invoke(eventArgs);
        return instance;
    }

    public U Create<U>(T eventArgs)
    {
        return Create<U, object>(null, eventArgs);
    }

    public delegate void CreatedEventHandler(T args);
    public event CreatedEventHandler OnCreated;
}

public class EventFactory
{
    public U Create<U, V>(V constructorArgs)
    {
        var instance = (U)Activator.CreateInstance(typeof(U), constructorArgs);
        OnCreated?.Invoke();
        return instance;
    }

    public U Create<U>() where U : new()
    {
        var instance = new U();
        OnCreated?.Invoke();
        return instance;
    }

    public delegate void CreatedEventHandler();
    public event CreatedEventHandler OnCreated;
}