我不明白纯委托和事件字段之间的区别

Question

代表：我明白了。 但是当我搬到活动时，很多事情我都不太了解。 我在网上读过书，MSDN和一些简单的例子，它们都有相同的结构。 例如，这是链接： 事件示例

我拿第一个例子，作者说这是关于C＃事件最简单的例子。

这是他的代码：

public class Metronome
{
    public event TickHandler Tick;
    public EventArgs e = null;
    public delegate void TickHandler(Metronome m, EventArgs e);
    public void Start()
    {
        while (true)
        {
            System.Threading.Thread.Sleep(3000);
            if (Tick != null)
            {
                Tick(this, e);
            }
        }
    }
}

public class Listener
{
    public void Subscribe(Metronome m)
    {
        m.Tick += new Metronome.TickHandler(HeardIt);
    }
    private void HeardIt(Metronome m, EventArgs e)
    {
        System.Console.WriteLine("HEARD IT");
    }
}

class Test
{
    static void Main()
    {
        Metronome m = new Metronome();
        Listener l = new Listener();
        l.Subscribe(m);
        m.Start();
    }
}

你可以注意到line： public event TickHandler Tick 。 当我更改为public TickHandler Tick ，程序仍然运行相同。 但我理解新线，因为它只是一个纯粹的代表。

所以，我的问题是： event关键字的真正目的是什么： public event TickHandler Tick 。 这非常重要，因为所有示例总是这样使用，但我无法解释原因。

谢谢 ：）

Answer 1

代表和事件是相关的概念，但它们不是一回事。 “代表”一词往往有两个含义（经常被掩盖）：

• 委托类型 ，类似于单个方法接口。 （存在显着差异，但这是一个合理的起点。）
• 通常通过方法组创建的该类型的实例 ，以便在“调用”委托时调用该方法。

事件既不是那些事件。 它是一种类型的成员 - 一对添加/删除方法，让代理人订阅或取消订阅该事件。 使用foo.SomeEvent += handler;时使用add和remove方法foo.SomeEvent += handler; 或者foo.SomeEvent -= handler; 。

这非常类似于属性实际上是一对get / set方法（或者可能只是两者中的一个）。

当您声明类似字段的事件时 ：

public event TickHandler Tick;

编译器将成员添加到您的类中， 有点像这样：

private TickHandler tick;

public event TickHandler
{
    add { tick += value; }
    remove { tick -= value; }
}

它比这复杂一点，但这是基本的想法 - 它是一个简单的事件实现，就像一个自动实现的属性。 从类中，您可以访问支持字段，而在课外，您最终只会使用该事件。

我个人认为很遗憾，类似字段的事件的声明看起来非常像委托类型的字段 - 它导致一些答案中发现的一些误导性（IMO）语句，就像event关键字“修改“一个字段声明 - 实际上它意味着你宣布一些完全不同的东西。 我认为，如果类似字段的事件看起来更像是自动实现的属性，那就更清楚了

// Not real C#, but I wish it were...
public event TickHandler Tick { add; remove; }

我有一篇文章更详细，你可能会发现它很有用。

Answer 2

event关键字基本上限制了对delegate的操作。 您不能再使用=运算符手动分配它。

您只能逐个 添加 （使用+= ）或从事件中删除 （使用-= ）委托。 这样做是为了防止某些订户“覆盖”其他订阅。

因此，你做不到： m.Tick = new Metronome.TickHandler(HeardIt)

Answer 3

“ event ”是一个修饰语。 有什么好处？

1. 您可以在界面中使用事件
2. 只有声明它的类才能调用事件
3. 事件暴露了一个add和remove访问器，您可以覆盖它并执行自定义的东西
4. 事件将您限制为已分配方法SomeMethod(object source, EventArgs args)的特定签名，它为您提供有关该事件的其他信息。

Answer 4

你是对的 - event关键字的添加似乎几乎是多余的。 但是，作为事件的字段和键入纯委托的字段之间存在关键区别。 使用event关键字意味着包含对象外部的对象可以订阅委托，但是它们不能调用它。 删除event关键字时，外部对象可以订阅并调用委托（可见性允许）。

Answer 5

向程序添加侦听器时，添加事件而不是委托

看你的代码m.Tick + =

你看到那个部分你正在要求属性（类型事件），你正在添加一个带有+ =的监听器。 现在，您只能向Tick属性添加TickHandler类型，如果您覆盖它，则必须使用与TickHandler相同的格式。

就像添加到字符串或int时一样。

string stringTest = string.Empty;
stringTest += "this works";
stringTest += 4; //this doesn't though
int intTest = 0;
intTest += 1; //works because the type is the same
intTest += "This doesn't work";
Metronome m = new Metronome();
Metronome.TickHandler myTicker = new Metronome.TickHandler(function);
m.Tick += myTicker; //works because it is the right type
m.Tick += 4; //doesn't work... wrong type
m.Tick += "This doesnt work either"; //string type is not TickHandler type

那会清除一些吗？

Answer 6

据我所知，事件基本上是一个多播委托，但是对于基本操作具有不同的访问规则，可以对委托中的代理和事件以及它们所定义的类内外的事件执行。

这些业务是：

使用=运算符赋值

使用+ =和 - =运算符添加/删除

使用（）运算符调用

              Operation         | delegate   | event
              ------------------+------------+--------
Inside class  += / -=           | valid      | valid
              ------------------+------------+--------
Inside class  =                 | valid      | valid
              ------------------+------------+--------
Inside class  ()                | valid      | valid
              ------------------+------------+--------
Outside class  += / -=          | valid      | valid
              ------------------+------------+--------
Outside class  =                | valid      | not valid
              ------------------+------------+--------
Outside class  ()               | valid      | not valid

这给你封装，这总是很好的OOP风格。 :-)

Answer 7

我认为使用委托和事件之间的主要区别在于事件只能由服务器引发（意味着类的作者）

如果现在删除event关键字，则可以在Listener引发m.Tick(sender,e) ，否则不会。

public class Listener
{
  public void Subscribe(Metronome m)
  {
    m.Tick += new Metronome.TickHandler(HeardIt);
  }

  private void RaisTick(object sender, EventArgs e)
  {
      m.Tick(sender,e);
  }
  private void HeardIt(Metronome m, EventArgs e)
  {
     System.Console.WriteLine("HEARD IT");
  }

}