C#基础之------委托


一、委托的基本介绍

可以任务委托是持有一个或多个方法的对象。当然,正常情况下你不会去执行一个对象,但是委托与对象不同。可以执行委托,这是委托就会执行他所"持有"的方法。

举个栗子就如同 你媳妇让你去买两个包子,  你就是那个 委托  ,买包子是你所持有的方法,当然这样举得栗子稍有不妥,但是能帮助理解一些委托的基本概念。

委托的概述:

委托与对象的对照
声明类型 声明类 声明委托(类型)
声明类型的变量 声明类类型的变量 声明委托类型的变量
填充变量
创建累的实例并且把

它的引用赋值给变量


创建委托的实例并且把

它的实例赋值给变量并且

添加一个方法

使用变量 使用类对象 调用委托
二、委托的基本使用

1.委托的声明:

委托就好像类一样,必须要在创建变量及类型前声明。

 delegate  void  Demo(int x)

delegate  :委托的关键字

void:返回类型

Demo:委托类型名

(int x):签名

2.创建委托对象:

创建委托变量

Demo Mydemo;

创建委托对象

Mydemo=new Demo(实例名.方法)
Mydemo=new Demo(类名.方法)

创建委托对象要有委托名,括号内的是添加到委托内的方法,可以是实例方法也可以是静态方法。

我们还可以使用快捷语法类进行委托的创建,它只有 方法说明符构成。

Mydemo=实例名.方法
Mydemo=类名.方法

可以这样做的原因是 方法名称和其相应的委托类型之间存在隐式转换。

3.给委托赋值:

因为委托是引用类型,我们可以给委托赋值来改变包含在委托变量内的引用,改变之后,原有的委托对象会被垃圾回收器回收。

Mydemo=InsertObj.other1

4.组合委托:

委托是可以使用额外的运算符来“组合”。这个运算会创建一个新的委托,其调用列表连接了作为操作数的两个委托的调用列表副本。

Mydemo demo1=Mathod.Mym1;
Mydemo demo2=Sclass.Mym2;
Mydemo demo3=demo1+demo2;

组合委托总觉得好像操作数被改变一样。事实上委托是恒定的,委托对象被创建后不能再被改变。

(图示中的方法与代码不同,意义一样。)

5.向委托添加方法:

运算符: +=

Mydemo demo=inst.Mym1;
demo+=scl.m3;
demo+=x.act;

当为委托添加方法的时候,其实委托是不可变的,当向委托中添加方法的时候是其实是生成一个新的委托。

所以向委托中添加了三个方法后的结果其实是变量指向一个全新的委托。

6.移除方法:

运算符: -=

移除方法与添加方法一样,本质上都是创建了一个新的委托,新的委托是旧的委托的副本----值是没有了已经被移除方法的引用。

7.调用委托:

Mydemo demo=inst.Mym1;
demo+=scl.m3;
demo+=x.act;demo(123);//调用委托

如果一个方法在委托中出现多次那么,每次在执行列表中遇到方法的时候都会被执行一次。

8.完整委托实例:

delegate void Mydele(string str);
    public class Myclass
    {
        public void PritStr1(string str)
        {
            Console.WriteLine(str);
        }
        public static void PritStr2(string str)
        {
            Console.WriteLine(str);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Myclass cla = new Myclass();
            Mydele dele = cla.PritStr1;//实例化委托

            //给委托添加方法
            dele += Myclass.PritStr2;
            //调用委托
            dele("测试一下");
            Console.ReadKey();
        }
    }

9.带返回值的委托:

 delegate int Mydele();
    public class Myclass
    {
        int str = 10;
        public int PritStr1()
        {

            return str+=1;
        }
        public  int PritStr2()
        {

            return str+=2;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Myclass cla = new Myclass();
            Mydele dele = cla.PritStr1;//实例化委托

            //给委托添加方法
            dele += cla.PritStr2;
            //调用委托
            Console.WriteLine("返回值是:{0}",dele());
            Console.ReadKey();
        }
    }

10.调用使用引用参数的委托:

对于委托中的引用参数与 在方法中是一样的。参数传递的值地址,所以在每一个方法内对数值的操作都会体现出来。

 delegate void Mydele(ref int x);
    public class Myclass
    {
        public void PritStr1(ref int x)
        {
            x += 2;
        }
        public void PritStr2(ref int x)
        {
            x += 1;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Myclass cla = new Myclass();
            Mydele dele = cla.PritStr1;//实例化委托

            //给委托添加方法
            dele += cla.PritStr2;
            //调用委托
            int x = 5;
            dele(ref x);
            Console.WriteLine("X的值是{0}",x);
            Console.ReadKey();
        }
    }
三、关于委托的一些延伸

匿名方法:

匿名方法的产生是因为在程序中有的方法只需要执行一次,本着最大限度节省时间、节省人力的奋斗方针,程序猿大牛们发明了---匿名方法。一种不需要声明、创建实例、配合委托直接使用的方法。

——>普通具名方法(low到爆啊)

  delegate int Mydele(int x);
    public class Myclass
    {
        public int PritStr1( int x)
        {
            x += 2;
            return x;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Myclass cla = new Myclass();
            Mydele dele = cla.PritStr1;//实例化委托

            Console.WriteLine("X的值是{0}",dele(10));
            Console.WriteLine("X的值是{0}", dele(1));
            Console.ReadKey();
        }
    }

——>匿名方法(高富帅)

 class Program
    {
        delegate int Mydele2(int x);
        static void Main(string[] args)
        {

            Mydele2 dele = delegate(int x)
            {
                return x + 10;
            };
            Console.WriteLine("X的值是{0}", dele(1));
            Console.ReadKey();
        }
    }  

匿名方法的语法:

匿名方法的主要语法包括:

1.delegate, 关键字。

2.参数列表,如果语句块没有任何参数则可以省略。

3.语句块,包含匿名方法的代码。

1.返回类型

匿名方法不会显示声明返回值,实现匿名方法的时候必须返回一个类型与委托返回类型相同的值。如果委托声明的是Void,那么匿名方法就不能有返回值。

这一点是遵从于委托的基本概念,  参数 与返回类型都需要与委托声明的时候相符合才可以。

2.参数

方法签名必须与委托相符合。

签名包括:    1.参数数量    2.参数类型及位置    3.修饰符

省略参数列表的前提是: 1.委托参数不包含任何out修饰符。   2.匿名方法不适用任何参数。

3.Params参数

委托类型声明的时候最后一个参数必须是Params

匿名参数的列表是可以忽略Params关键字的

delegate void Mydele(int x,params int[]  y);
Mydele dele=delegate(int x,int[] y)
{
//具体代码
};

4.匿名方法变量的作用域

  • 外围作用域的变量叫做外部变量。
  • 用在匿名方法实现代码中的外部变量成为方法捕获。
delegate void Mydele(int x,params int[]  y);
int xx=5;
Mydele dele=delegate(int x,int[] y)
{
//具体代码
console.writeline("捕获:{0}",xx);//使用了外部变量

};
console.writeline("{0}",x);//编译错误,超出作用域

Lambda表达式:

拉姆达表达式其实就是 委托和匿名方法的 2.0    变得更加简洁方便。

Mydele dele= delegate(int x)      {return x+1;};//匿名方法
Mydele dele=         (int x) =>   {return x+1;};//省略delegate 使用=>(goes to)
Mydele dele=             (x) =>   {return x+1;};//省略类型
Mydele dele=               x =>   {return x+1;};//省略圆括号
Mydele dele=               x =>    x+1;         //省略return 

----->>>>任重而道远,这艰辛路上怎能没有你的支持和鼓励。
时间: 2024-10-16 04:13:22

C#基础之------委托的相关文章

C# 1的核心基础之一——委托

C# 1的核心基础之一--委托 C# 1的核心基础之一--委托简单委托的构成合并和删除委托事件的简单讨论委托总结 简单委托的构成 声明委托类型: delegate void StringProcessor(string input); 为委托实例的操作找到一个恰当的方法 void PrintString(string x)完全符合要求 void PrintInteger(int x)参数类型不兼容 void PrintTwoStrings(string x, string y)参数个数不匹配 i

[.net 面向对象编程基础] (21) 委托

[.net 面向对象编程基础] (20)  委托 上节在讲到LINQ的匿名方法中说到了委托,不过比较简单,没了解清楚没关系,这节中会详细说明委托. 1.什么是委托? 学习委托,我想说,学会了就感觉简单的不能再简单了,没学过或都不愿了解的人,看着就头大,其实很简单.委托在.net面向对象编程和学习设计模式中非常重要,是学习.net面向对象编程必须要学会并掌握的. 委托从字面上理解,就是把做一些事情交给别人来帮忙完成.在C#中也可以这样理解,委托就是动态调用方法.这样说明,就很好理解了. 平时我们会

【.NET基础】--委托、事件、线程(3)

之前的两篇文章我们了解了委托和事件,本文我们看一下线程. 1,一个窗体程序,默认拥有一个线程(相当于一个商店里面,只有一个店员),这个默认的线程叫做 UI线程/主线程. 2,进程和线程的关系: A,进程,包含程序运行所需要的资源 ,在大多数情况下是指 程序.(商店:囤积要使用的资源的地方) B,线程,是在进程中能够被CPU调用的程序单元,是提供给CPU运行程序的代码片段.(商店员工:是运行程序的行动者) C,一个进程至少一个线程,每一个线程有自己专属的寄存器(栈指针.程序计数器等)但代码区是共享

[C#基础]说说委托+=和-=的那些事

写在前面 为什么会突然想说说委托?原因吗,起于一个同事的想法,昨天下班的路上一直在想这个问题,如果给委托注册多个方法,会不会都执行呢?为了一探究性,就弄了个demo研究下. += 大家都知道委托都继承自System.MulticastDelegate,而System.MulticastDelegate又继承自System.Delegate,可以通过+=为委托注册多个方法.那么他们是否都执行了呢?执行的结果又是怎样的呢?有返回值和没返回值的是否结果是否一样?那就试着说说+=都干了哪些事? 测试代码

C#基础系列——委托实现简单设计模式

前言:上一篇介绍了下多线程的相关知识:C#基础系列--多线程的常见用法详解,里面就提到了委托变量.这篇简单介绍下委托的使用.当然啦,园子里面很多介绍委托的文章都会说道:委托和事件的概念就像一道坎,过了这个槛的人,觉得真是太容易了,而没有过去的人每次见到委托和事件就觉得心里发慌.确实这东西就像最开始学C语言的指针一样,令人有一种很纠结的感觉,总觉得要调用一个方法直接调用就行了,为啥非要定义一个委托时执行这个方法呢.其实在C#里面很多的技术都是为了重用和简化代码而生,委托也不例外,很多使用C#多态去

C#基础学习——委托

using System; namespace Test { public delegate void TryDelegate(string name); public class SayHello{ public void SpeakChinese(string name){ Console.WriteLine("你好,"+name); } public void SpeakEnglish(string name){ Console.WriteLine("Hello,&qu

C#基础:委托

委托是C#中最为常见的内容.与类.枚举.结构.接口一样,委托也是一种类型.类是对象的抽象,而委托则可以看成是函数的抽象.一个委托代表了具有相同参数列表和返回值的所有函数.比如: delegate int GetCalculatedValueDelegate(int x, int y); 在上面的定义中,我们定义了一个委托,这个委托代表着一类函数,这些函数的第一个参数是整数型的x,第二个参数是整数型的y,而函数的返回值则是一个整数.在这里,为了描述方便,我们把这一类的函数称为具有相同签名(sign

C#基础系列——委托和设计模式(二)

此篇简单抽取了几个设计模式分别按照多态和委托的方式去实现,当然这里的重点并不是讲设计模式,而是为了使读者更好地理解委托.所以设计模式的很多细节,本篇可能会略过. 一.简单工厂模式:本篇就借助计算器的例子加以说明. 1.多态实现简单工厂模式. class Program2 { static void Main(string[] args) { //1.使用多态实现简单工厂模式 int x = 8, y = 2; var iRes1 = GetObject("+").Compute(x,

js基础-事件委托

让利用事件冒泡的原理,让自己的所触发的事件,让他的父元素代替执行! <!DOCTYPE html> <html> <head> <title>事件委托</title> </head> <body> <ul id="ul"> <li class="item">11</li> <li class="item">22<

[C#基础知识]委托详解

1. 委托是什么? 个人认为,可以从以下2点来理解:  (1) 从数据结构来讲,委托是和类一样是一种用户自定义类型. (2) 从设计模式来讲,委托(类)提供了方法(对象)的抽象. 既然委托是一种类型,那么它存储的是什么数据? 我们知道,委托是方法的抽象,它存储的就是一系列具有相同签名和返回回类型的方法的地址.调用委托的时候,委托包含的所有方法将被执行. 2. 委托类型的定义 委托是类型,就好像类是类型一样.与类一样,委托类型必须在被用来创建变量以及类型对象之前声明. delegate void