委托事件

一. 什么是委托

通俗的讲，就是一个能存放符合某种格式（方法签名）的方法的指针的容器。

二．委托入门

程序示例：

//声明委托类（必须指定返回值类型和方法参数列表）
    public delegate void DGSayHi(string str);

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //创建委托对象，并为委托对象添加一个方法指针（方法对象地址）
            DGSayHi dgSayHi = new DGSayHi(SayHiSomeWhere);
            //调用委托（委托内部的方法就会被调用）
            //注意：不能存放 签名 和 委托签名 不一致的方法
            dgSayHi("霍啊啊");
        }

        void SayHiInChina()
        {
            MessageBox.Show("你好");
        }

        void SayHiSomeWhere(string location)
        {
            MessageBox.Show(location+"你好");
        }

    }

三．委托源码

1. 语法糖：在C#中有很多简洁语法，实质是由编译器在编译时转成完整语法，那么这种简洁语法叫做语法糖。

2. 委托的两个目的：

       能将方法作为参数和返回值；

       调用一个委托，执行N个方法（多播委托）；

3. 代码示例：

//1. 声明委托的本质：
    //委托编译后生成一个同名类（DGTest）
    //继承关系：DGTest->MulticastDelegate->Delegate
    public delegate void DGTest();
    public partial class Form1 : Form
    {        
        public Form1()
        {
            InitializeComponent();
        }
    }
private void btnTest_Click(object sender, EventArgs e)
        {
            //语法糖：在C#中有很多 简洁语法，实质是由编译器 在编译时 转成 完整语法，那么这种 简洁语法叫做语法糖
            //2.创建委托对象
            DGTest dg = Test;//new DGTest(this.Test);
            /*3.为委托追加方法的本质：
             *    是为 被追加的方法创建一个新的委托对象，并将 方法 指针存入对象的 父类的父类(Delegate)的 IntPtr 变量中
             *    然后再将 新创建的委托 添加到 当前委托对象(dg)的 数组中
             */
            dg += Test2;//编译后：(DGTest) Delegate.Combine(dg, new DGTest(this.Test2));
            dg += Test3;//编译后：(DGTest) Delegate.Combine(dg, new DGTest(this.Test3));
            dg -= Test3;//编译后：(DGTest) Delegate.Remove(dg, new DGTest(this.Test3));
            /*4.调用委托，其实就是通过调用委托对象里的Invoke方法 遍历 委托内部的数组，然后依次调用 数组中的 方法
             */
            dg();//编译后：dg.Invoke();
            
            /* 委托的作用：
             *   1.将方法做为参数
             *   2.将方法作为返回值
             */
        }

四.委托当参数用

代码示例：

void Test1()
        { }
        void Test2()
        { }
        void Test3()
        { }
        public void InvokeTest(DGTest dgTest)
        {
            dgTest();
        }
        //委托当参数用
        private void btnPara_Click(object sender, EventArgs e)
        {
            InvokeTest(Test1);
            InvokeTest(Test2);
            InvokeTest(Test3);
        }

五.委托当返回值

代码示例：

public DGTest InvokeTest(string strType)
        {
            switch (strType)
            {
                case "1":
                    return Test1;
                case "2":
                    return Test2;
                default:
                    return Test3;
            }
        }
        //委托当返回值
        private void btnReturn_Click(object sender, EventArgs e)
        {
            DGTest dg = InvokeTest("1");
            dg();
        }

六．自定义Each方法

程序示例：

//自定义Each方法
        private void btnEach_Click(object sender, EventArgs e)
        {
            ArrayList list = new ArrayList();
            list.Add("你");
            list.Add("好");
            list.Add("啊");
            list.Add("！");
            Each(list,ShowName);
        }
        void ShowName(int index, object item)
        {
            MessageBox.Show(index + "item=" + item);
        }
        delegate void DGEachFunc(int index,object item);
        public void Each(ArrayList list,DGEachFunc func)
        {
            for (int i = 0; i < list.Count; i++)
            {
                func(i, list[i]);
            }
        }

七．排序使用委托

代码示例：

#region 4.0 使用接口排序
        /// <summary>
        /// 使用接口排序
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnSort_Click(object sender, EventArgs e)
        {
            List<Dog> list = new List<Dog>();
            list.Add(new Dog() { name = "小白", age = 12 });
            list.Add(new Dog() { name = "小黑", age = 1 });
            list.Add(new Dog() { name = "小黄", age = 2 });

            for (int i = 0; i < list.Count; i++)
            {
                Console.WriteLine(i + "：" + list[i].name + ",age=" + list[i].age);
            }

            //此处 传递一个 IComparer接口的实现类 对象进去 ，目的 是 为 Sort 排序方法里的 比较过程 提供一个 比大小的方法。
            list.Sort(new CompareDog());

            Console.WriteLine("排序后：");
            for (int i = 0; i < list.Count; i++)
            {
                Console.WriteLine(i + "：" + list[i].name + ",age=" + list[i].age);
            }
        } 
        #endregion

        #region 5.0 使用委托排序
        /// <summary>
        /// 使用委托排序
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnSortDelegate_Click(object sender, EventArgs e)
        {
            List<Dog> list = new List<Dog>();
            list.Add(new Dog() { name = "小白", age = 12 });
            list.Add(new Dog() { name = "小黑", age = 1 });
            list.Add(new Dog() { name = "小黄", age = 2 });

            for (int i = 0; i < list.Count; i++)
            {
                Console.WriteLine(i + "：" + list[i].name + ",age=" + list[i].age);
            }

            //传入 的参数 为 一个 符合 Comparison 委托签名的方法
            list.Sort(ComparisonDog);

            //list.Sort((x, y) => x.age - y.age);
            //int d = list.Max(x => x.age);

            Console.WriteLine("排序后：");
            for (int i = 0; i < list.Count; i++)
            {
                Console.WriteLine(i + "：" + list[i].name + ",age=" + list[i].age);
            }
        }

        int ComparisonDog(Dog x, Dog y)
        {
            return x.age - y.age;
        } 
        #endregion

八．委托泛型案例-找最大值

代码示例：

#region 6.0 使用泛型方法 加 泛型委托 完成 通用版的 Max方法
        /// <summary>
        /// 使用泛型方法 加 泛型委托 完成 通用版的 Max方法
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnFindMax_Click(object sender, EventArgs e)
        {
            int[] arrInt = new int[5] { 1, 2, 5, 6, 3 };
            //int Max = MaxInt(arrInt);
            int max = MaxValue<int>(arrInt, (x, y) => x - y);


            string[] arrStr = new string[] { "a", "c", "b" };
            string maxLengthStr = MaxValue<string>(arrStr, (x, y) => x.Length - y.Length);

            Dog[] dogs = new Dog[] { new Dog() { age = 1, name = "小白" }, new Dog() { age = 0, name = "小白2" }, new Dog() { age = 5, name = "小白3" } };
            Dog maxAgeDog = MaxValue<Dog>(dogs, (x, y) => x.age - y.age);

        }

        int MaxInt(int[] arr)
        {
            int maxInt = arr[0];
            for (int i = 1; i < arr.Length; i++)
            {
                if (maxInt < arr[i])
                {
                    maxInt = arr[i];
                }
            }
            return maxInt;
        }


        T MaxValue<T>(T[] arr, Comparison<T> func)
        {
            T maxInt = arr[0];
            for (int i = 1; i < arr.Length; i++)
            {
                //使用委托来 完成元素 大小的比较过程！
                if (func(maxInt, arr[i]) < 0)
                {
                    maxInt = arr[i];
                }
            }
            return maxInt;
        } 
        #endregion

九．委托加工字符串（案例）

代码示例：

#region 9.0 调用 委托 加工 数组里的 每个字符串
        /// <summary>
        /// 调用 委托 加工 数组里的 每个字符串
        /// </summary>
        private void btnMakeUpStr_Click(object sender, EventArgs e)
        {
            //创建数组
            string[] strArr = new string[] { "bb", "小李", "飞到" };
            //加工后产生新的数组，并将 方法 作为 第二个参数 传入
            string[] strArrNew = MakeUpStrArr(strArr, MakeUpStr);
            //遍历新数组 检查结果
            for (int i = 0; i < strArrNew.Length; i++)
            {
                Console.WriteLine(strArrNew[i]);
            }
        }

        //为传入字符串加一个 新的字符串
        string MakeUpStr(string str)
        {
            return str += "- : )";
        }

        //为传入的字符串数组 里的每个字符串 追加一个 新的字符串，并作为新字符串数组返回
        string[] MakeUpStrArr(string[] arrStr, DGMakeUpStr dgMakeUpStr)
        {
            //创建新数组
            string[] arrstrNew = new string[arrStr.Length];
            //遍历字符串数组
            for (int i = 0; i < arrStr.Length; i++)
            {
                arrstrNew[i] = dgMakeUpStr(arrStr[i]);//此处调用 传入的委托对象里的方法 为 字符串加工
            }
            //返回新数组
            return arrstrNew;
        } 
        #endregion

十．委托找最大值（更加清晰的案例）

private void btnFindMaxByDel_Click(object sender, EventArgs e)
        {
            DGCompare dg = new DGCompare(IntCompare);

            //找最大数值
            object[] arrInt = {5, 4, 1, 9, 8};
            int maxInt = Convert.ToInt32(GetMax(arrInt, new DGCompare(IntCompare)));

            //找最长字符串
            object[] arrStr = { "ui", "xiaomi", "lei", "h" };
            string maxLenStr = GetMax(arrStr, StringCompare).ToString();

            //找年龄最大的狗
            object[] arrDog = { new Dog { name = "小白", age = 21 }, new Dog { name = "小黑", age = 11 }, new Dog { name = "小花", age = 5 } };
            Dog oldestDog = GetMax(arrDog, DogCompare) as Dog;
        }

        /// <summary>
        /// 根据 比较方法找最大值
        /// </summary>
        /// <returns></returns>
        object GetMax(object[] values, DGCompare comparor)
        {
            object max = values[0];
            foreach (object obj in values)
            {
                if (comparor.Invoke(obj, max) > 0)
                {
                    max = obj;
                }
            }
            return max;
        }

        //--------------------------------- 三个不同的比较方法 ----------------------------
        public int IntCompare(object value1, object value2)
        {
            int i1 = (int)value1;
            int i2 = (int)value2;
            return i1 - i2;
        }

        public int StringCompare(object value1, object value2)
        {
            string i1 = (string)value1;
            string i2 = (string)value2;
            return i1.Length - i2.Length;
        }

        public int DogCompare(object value1, object value2)
        {
            Dog i1 = (Dog)value1;
            Dog i2 = (Dog)value2;
            return i1.age - i2.age;
        }

十一.委托的封装（事件）

代码示例：

public partial class C03事件 : Form
    {
        //1.手动 创建 按钮对象
        MyTripleButton btnMyTriple = new MyTripleButton();

        //2.手动 创建 改进型 按钮对象
        MyTripleButtonSelf btnMyTriSelf = new MyTripleButtonSelf();

        //3.手动 创建 事件 按钮对象
        MyTripleButtonSelfEvent btnMyTriSelfEvent = new MyTripleButtonSelfEvent();

        public C03事件()
        {
            InitializeComponent();

            //1.2.设置 按钮的 文本 和位置
            btnMyTriple.Text = "自定义按钮";
            btnMyTriple.Location = new Point(100, 100);
            //1.3.将按钮 显示到 窗体上
            this.Controls.Add(btnMyTriple);
            //1.4.为按钮 的 委托 设置一个 方法（按钮被点击的时候 会被 执行）
            btnMyTriple.dgMyClick = MyTripleClick;


            //2.2.设置 按钮的 文本 和位置
            btnMyTriSelf.Text = "改进型 自定义按钮";
            btnMyTriSelf.Location = new Point(100, 150);
            btnMyTriSelf.Size = new Size(150, 50);
            //2.3.将按钮 显示到 窗体上
            this.Controls.Add(btnMyTriSelf);
            //2.4.为按钮 的 委托 设置一个 方法（按钮被点击的时候 会被 执行）
            btnMyTriSelf.AddClickMethod(MyTripleClick);


            //3.2.设置 按钮的 文本 和位置
            btnMyTriSelfEvent.Text = "事件 自定义按钮";
            btnMyTriSelfEvent.Location = new Point(100, 200);
            btnMyTriSelfEvent.Size = new Size(150, 50);
            //3.3.将按钮 显示到 窗体上
            this.Controls.Add(btnMyTriSelfEvent);
            //3.4.为按钮 的 委托 设置一个 方法（按钮被点击的时候 会被 执行）
            btnMyTriSelfEvent.dgMyClick += MyTripleClick;
            btnMyTriSelfEvent.dgMyClick -= MyTripleClick;
        }

        void MyTripleClick(DateTime clickTime)
        {
            MessageBox.Show("Test" + clickTime);
        }

        private void btnTrick_Click(object sender, EventArgs e)
        {
            //直接 把 按钮对象 里的委托 设置为空，从而 导致委托中原来保存的方法指针都丢失，有可能破坏了 业务的完整性，不安全！！！
            btnMyTriple.dgMyClick = null;
            //新式 按钮，没有把按钮里的 委托对象 暴露给 外部直接操作，所以相对来说 比较安全！！！
            //btnMyTriSelf.RemoveClickMethod(
            //事件 按钮，事件机制 会自动的将 修饰的 委托变量改为私有，并同时提供一个 add 和 remove方法
            //btnMyTriSelfEvent.dgMyClick = null;
        }
    }

十二. 事件

       当我们使用event关键字修饰一个类里的委托对象时，编译器会自动把这个委托对象私有化，并且声称一个与委托对象同名的事件语法，其中就包含了add和remove方法。在类的外部调用这个委托名的时候，实际上就是调用了同名的事件语法，+=就是调用了语法里的add方法，-=就是调用了事件语法里的remove方法，而add和remove方法内部，都是实际操作的私有化的委托对象。

十三. 事件案例（三击按钮）

代码示例：

/// <summary>
    /// 三击按钮类 - 用户点击三次后 执行用户的 方法
    /// </summary>
    public class MyTripleButton:System.Windows.Forms.Button
    {
        Timer time = new Timer();

        public MyTripleButton()
        {
            base.Click += MyTripleButton_Click;
            time.Interval = 1000;
            time.Tick += time_Tick;
        }

        int clickTimes = 0;
        //定义一个 用来保存 用户方法的委托对象
        public event DGMyClick dgMyClick;

        void time_Tick(object sender, EventArgs e)
        {
            clickTimes = 0;
        }

        //每当被点击的时候，此方法会被调用
        void MyTripleButton_Click(object sender, EventArgs e)
        {
            //如果点击次数没达到3次
            if (clickTimes < 2)
            {
                //如果是第一次点击 则启动计时器
                if (clickTimes == 0)
                {
                    time.Start();
                }
                //点击次数++
                clickTimes++;
            }
            else//点击三次后
            {
                //1.执行用户的 方法
                if (dgMyClick != null)
                    dgMyClick(DateTime.Now);
                //2.清空点击次数
                clickTimes = 0;
                //3.重启计时器
                time.Stop();
            }
        }
}

public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            //1.创建三击按钮对象
            MyTripleButton myBtn = new MyTripleButton();
            //2.利用一个事件机制 为 按钮里的委托对象 注册一个 方法（或 移除一个方法）
            myBtn.dgMyClick += ClickSelf;
            //3.注意：因为使用了事件机制 封装了 按钮里的委托对象，所以不能 直接 赋值 和 调用委托了
            //myBtn.dgMyClick = null;
            //myBtn.dgMyClick();
            this.Controls.Add(myBtn);
        }

        void ClickSelf(DateTime time)
        {
            MessageBox.Show("三击了~~~~~~~~~~~~~！加分！");
        }
    }