我知道活动始终与代表联系。但是，我缺少一些核心使用事件，并试图理解这一点。

我创建了一个简单的事件程序，如下图，和它的作品完美的罚款。

 命名空间CompleteRef3._0
{
委托无效someEventDelegate（）;

类EventTester
{
    公共事件someEventDelegate someEvent;

    公共无效doEvent（）
    {
        如果（！someEvent = NULL）someEvent（）;
    }

}

类节目
{
    静态无效EventHandler1（）
    {
        Console.WriteLine（事件处理函数1名为..）;
    }

    静态无效EventHandler2（）
    {
        Console.WriteLine（事件处理2名为..）;
    }
    静态无效EventHandler3（）
    {
        Console.WriteLine（事件处理函数3名为..）;
    }


    静态无效的主要（字串[] args）
    {
        EventTester EVT =新EventTester（）;
        evt.someEvent + = EventHandler1;
        evt.someEvent + = EventHandler2;
        evt.someEvent + = EventHandler3;
        evt.doEvent（）;
        Console.ReadKey（）;

    }
}
}
 

我取代了事件声明中使用委托。这是我更换了行的的公共事件someEventDelegate someEvent; 的是的 someEventDelegate someEvent; 的以上程序，我仍然得到同样的结果。现在，我很困惑，为什么我们需要使用活动，如果可以仅通过委托来实现。什么是真正的使用事件？

无事件修改后的方案如下 -

 命名空间CompleteRef3._0
{
委托无效someEventDelegate（）;

类EventTester
{
    someEventDelegate someEvent;

    公共无效doEvent（）
    {
        如果（！someEvent = NULL）someEvent（）;
    }

}

类节目
{
    静态无效EventHandler1（）
    {
        Console.WriteLine（事件处理函数1名为..）;
    }

    静态无效EventHandler2（）
    {
        Console.WriteLine（事件处理2名为..）;
    }
    静态无效EventHandler3（）
    {
        Console.WriteLine（事件处理函数3名为..）;
    }


    静态无效的主要（字串[] args）
    {
        EventTester EVT =新EventTester（）;
        evt.someEvent + = EventHandler1;
        evt.someEvent + = EventHandler2;
        evt.someEvent + = EventHandler3;
        evt.doEvent（）;
        Console.ReadKey（）;

    }
}
}
 

解决方案

当然，你可以使用，因为在幕后代表的事件是，包装一个委托的构建。

但使用事件，而不是代表的基本原理是一样的，使用领域的性质，而不是 - 的数据封装的。这是不好的做法，暴露领域（无论他们是 - 原始字段或委托）。直接

顺便说一句，您将委托​​场，使人们有可能在第二个片段之前错过了公开关键字。

另外一个的方式与第二个片段：对代表你应该使用 Delegate.Combine 而不是+ =

I know Events are always associated with Delegates. But, I am missing some core use of Events, and trying to understand that.

I created a simple Event program, as below, and it works perfectly fine.

namespace CompleteRef3._0
{
delegate void someEventDelegate();

class EventTester
{
    public event someEventDelegate someEvent;

    public void doEvent()
    {
        if (someEvent != null) someEvent();
    }

}

class Program
{
    static void EventHandler1()
    {
        Console.WriteLine("Event handler 1 called..");
    }

    static void EventHandler2()
    {
        Console.WriteLine("Event handler 2 called..");
    }
    static void EventHandler3()
    {
        Console.WriteLine("Event handler 3 called..");
    }


    static void Main(string[] args)
    {
        EventTester evt = new EventTester();
        evt.someEvent += EventHandler1;
        evt.someEvent += EventHandler2;
        evt.someEvent += EventHandler3;
        evt.doEvent();
        Console.ReadKey();

    }
}
}

I replaced the event declaration with delegates. That is I replaced the line public event someEventDelegate someEvent; with someEventDelegate someEvent; on the above program, and I still get the same result. Now, I was confused why we need to use Events, if it can be achieved by Delegates only. What is the real use of Events?

The modified program without events is as below -

namespace CompleteRef3._0
{
delegate void someEventDelegate();

class EventTester
{
    someEventDelegate someEvent;

    public void doEvent()
    {
        if (someEvent != null) someEvent();
    }

}

class Program
{
    static void EventHandler1()
    {
        Console.WriteLine("Event handler 1 called..");
    }

    static void EventHandler2()
    {
        Console.WriteLine("Event handler 2 called..");
    }
    static void EventHandler3()
    {
        Console.WriteLine("Event handler 3 called..");
    }


    static void Main(string[] args)
    {
        EventTester evt = new EventTester();
        evt.someEvent += EventHandler1;
        evt.someEvent += EventHandler2;
        evt.someEvent += EventHandler3;
        evt.doEvent();
        Console.ReadKey();

    }
}
}

Sure, you can use delegates because behind the scenes an event is a construct that wraps a delegate.

But the rationale of using events instead of delegates is the the same as for using properties instead of fields - data encapsulation. It's bad practice to expose fields (whatever they are - primitive fields or delegates) directly.

By the way, you missed a public keyword before your delegate field to make it possible in the second snippet.

Another "by the way" with the second snippet: for delegates you should use Delegate.Combine instead of "+=".