博客

事件接受与发送是通过 委托来实现的，随意，在学习事件之前一定要知道委托。

首先我们先看下图：

上的图不完整人，但大概是这个意思。

我们要创建一个事件管理。 来处理发布者发送消息和订阅者的接受消息中间转接。

然后订阅者去创建监听消息，然后，发布者再去触发事件。事件管理就会向所有监听该事件的订阅者去发布消息。当订阅者监听到消息后，会对其做一些相关的操作。大概就是这么个意思。

然后，我们开始写代码吧。首先，我们要去创建事件管理，其实就是一个委托，但创建的时候需要添加 关键字 event。

public delegate void EventManager();
class EventClass
{
    private static EventClass _instance;
    public static EventClass Instance
    {
        get
        {
            if (_instance == null)
                _instance = new EventClass();
            return _instance;
        }
    }

    // 创建一个事件管理对象
    private event EventManager eventManager;
    public void AddEventListener(EventManager arge)
    {
        eventManager += arge;
    }

    public void RemoveEventListener(EventManager arge)
    {
        eventManager -= arge;
    }

    public void DispatchEvent()
    {
        eventManager();
    }
}

我们创建了一个委托类型 EventManager 然后在 EventClass 类中创建了 添加 事件的方法 AddEventListener 移除监听事件 RemoveEventListener 和 分发事件 DispatchEvent

。当订阅者监听是后，就会去调用 AddEventListener 函数如下：

class EventClass1 
{
   public void PrintLog()
   {
       Console.WriteLine("EventClass1__PrintLog");
   }
}



EventClass1 event1 = new EventClass1();
EventClass.Instance.AddEventListener(event1.PrintLog);

这个时候，委托变量 eventManager 就会记录 event1 对象中的 PrintLog 函数正在监听着事件。当其他函数去执行 DispatchEvent 分发事件函数时，eventManager 会调用每一个监听事件函数。完整代码如下：

public delegate void EventManager();
 class EventClass
 {
     private static EventClass _instance;
     public static EventClass Instance
     {
         get
         {
             if (_instance == null)  
                 _instance = new EventClass();
             return _instance;
         }
     }

     // 创建一个事件管理对象
     private event EventManager eventManager;
     public void AddEventListener(EventManager arge)
     {
         eventManager += arge;
     }

     public void RemoveEventListener(EventManager arge)
     {
         eventManager -= arge;
     }

     public void DispatchEvent()
     {
         eventManager();
     }
 }

 class EventClass1 
 {
     public void PrintLog()
     {
         Console.WriteLine("EventClass1__PrintLog");
     }
 }

 class EventClass2
 {
     public void PrintLog2()
     {
         Console.WriteLine("EventClass2_PrintLog2");
     }
 }

 class Program
 {
     static void Main(string[] args)
     {
         EventClass1 event1 = new EventClass1();
         EventClass2 event2 = new EventClass2();

         EventClass.Instance.AddEventListener(event1.PrintLog);
         EventClass.Instance.AddEventListener(event2.PrintLog2);

         // 调用分发事件函数
         EventClass.Instance.DispatchEvent();
         Console.ReadKey();
     }
 }

运行结果如下：

EventClass1__PrintLog

EventClass2_PrintLog2

在这里创建事件委托的还可以使用 event 关键字简化

 public event EventManager eventManager;

// 创建一个事件管理对象
 //private EventManager eventManager;
 //public void AddEventListener(EventManager arge)
 //{
 //    eventManager += arge;
 //}

 //public void RemoveEventListener(EventManager arge)
 //{
 //    eventManager -= arge;
 //}

这样的话，就可以直接 使用 “+=” 方式来进行监听事件

EventClass.Instance.eventManager += event1.PrintLog;
EventClass.Instance.eventManager += event2.PrintLog2;

看完整的代码

public delegate void EventManager();
class EventClass
{
    private static EventClass _instance;
    public static EventClass Instance
    {
        get
        {
            if (_instance == null)  
                _instance = new EventClass();
            return _instance;
        }
    }

    public event EventManager eventManager;
    public void DispatchEvent()
    {
        eventManager();
    }
}

class EventClass1 
{
    public void PrintLog()
    {
        Console.WriteLine("EventClass1__PrintLog");
    }
}

class EventClass2
{
    public void PrintLog2()
    {
        Console.WriteLine("EventClass2_PrintLog2");
    }
}

class Program
{
    static void Main(string[] args)
    {
        EventClass1 event1 = new EventClass1();
        EventClass2 event2 = new EventClass2();

        EventClass.Instance.eventManager += event1.PrintLog;
        EventClass.Instance.eventManager += event2.PrintLog2;

        // 调用分发事件函数
        EventClass.Instance.DispatchEvent();
        Console.ReadKey();
    }
}

其实系统有给我们创建通用的事件委托 EventHandler，这样的话，我们就不需要自己定义委托了。直接可以使用通用委托来定义。在我们传递监听参数时就需要传递参数，带上两个参数。object 和 EventArgs 而输出的时候，也需要带上参数第一个就是委托所在类本身，第二个没有参数，可以传 null

public event EventHandler eventManager;

 //public void PrintLog()
 //{
 //    Console.WriteLine("EventClass1__PrintLog");
 //}

 public void PrintLog(object source, EventArgs e)
 {
     Console.WriteLine("EventClass1__PrintLog");
 }

```csharp
public void DispatchEvent()
{
     if (eventManager != null)
         eventManager(this, null);
 }

其他的基本上不用变化。输出还是一样的。

在使用通用委托时，有两个参数，其中 EventArgs 是可以传递参数的，但是要传递参数的话，必须继承 EventArgs 类来储存内容才能使用。而我们的委托也要用泛型委托。具体看下面代码：

public class EventArgsTest : EventArgs
{
     public int TestNum { get; set; }
 }

 class EventClass
 {
     private static EventClass _instance;
     public static EventClass Instance
     {
         get
         {
             if (_instance == null)
                 _instance = new EventClass();
             return _instance;
         }
     }

     public event EventHandler<EventArgsTest> eventManager;
     public void DispatchEvent()
     {
         EventArgsTest e = new EventArgsTest();
         e.TestNum = 10;
         if (eventManager != null)
             eventManager(this, e);
     }
 }

 class EventClass1
 {
     public void PrintLog(object source, EventArgsTest e)
     {
         Console.WriteLine("EventClass1__PrintLog = {0}", e.TestNum);
     }
 }

 class EventClass2
 {
     public void PrintLog2(object source, EventArgsTest e)
     {
         Console.WriteLine("EventClass2_PrintLog2 = {0}", e.TestNum);
     }
 }

 class Program
 {
     static void Main(string[] args)
     {
         EventClass1 event1 = new EventClass1();
         EventClass2 event2 = new EventClass2();

         EventClass.Instance.eventManager += event1.PrintLog;
         EventClass.Instance.eventManager += event2.PrintLog2;

         // 调用分发事件函数
         EventClass.Instance.DispatchEvent();
         Console.ReadKey();
     }
 }