.Net Framework中委托和事务的编码规范：

委托类型的名称都应当以EventHandler停止。
委托的原型定义：有一个void返回值，并接管两个输入参数：一个Object 类型，一个 EventArgs类型（或持续自EventArgs）。
事务的定名为 委托去掉 EventHandler之后残剩的项目组。
持续自EventArgs的类型应当以EventArgs结尾。

    class Fax 
    {
        public Fax（MailManager m）
        {
            //机关委托的实力，引用SendFax回调办法
            //向MailMaager的NewsMail事务挂号回调办法。
            m.NewsMail += SendFax;
        }
        public static void SendFax（object sender， NewMailEventArgs message）
        {
            Console.WriteLine（"SendFax From:{0} ，To:{1} ，Subject:{2}"， message.Form，message.To，message.Subject）;
        }
        //履行这个办法，Fax对象将刊出对NewMail事务的存眷。今后不在接管事务的通知。
        public void Untier（MailManager mm）
        {
            mm.NewsMail -= SendFax;
        }
    }
    class Pager
    {
        public Pager（MailManager m）
        {
            m.NewsMail += PrintPager;
        }
        public static void PrintPager（object sender， NewMailEventArgs message）
        {
            Console.WriteLine（"Pager From:{0} ，To:{1} ，Subject:{2}"， message.Form， message.To， message.Subject）;
        }
        public void Untier（MailManager mm）
        {
            mm.NewsMail -= PrintPager;
        }
    }  
    class Program
    {
        static void Main（）
        {
            MailManager mm = new MailManager（）;
            Fax fx = new Fax（mm）;
            Pager p = new Pager（mm）;
            mm.SimulateNewMail（"XiaoBai"， "Blogs"， "HelloWord"）;
            p.Untier（mm）;
            mm.SimulateNewMail（"XiaoBai"， "Blogs"， "HelloWord"）;
            Console.ReadKey（）;
        }

    }
    //激发事务的对象欲望向接管事务通知的对象传递一些附加信息，这些附加信息须要封装到它本身的类中，
    //按照商定，这种类应当从EventArgs派生，并且类名以EventArgs停止
    //1.定义类型来容纳所有须要发送给事务通知接管者的附加信息。
    class NewMailEventArgs : EventArgs
    {
        readonly string m_form， m_to， m_subject;
        public NewMailEventArgs（string form， string to， string subject）
        {
            m_form = form;
            m_to = to;
            m_subject = subject;
        }
        public string Form { get { return m_form; } }
        public string To { get { return m_to; } }
        public string Subject { get { return m_subject; } }
    }
    class MailManager
    {
        //2.定义事务成员
        public event EventHandler NewsMail;

        //3.定义负责激发事务的办法来通知事务的挂号对象。
        public virtual void OnNewMail（NewMailEventArgs e）
        {
            //EventHandler temp = Interlocked.CompareExchange（ref NewsMail， null， null）;
            //if （temp != null）
            //{
            //    temp（this， e）;
            //}
            e.Raise（this， ref NewsMail）;
        }
        public void SimulateNewMail（string form， string to， string subject）
        {
            NewMailEventArgs e = new NewMailEventArgs（form， to， subject）;
            OnNewMail（e）;
        }
    }
    //为了便利，可以定一个扩大办法来封装3的线程安然逻辑。
    public static class EventArgExtensions {
        public static void Raise（this TEventArgs e，Object sender，ref EventHandler eventDelete） where TEventArgs:EventArgs
        {
            EventHandler temp = Interlocked.CompareExchange（ref eventDelete， null， null）;
            if （temp != null） temp（sender， e）;
        }
    }

事务+= ，-=背后的事：

public event EventHandler NewsMail
{
    add
    {
        EventHandler handler;
        EventHandler handler2;
        EventHandler handler3;
        bool flag;
        handler = this.NewsMail;
    Label_0007:
        handler2 = handler;
        handler3 = （EventHandler） Delegate.Combine（handler2， value）;
        handler = Interlocked.CompareExchange>（&this.NewsMail， handler3， handler2）;
        if （（（handler == handler2） == 0） != null）
        {
            goto Label_0007;
        }
        return;
    }
    remove
    {
        EventHandler handler;
        EventHandler handler2;
        EventHandler handler3;
        bool flag;
        handler = this.NewsMail;
    Label_0007:
        handler2 = handler;
        handler3 = （EventHandler） Delegate.Remove（handler2， value）;
        handler = Interlocked.CompareExchange>（&this.NewsMail， handler3， handler2）;
        if （（（handler == handler2） == 0） != null）
        {
            goto Label_0007;
        }
        return;
    }
}

微信小程序开发

private EventHandler NewsMail;//即使源码将事务定义为public，委托字段NewMali也始终是private，目标是防止类外的代码不正确的操纵它。

//办法添加对事务的存眷
public void add_NewsMail（EventHandler value）

{

//经由过程轮回对CompareExchange的调用，可以以一种线程安然的办法挂号对事务的存眷。
    EventHandler handler2;
    EventHandler newsMail = this.NewsMail;
    do
    {
        handler2 = newsMail;
        EventHandler handler3 = （EventHandler） Delegate.Combine（handler2， value）;
        newsMail = Interlocked.CompareExchange>（ref this.NewsMail， handler3， handler2）;
    }
    while （newsMail != handler2）;
}

 

 

//办法刊出对事务的存眷。
public void remove_NewsMail（EventHandler value）
{
    EventHandler handler2;
    EventHandler newsMail = this.NewsMail;
    do
    {
        handler2 = newsMail;
        EventHandler handler3 = （EventHandler） Delegate.Remove（handler2， value）;
        newsMail = Interlocked.CompareExchange>（ref this.NewsMail， handler3， handler2）;
    }
    while （newsMail != handler2）;
}

 

 

事务属性： add和remove接见器的事务。

class Events : IDrawingObject
{        
    event EventHandler PreDrawEvent;

    event EventHandler IDrawingObject.OnDraw
    {
        add
        {
            lock （PreDrawEvent）
            {
                PreDrawEvent += value;
            }
        }
        remove
        {
            lock （PreDrawEvent）
            {
                PreDrawEvent -= value;
            }
        }
    }

}

凡是不须要供给本身的自定义事务接见器。在大多半景象下，应用在声明事务时由编译器主动生成的接见器就足够了。

消化消化

  static void Main（）
        {
            //MailManager mm = new MailManager（）;
            //Fax fx = new Fax（mm）;
            //Pager p = new Pager（mm）;
            //mm.SimulateNewMail（"XiaoBai"， 百度排名"Blogs"， "HelloWord"）;
            //p.Untier（mm）;
            //mm.SimulateNewMail（"XiaoBai"， "Blogs"， "HelloWord"）;
            lookManager looker = new lookManager（）;
            ShenZhen shen = new ShenZhen（looker）;//添加订阅事务
            BeiJing bj = new BeiJing（looker）;//添加订阅事务
            looker.horn += HeNan.Nothing;//
            MessagesArgs stutent = new MessagesArgs（） { Massage = "深圳的鸡蛋便宜5毛！其他城市的都涨价1块" };
            looker.horn -= HeNan.Nothing;//移除对事务的订阅
            looker.horn -= HeNan.Nothing;//试图删除一个从未添加过的办法，不会抛出任何异常警告。Delegate.Remove在内部不做任何工作。
            looker.OnHorn（stutent）;
            Console.ReadKey（）;
        }

    }
    class MessagesArgs : EventArgs
    {
        private string massage;
        public string Massage
        {
            get { return massage; }
            set { massage = value; }
        }
    }
    class lookManager
    {
        public event EventHandler horn;//为什么委托定义的返回值凡是都为void？尽管并非必须，然则我们发明很多的委托定义返回值都为void，为什么呢？这是因为委托变量可以供多个订阅者注册，若是定义了返回值，那么多个订阅者的办法都邑向公布者返回数值，成果就是后面一个返回的办法值将前面的返回值覆盖掉了
        public void OnHorn（MessagesArgs stutens）//事务的本意应当为在事务公布者在其本身的某个行动中触发
        {
            EventHandler temp = Interlocked.CompareExchange（ref horn， null， null）;
            if （temp != null） temp（this， stutens）;//触发事务
        }

    }
    class HeNan
    {
        public static void Nothing（object sender，MessagesArgs args）
        {
            Console.WriteLine（"河南的群众对：{0}默示不关怀！"，args.Massage）;
        }
    }
    class ShenZhen
    {
        public ShenZhen（lookManager mm）
        {
            mm.horn += Happy;
        }
        public static void Happy（object sender，MessagesArgs args）
        {
            Console.WriteLine（"深圳的很兴奋:{0}"， args.Massage）;
        }
    }
    class BeiJing
    {
        public BeiJing（lookManager mm）
        {
            mm.horn += Sad;
        }
        public static void Sad（object sender， MessagesArgs args）
        {
            Console.WriteLine（"北京的很尴尬:{0}"， args.Massage）;
        }
    }