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

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

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

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

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

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

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

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

　　　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

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

        }

　　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;

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

　　

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

参考：

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

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

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

　　　　　

　

时间： 2024-11-07 21:03:49

【.NET基础】--委托、事件、线程（1）的相关文章

4.net基础之委托事件

委托的声明public delegate void NoReturnNoPara();访问修饰符 delegate关键字 返回值 委托名委托的调用NoReturnNoPara nrnp = new NoReturnNoPara(传递方法名);传递的方法必须满足,没有返回值,没有参数的限制.实例方法,静态方法,虚方法nrnp.Invoke(); 泛型委托Func:接收0-17个输入参数,一个返回参数的泛型委托Action:接收0-17个输入参数,0个返回参数的泛型委托 委托的意义:解耦使用泛型+委

谈.Net委托与线程——解决窗体假死

引言 在之前的<创建无阻塞的异步调用>中,已经介绍过异步调用的编写步骤和实施原理.异步调用是CLR为开发者提供的一种重要的编程手段,它也是构建高性能.可伸缩应用程序的关键.在多核CPU越来越普及的今天,异步编程允许使用非常少的线程执行很多操作.我们通常使用异步完成许多计算型.IO型的复杂.耗时操作,去取得我们的应用程序运行所需要的一部分数据.在取得这些数据后,我们需要将它们绑定在UI中呈现.当数据量偏大时,我们会发现窗体变成了空白面板.此时如果用鼠标点击,窗体标题将会出现"失去响应&

[.net 面向对象编程基础] (22) 事件

[.net 面向对象编程基础] (22)  事件 事件(Event)是学习.net面向对象编程很重要的一部分,在学习事件之前,我们实际上已经在很多地方使用了事件,比如控件的click事件等,这些都是.net设计控件的时候已经定义好的事件.除此之外,我们同样可以自己定义事件. 事件实际上是一种消息机制,当然点击控件时,click就通知处理他的方法去处理,实际上就是前面说的委托.因此我们可以说:事件是一种具有特殊签名的委托.而事件/消息机制是windows的核心,因此我们必须掌握他. 为了更加容易理

C#解惑1——委托&amp;事件（转）

委托是一个类,它定义了方法的类型,使得可以将方法当作另一个方法的参数来进行传递,这种将方法动态地赋给参数的做法,可以避免在程序中大量使用If-Else(Switch)语句,同时使得程序具有更好的可扩展性. 委托和事件在.NET Framework[1]中的应用非常广泛,然而,较好地理解委托和事件对很多接触C#时间不长的人来说并不容易. 中文名 c#委托 外文名 Delegate 编程语言 C# 作    用 方便的引用被委托的方法 应    用 NET Framework 目录 1引言 2参数

C# 利用委托事件进行窗体间的传值（新手必看）

引言: 窗体间传值是每个学习WinForm新手的常见问题,最初级的方法就是 在窗体中先获取到要接受值窗体.然后通过.得到某个空间或者属性,直接赋值,这个需要接收放的窗体属性或者空间必须是public ,是极不安全的一种方式.在升级一下的新手做法就是在接受窗体中定义一个方法然后通过 调用这个方法来给某个控件或者属性赋值.这两种方法都是非安全的低级方式.非常不建议使用.本文我们讲讲如何通过委托事件(非单纯的委托)来解决窗体间信息传递的问题. 场景: 通过点击主主窗体From_Main的发送按钮,所有

JQuery基础修炼-事件篇

目录 第1章 事件介绍 第2章 鼠标事件 第3章 表单事件 第4章 键盘事件 第5章 事件的绑定和解绑 第6章 事件对象的使用 第7章 自定义事件 click与dbclick事件 用交互操作中,最简单直接就是点击操作.jQuery提供了两个方法一个是click方法用于监听用户单击操作,另一个方法是dbclick方法用于监听用户双击操作.这两个方法的用户是类似,下面以click()事件为例 使用上非常简单: 方法一:$ele.click() 绑定$ele元素,不带任何参数一般是用来指定触发一个事件

C#委托事件

1.委托事件关键词:delegate 2.在声明函数的时候在函数类型后面加上 例:public delegate int Test(int x,int y) 3.定义委托变量:Test t1,委托接收的是方法引用. 4.委托变量可以当成函数的调用.用赋值“=” 委托变量 = 函数名 5.委托类型的变量,可以引用任何一个满足要求的方法,类似于C语言的函数指针. 6.一个委托变量可以使用“+=”挂接多个方法,也能使用“-=”动态地移除某个方法的引用. 7.引用多个方法的委托变量称为“多路委托”. 8

观察者（Observer）模式 * 委托事件

观察者(Observer)模式:定义了一种一对多的依赖关系.让多个观察者对象同时监听某一个主题对象.   这个主题对象发生变化时会通知所有观察者对象,使他们字段更新自己 /* * 抽象主题(Subject)角色:主题角色把所有对观察考对象的引用保存在一个聚集里,每个主题都可以有任何数量的观察者. 抽象主题提供一个接口,可以增加和删除观察者对象,主题角色又叫做抽象被观察者(Observable)角色,一般用一个抽象类或者一个接口实现. * 抽象观察者(Observer)角色:为所有的具体观察者定义

C# 委托 / 跨线程访问UI / 线程间操作无效: 从不是创建控件“Form1”的线程访问它

C# 委托 / 跨线程访问UI /  线程间操作无效: 从不是创建控件"Form1"的线程访问它 网上的代码都比较复杂,还是这个简单 见代码, 简易解决办法: 主窗体代码 using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; usi

Jquery基础之事件操作

事件是用户操作时页面或页面加载时引发的用来完成javascript和HTML之间的交互操作.常见的元素点击事件.鼠标事件.键盘输入事件等,较传Javascript 相比JQuery增加并扩展了基本的事件处理机制,极大的增强了事件处理的能力. 一.DOM加载事件 页面加载完毕后浏览器会通过javascript为Dom元素加载事件,使用Javascript时候使用的是window.onload方法,而Jquery使用的是$(document).ready()方法,下表 展示两个事件的异同.    w