便于自我理解delegate委托

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DawaNote
{
    //delegate 命名规则 
    //1.  xxHandler
    //2.  xxEventHandler
    //
    //delegate 可以在类外部声明即命名空间中直接声明
    //event 是用来修饰delegate实例的，不可用来修饰delegate
    //event 是一种特殊的delegate实例
    //delegate 可以理解为一种特殊的类，故而可以在命名空间中声明，实例化委托的过程类比于类的实例化。
    //public delegate void NamespaceHandler(string str);类似于类的声明
    //public static NamespaceHandler StaticWrite;类似于变量的声明
    //StaticWrite = OnWrite2;类似于变量的初始化。
    //StaticWrite("test");理解为变量的一个方法的执行，如果变量为null，则无法执行方法。

    public delegate void NamespaceHandler(string str);


    class Program
    {
        static void Main(string[] args)
        {
            MyDelegates myDelegates = new MyDelegates();
            myDelegates.Test3();
            //myDelegates.WriteEvent += Write;
            //myDelegates.Write2 += Write;
            //myDelegates.Write2("Write2");
            //编译不通过，event只能在声明类中调用
            //myDelegates.WriteEvent("WriteEvent");
            Console.Read();
        }



        static void Write(string str)
        {
            Console.WriteLine("Program.Write： " + str);
        }

    }
    public class MyDelegates
    {

        //类内部定义委托
        public delegate void ClassHandler(string str);

        //声明静态委托
        public static NamespaceHandler StaticWrite;
        public static ClassHandler StaticWrite2;

        //声明普通委托
        public NamespaceHandler Write;
        public ClassHandler Write2;
        public ClassHandler Write3;

        //event只能在类下声明，无法在方法下声明，普通委托则无此限制
        //event只能在声明类中调用，在外部类中只能使用+=，-=，普通委托则无此限制
        public event ClassHandler WriteEvent;

        public void Test()
        {
            //event ClassHandler WriteEvent; //编译不通过
            WriteEvent += OnWrite2;
            //在声明类内部调用事件
            WriteEvent("event");
        }


        //委托是一种数据类型（引用类型）
        //Write3会执行Write2所有的方法，可以理解为委托是引用类型类型，类似于Write3是Write2的普通的引用类型
        public void Test1()
        {
            Write2 = OnWrite;
            Write2 += OnWrite2;
            Write3 = Write2;
            Write2("Write2");
            Write3("Write3");
        }

        //Write3 赋值需要在Write2实例化之后进行（+= ，=）,否则报：未将对象引用设置到对象的实例。
        public void Test2()
        {
            #region 错误的写法

            //Write2未初始化，相当于null，次语句与Write3 = null;等同
            Write3 = Write2;
            //Write2初始化，相当于new 构造。
            Write2 = OnWrite;
            Write2("Write2");
            //以此异常，因为 Write3 = null;故而报异常：未将对象引用设置到对象的实例。
            Write3("Write3");
            
            #endregion

            #region 正确的写法

            Write2 = OnWrite;
            Write3 = Write2;
            Write2("Write2");
            Write3("Write3");
            
            #endregion

        }

        // = 与 +=
        public void Test3()
        {
            Write2 = null;
            //Write2初始化，相当于new 构造。  
            //当Write2=null时，第一个+=会后台会自动初始化Write2   Write2 = OnWrite;与  Write2 += OnWrite;结果相同
            Write2 = OnWrite;
            Write2 += OnWrite;
            Write2 += OnWrite;
            //+=，Write2进行多委托，进而多次执行OnWrite方法，此处执行3次打印功能
            Write2("Write2");
            Console.WriteLine("------------------------------");
            //Write2初始化，相当于new 构造。
            //此处执行一次打印
            Write2 = OnWrite;
            Write2("Write2");

        }

        public void OnWrite(string str)
        {
            Console.WriteLine("MyDelegates.Onwrite： " + str);
        }
        public void OnWrite2(string str)
        {
            Console.WriteLine("MyDelegates.OnWrite2： " + str);
        }

    }
}