首页 > > 网络编程 > Asp.Net编程 >

【.NET基础】--委托、事件、线程（1）

2018-06-22 06:47:53来源：未知 阅读 ()

新老客户大回馈,云服务器低至5折

1,委托 是存放方法的指针的清单，也就是装方法的容器　　　 

A, 新建winform项目【01委托】，项目中添加dg_SayHi.cs 委托类 用于存储方法　 

namespace _01委托
{
    //定义委托 【类】
    delegate void dg_SayHi();
}

　　  B, Winfrom中添加按钮 "委托"，按钮事件“btnDelegate_Click”中新建委托对象，并添加、移除 方法：

        /// <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");
        }
    }

 　　　  C，点击“委托”，查看效果：

　　　　

　　　　D, 一张图片解释上面的运行过程：

　　　

2, 委托返回类型和添加到委托的方法的返回类型保持一致

委托可以作为参数使用，传递方法。把委托对象作为参数，委托对象是方法的容器（上图中的椭圆），这样实际上就传递了方法；上面示例我们只是在委托中添加了方法，还没有把委托作为参数传递，我们看下面的示例介绍

　　　　A, 我们有两个方法，分别是获取int数组中最大数的方法 int GetMaxNum()　和  获取int数组中最小数的方法 int GetMinNum()　　　

 /// <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;
        }
View Code

　　　　B，如果把这两个方法添加到委托类中，所以我们需要添加int类型的委托类 int dg_GetMaxAndMin()

   //定义委托 【类】
    delegate void dg_SayHi();

    //再定义一个委托类，接收返回类型为int的方法
    delegate int dg_GetMaxAndMin(int[] arr);

　　  　 C, 添加按钮事件，事件中读取委托中方法的返回值

 private void BtnDelegateAsPara_Click(object sender, EventArgs e)
        {
            int[] arr = { 1, 2, 5, 6, 7, 12 };
　　　　　　//创建委托对象，并通过构造函数添加   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());

        }

　　　　 D,点击按钮查看效果：

　　　  

　　　　

　　　AA, 我们还有一个方法返回年龄最大的Person 

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

namespace _01委托
{
    public class Person
    {
        #region 姓名
        string name;

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        #endregion

        #region 年龄
        int age;

        public int Age
        {
            get { return age; }
            set { age = value; }
        }
        #endregion
    }
}
View Code
  /// <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;
        }
View Code

　　　BB,如果我们把Person类添加到委托中，那么我们就还需要添加 Person类型的委托类 Person dg_GetMax()。

  //定义委托 【类】
    public delegate void dg_SayHi();

    //再定义一个委托类，接收返回类型为int的方法
    delegate int dg_GetMaxAndMin(int[] arr);

    //再定义一个委托类，接收返回类型为Person的方法
    delegate Person dg_GetMaxAgePer(Person[] perArr);

　　 CC,更新按钮事件,新建Person类型的委托对象，并添加 Person GetMaxAgePer()方法

 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}
            };

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

            dg_GetMaxAgePer objGetMaxAge = new dg_GetMaxAgePer(GetMaxAgePer);
            Person per = objGetMaxAge(perArr);

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

        }

　　　　　　DD， 运行查看运行结果：

　　　　　　

3，委托改写为泛型委托，作为参数进行传递

　　按照上面的示例，我们每个不同返回类型的方法，都定义与之返回类型相同同类型的委托，有些麻烦，现在我们用泛型进行定义。

 　　A, 由于不知道要比较的对象，我们先试着写一个泛型比较方法，如下，方法中传递过来了比较的对象T[] arr,但是对象我们不确定是int[]数组还是person[]数组，这样for循环里面我们就还需要添加一个具体的比较方法。这个方法就需要通过委托传递比较方法过来了！

 　　　　public T GetMax<T>(T[] arr)
        {
            T max = arr[0];
            for (int i = 0; i < arr.Length; i++)
            {
                //比较大小、具体该怎么判断？  判断的对象无法确定，有可能是int类型也有可能是Person类
            }
            return max;
        }

　　B, 上面的For循环中应该是把下面的两个比较方法传递进去的

 #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
View Code

　　C,现在我们定义可以接收上面两个不同对象比较方法的委托：int dg_GetMax<T>(T t1, T t2)　

   //定义委托 【类】
    delegate void dg_SayHi();

    //再定义一个委托类，接收返回类型为int的方法
    delegate int dg_GetMaxAndMin(int[] arr);

    //再定义一个委托类，接收返回类型为Person的方法
    delegate Person dg_GetMaxAgePer(Person[] perArr);

    //定义泛型委托, 这个委托接收比较不同对象大小的方法Compare， 委托方法的参数两个： t1,t2 ，比较这两个大小后返回 int数值
    public delegate int dg_GetMax<T>(T t1, T t2);

　　D, 这样，我们就可以在A步骤中添加委托参数，实现比较

  /// <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
        }

　　E, 更新按钮事件,使用我们刚写好的泛型委托：

  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(perArr, dg_GetMaxPer);

            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));

        }
View Code

　　F,运行查看效果：

　　

--------【以上Demo下载】-----------

4，匿名方法介绍：

　　使用Delegate的时候，很多时候没有必要单独去定义好一个普通的方法（上面例子中的Compare方法），因为这个方法也就只有Delegate会用，而且只用一次，这时候就适合用匿名方法。

  //三，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;
            });

5，委托Delegate编译以后就是一个类Class,这个类继承于 MulticastClass （多播委托）

　　我们用.NET Relfector反编译，查看委托实质：

　　--------- ------------　

　A, 委托的实质是类，继承于多播委托MulticastDelegate，MulticastDelegate继承于System.Delegate类

　

　　B, objSayHi += SayHiEN； 这段代码的实质是： 把两个集合中的方法都存放到一个集合中，然后返回

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

　　上面把方法添加到委托中，编译后就是下面的这样：

　　

总结： 本文了解委托，并使用委托作为方法进行传递，又接触到了泛型和匿名方法，借助反编译器查看委托的实质。

【本文完整Demo下载】

参考：

返回委托中方法的值：http://m.blog.csdn.net/blog/lrz8745/7325056

 http://www.cnblogs.com/linlf03/archive/2011/05/09/2041657.html

实用插件：Indent Guides 插件  代码中显示虚竖线

　　　　　

 

　

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：【.NET基础】--委托、事件、线程（2）

下一篇：.NET逻辑分层架构总结

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签