基本信息

---

下载

   友情提示：（无需注册或充值，赞助后即可获取资源下载链接）

---

     嘿，亲！知识可是无价之宝呢，但咱这精心整理的资料也耗费了不少心血呀。小小地破费一下，绝对物超所值哦！如有下载和支付问题，请联系我们QQ(微信同号)：813200300

本次赞助数额为： 2 元　

支付宝支付

微信支付

   源码介绍

---

01委托_1

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace _01委托
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        #region 01委托概述
        /// <summary>
        /// 点击按钮事件
        /// </summary>
        private void btnDelegate_Click(object sender, EventArgs e)
        {
            //委托是方法的容器，可以在委托对象中添加、移除方法

            ///创建委托对象,并通过构造函数添加SayHiCN方法 
            dg_SayHi objSayHi = new dg_SayHi(SayHiCN);
            //向委托对象中 "添加" 一个方法
            objSayHi  = SayHiEN;
            //从委托对象中 "移除" 一个方法
            objSayHi -= SayHiCN;


            //调用委托,委托是方法的容器 ，调用委托的时候委托里面的方法都会被调用
            objSayHi();

        }

        void SayHiCN()
        {
            MessageBox.Show("你好上海");
        }
        void SayHiEN()
        {
            MessageBox.Show("hi shanghai");
        }
        #endregion



        private void BtnDelegateAsPara_Click(object sender, EventArgs e)
        {
            int[] arr = { 1, 2, 5, 6, 7, 12 };

            Person[] perArr =  { 
                new Person {Name="甜馨",Age=2},
                new Person {Name="奥莉",Age=3},
                new Person {Name="嗯哼",Age=1}
            };


            ////二，我们用写好的委托方法再次实现 比较大小
            //dg_GetMax<int> dg_GetMaxInt = new dg_GetMax<int>(Compare);
            //int numMax = GetMax(arr, dg_GetMaxInt);  //调用泛型委托
            ////dg_GetMax<Person> dg_GetMaxPer = new dg_GetMax<Person>(Compare);
            //Person per = GetMax<Person>(perArr, Compare);    //另外一种写法

            //三，Compare方法改写为委托方法 ,可以把Compare改写为匿名方法
            //int numMax = GetMax<int>(arr, Compare);
            int numMax = GetMax<int>(arr, delegate(int a, int b)
            {
                int num = 0;
                if (a > b)
                {
                    num = 1;
                }
                else if (a == b)
                {
                    num = 0;
                }
                else if (a < b)
                {
                    num = -1;
                }
                return num;
            });
            //Person per = GetMax<Person>(perArr, Compare);  
            Person per = GetMax<Person>(perArr, delegate(Person AA, Person BB)
            {
                int num = 0;
                if (AA.Age > BB.Age)
                {
                    num = 1;
                }
                else if (AA.Age == BB.Age)
                {
                    num = 0;
                }
                else if (AA.Age < BB.Age)
                {
                    num = -1;
                }
                return num;
            });


            MessageBox.Show("最大数"   numMax.ToString());
            MessageBox.Show(string.Format("最大年龄是：{0},年龄:{1}岁", per.Name, per.Age));

            //一，创建委托对象，并通过构造函数添加   GetMaxNum 方法
            //dg_GetMaxAndMin objGetMax = new dg_GetMaxAndMin(GetMaxNum);
            //int numMax = objGetMax(arr);   //传递参数数组
            ////委托对象添加  GetMinNum 方法
            //objGetMax  = GetMinNum;
            //int numMin = GetMinNum(arr);   //传递参数数组

            //MessageBox.Show("最大数"   numMax.ToString()   "  最小数"   numMin.ToString());
            //MessageBox.Show(string.Format("最大年龄是：{0},年龄{1}岁", per.Name, per.Age));

        }

        //委托的GetInvocationList()方法会返回委托数组，里面包含了所有注册到委托上的方法
        //Delegate[] arrTest = objGetMax.GetInvocationList();
        //for (int i = 0; i < arrTest.Length; i  )
        //{
        //    MessageBox.Show(string.Format("委托中的第{0}个方法的返回值：{1}", i   1, arrTest[i].DynamicInvoke()));
        //}

        //// 获取最大年龄的方法添加到委托中
        //dg_GetMaxAgePer obgGetMaxAge = new dg_GetMaxAgePer(GetMaxAgePer);
        ////  直接调用委托，只能获得最后一个添加的方法 的返回值 
        //MessageBox.Show(string.Format("最大年龄的是{0}，年龄{1}", obgGetMaxAge.Invoke().Name, obgGetMaxAge.Invoke().Age));

        /// <summary>
        /// 2.1  返回数组中的最大数
        /// </summary>
        /// <returns></returns>
        int GetMaxNum(int[] arr)
        {
            int numMax = arr[0];
            for (int i = 1; i < arr.Length; i  )
            {
                if (arr[i] > numMax)
                {
                    numMax = arr[i];
                }
            }
            return numMax;
        }
        /// <summary>
        /// 2.2  返回数组中的最小数
        /// </summary>
        /// <returns></returns>
        int GetMinNum(int[] arr)
        {

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

        /// <summary>
        /// 2.3  返回年龄最大的Person
        /// </summary>
        /// <returns></returns>
        Person GetMaxAgePer(Person[] perArr)
        {
            Person MaxAgePer = perArr[0];
            for (int i = 1; i < perArr.Length; i  )
            {
                if (perArr[i].Age > MaxAgePer.Age)
                {
                    MaxAgePer = perArr[i];
                }
            }
            return MaxAgePer;
        }

        /// <summary>
        /// 2.3  泛型方法，获得数组中最大的元素
        /// </summary>
        /// <typeparam name="T">泛型参数,如果比较的是int则返回int,如果比较的是person则返回person</typeparam>
        /// <param name="arr">泛型数组</param>
        /// <param name="dgGetMax">委托参数，传递过来可以装比较方法的委托对象</param>
        /// <returns></returns>
        public T GetMax<T>(T[] arr, dg_GetMax<T> dg)
        {

            T max = arr[0];
            for (int i = 0; i < arr.Length; i  )
            {
                //比较大小、具体该怎么判断？  判断的对象无法确定，有可能是int类型也有可能是Person类
                //所以，我们方法中 添加了第二个泛型委托变量， 委托中的方法实现了具体的比较并返回值。返回1则表明第一个数比第二个数大
                if (dg(arr[i], max) == 1)
                {
                    max = arr[i];
                }
            }
            return max;   //这个max有可能是int，也有可能是max
        }

        #region 2.4 两个不同对象的比较方法
        //两个整形数比价大小
        int Compare(int a, int b)
        {
            int num = 0;
            if (a > b)
            {
                num = 1;
            }
            else if (a == b)
            {
                num = 0;
            }
            else if (a < b)
            {
                num = -1;
            }
            return num;
        }
        //两个Person类型比较大小
        int Compare(Person AA, Person BB)
        {
            int num = 0;
            if (AA.Age > BB.Age)
            {
                num = 1;
            }
            else if (AA.Age == BB.Age)
            {
                num = 0;
            }
            else if (AA.Age < BB.Age)
            {
                num = -1;
            }
            return num;
        }
        #endregion

        private void btnPersonDelegate_Click(object sender, EventArgs e)
        {
            Person per = new Person();

            per.AddMethod(SayHiCN);
            per.AddMethod(SayHiCN);
            /*
            per.dgSayHi = new dg_SayHi(SayHiCN);
            per.dgSayHi  = SayHiEN;

            //下面的代码就把委托对象给重置了，把之前添加在委托里的方法给清空了
            per.dgSayHi = null;
            per.dgSayHi = new dg_SayHi(SayHiEN);

            per.dgSayHi();
            */


        }



        //我们需要把上面的不同对象的比较方法 ，添加到委托中以方便作为参数  T GetMax<T> 比较方法中





    }
}