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 

----->>>>任重而道远，这艰辛路上怎能没有你的支持和鼓励。