C# 命名、声明和定义委托和事件约定

Naming, declaring and defining delegates and events conventions

提问by

How do you name delegates, events and instance of events?

你如何命名委托、事件和事件实例？

I use this:

我用这个：

delegate void OnSomethingHandler();
event OnSomethingHandler onSomething;

Is this an accepted way? Notice lower and upper cases

这是一种可接受的方式吗？注意大小写

---

---

Where do you place delegates and events?

你在哪里放置代表和活动？

I usually put delegates in an a namespace best reflecting them:

我通常将委托放在一个最能反映它们的命名空间中：

mynamespace.Def.SomethingLike
{

}
mynamespace.Def.SomethingElseLike
{

}

---

---

Where do you define events?

你在哪里定义事件？

I usually place them into the class that uses them.

我通常将它们放入使用它们的类中。

I notice that a lot of people define delegates and events in the same class. How common is that?

我注意到很多人在同一个类中定义委托和事件。这有多常见？

采纳答案by Andrew Hare

Everything you have looks pretty standard - the only thing I would change is that the event name would be Somethingrather than onSomething. Following Microsofts convention you would end up with something more like this:

你所拥有的一切看起来都很标准——我唯一要改变的是事件名称将是Something而不是onSomething. 按照微软的约定，你最终会得到更像这样的东西：

delegate void SomethingHandler();
event SomethingHandler Something;

protected void OnSomething()
{
    if (this.Something != null)
        this.Something();
}

And as a cool trick you can add an empty delegate to your Somethingevent so that you don't have to check the event for null before you raise it:

作为一个很酷的技巧，您可以向Something事件添加一个空委托，这样您就不必在引发事件之前检查事件是否为 null：

delegate void SomethingHandler();
event SomethingHandler Something = delegate {};

protected void OnSomething()
{
    this.Something();
}

回答by bdukes

MSDN on naming events:

MSDN 上的命名事件：

Events always refer to some action, either one that is happening or one that has occurred. Therefore, as with methods, events are named with verbs, and verb tense is used to indicate the time when the event is raised.

√ DOname events with a verb or a verb phrase.

Examples include Clicked, Painting, DroppedDown, and so on.

√ DOgive events names with a concept of before and after, using the present and past tenses.

For example, a close event that is raised before a window is closed would be called Closing, and one that is raised after the window is closed would be called Closed.

X DO NOTuse "Before" or "After" prefixes or postfixes to indicate pre- and post-events. Use present and past tenses as just described.

√ DOname event handlers (delegates used as types of events) with the "EventHandler" suffix, as shown in the following example:

public delegate void ClickedEventHandler(object sender, ClickedEventArgs e);

√ DOuse two parameters named senderand ein event handlers.

The sender parameter represents the object that raised the event. The sender parameter is typically of type object, even if it is possible to employ a more specific type.

√ DOname event argument classes with the "EventArgs" suffix.

事件总是指某种动作，要么是正在发生的，要么是已经发生的。因此，与方法一样，事件以动词命名，动词时态用于表示事件发生的时间。

√务必用动词或动词短语命名事件。

示例包括Clicked、Painting、DroppedDown等。

√ DO给事件的名称与之前和之后的一个概念，使用本时和过去时。

例如，在窗口关闭之前引发的关闭事件将被称为Closing，而在窗口关闭之后引发的事件将被称为Closed。

X不要使用“Before”或“After”前缀或后缀来表示前后事件。使用刚才描述的现在和过去时。

√ DO名称事件处理程序与“事件处理”后缀（用作类型的事件的代表），如下面的示例所示：

public delegate void ClickedEventHandler(object sender, ClickedEventArgs e);

√务必在事件处理程序中使用两个名为sender和e 的参数。

sender 参数表示引发事件的对象。sender 参数通常是 type object，即使可以使用更具体的类型。

√务必使用“EventArgs”后缀命名事件参数类。

So, events should be named with a verb or verb phrase. Instead of OnSomething, use Something, assuming that Somethingis actually a verb, like Close, Click, or ManagedPiplelineAbandoningand ManagedPiplelineAbandoned.

因此，事件应该用动词或动词短语命名。代替OnSomething，使用Something，假设它Something实际上是一个动词，例如Close, Click, or ManagedPiplelineAbandoningand ManagedPiplelineAbandoned。

The delegate for an event should be named with the EventHandlersuffix, giving CloseEventHandler, ClickEventHandler, ManagedPiplelineAbandoningHandler, etc.

对于事件的委托应与被命名EventHandler后缀，使CloseEventHandler，ClickEventHandler，ManagedPiplelineAbandoningHandler，等。

For delegates that aren't related to an event, use a noun, like EventProcessoror ItemRetriever, while an instance of that delegate is a verb, like processEventor retrieveItem.

对于与事件无关的委托，请使用名词 like EventProcessoror ItemRetriever，而该委托的实例是动词 like processEventor retrieveItem。

The casing of your delegate reference should be camel, unless the reference is not private. I can't think of a case where you'd have a non-private delegate field, though.

委托引用的大小写应该是驼峰式的，除非引用不是私有的。不过，我想不出有非私有委托字段的情况。

However, since it is suggested to use the conventional event handler signature (i.e. object sender, EventArgs e)), you should use a generic event handlerinstead of defining your own. That is, your event would be defined as something like this:

但是，由于建议使用传统的事件处理程序签名（即object sender, EventArgs e)），您应该使用通用事件处理程序而不是定义您自己的事件处理程序。也就是说，您的事件将被定义为这样的：

event EventHandler<SomethingEventArgs> Something;

回答by timB33

expanding on bdukes answer/summary and using an example I found here, here's my attempt:

扩展 bdukes 答案/摘要并使用我在此处找到的示例，这是我的尝试：

//from http://www.codeproject.com/Articles/11541/The-Simplest-C-Events-Example-Imaginable
using System;
namespace wildert
{
    public class TimeOfTickEventArgs : EventArgs //<- custom event args
    {
        private DateTime TimeNow;
        public DateTime Time
        {
            set { TimeNow = value; }
            get { return this.TimeNow; }
        }
    }
    public class Metronome
    {
        public delegate void TickEventHandler(object sender, TimeOfTickEventArgs e); //I put the delegate declaration before the events
        public event TickEventHandler Ticked; //Ticked(i.e. after something occurred), or possibly Ticking(i.e. before)

        public void Start()
        {
            while (true)
            {
                System.Threading.Thread.Sleep(3000);
                if (Ticked != null){
                    TimeOfTickEventArgs tot = new TimeOfTickEventArgs();
                    tot.Time = DateTime.Now;
                    Ticked(this, tot); //<- publish the event
                }
            }
        }
    }
    public class Listener
    {
        public void Subscribe(Metronome m){
            m.Ticked += new Metronome.TickEventHandler(HeardIt);  //<- subscribe to the event
        }
        private void HeardIt(object sender, TimeOfTickEventArgs e){ //<- this is the event handler (note signature 'object sender, xxx e')
            System.Console.WriteLine("HEARD IT AT {0}",e.Time);
        }
    }
    class Test
    {
        static void Main()
        {
            Metronome m = new Metronome();
            Listener l = new Listener();
            l.Subscribe(m);
            m.Start();
        }
    }
}