委托（作用：解耦），lambda的演化

1.了解委托

　　MyDelegate类代码如下：

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace MyDelegate

{

    /// <summary>

    /// 委托可以定义在类外面

    /// </summary>

    public delegate void OutNoReturnNoPara();

    public delegate void OutNoReturnWithPara(int x, int y);

    class DelegateClass

    {

        /// <summary>

        /// 1.声明委托，委托的参数与函数的参数必须一致

        /// </summary>

        public delegate void NoReturnNoPara();

        public delegate void NoReturnWithPara(int x, int y);

        public delegate string NoPara();

        public delegate DateTime WithPara(string name,int size);

        public static void Show()//静态方法的委托只能调用静态方法

        {

            //2.实例化委托，这里的method实例化后就是一个Plus函数

            NoReturnWithPara method = new NoReturnWithPara(Plus);//等价于NoReturnWithPara method = Plus;

            //3.调用委托

            method.Invoke(, );//等价于method(3, 4);

            method.BeginInvoke(, ,null,null);//补充：新建一个线程，异步调用

        }

        public static void Plus(int x,int y)

        {

            Console.WriteLine("这里是Plus  x={0}  y={1}", x, y);

        }

    }

}

　　在Program使用DelegateClass.Show();

　　可以调用Plus这个方法

2.委托的用处

　　1）打招呼===》普通方法

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace MyDelegate

{

    class GreetingClass

    {public static void Greeting(string name,PeopleType type)//输入和谁打招呼，和这个人是哪个国家的人

        {

            if(type==PeopleType.Chinese)

            {

                Console.WriteLine("{0}早上好", name);

            }

            else if(type==PeopleType.English)

            {

                Console.WriteLine("{0}Morning", name);

            }

            else

            {

                throw new Exception("wrong PeopleType");

            }

        }

    }public enum PeopleType //枚举，定义国家

    {

        Chinese,English

    }

}

　　在Program使用GreetingClass.Greeting("kxy",PeopleType.Chinese);//kxy是一个中国人，所以使用PeopleType.Chinese

可以实现给不同国家的人打招呼用对应国家的语言

　　但是如果我们需要增加一种语言，则需要修改枚举PeopleType和函数Greeting

　　2）打招呼===》委托方法

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace MyDelegate

{

    class GreetingClass

    {

        public static void GreetingChinese(string name)

        {

            Console.WriteLine("{0}早上好", name);

        }

        public static void GreetingEnglish(string name)

        {

            Console.WriteLine("{0}Morning", name);

        }

    }

    public delegate void GreetingHandler(string name);

}

　　Program代码如下：

 GreetingHandler handle = new GreetingHandler(GreetingClass.GreetingEnglish);//指明是哪国人

 handle("flt");//输入人的名字

　　当需要增加一种新的语言时，直接增加一个Greeting*******函数就可以了，解除耦合

3.lambda的演化

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace MyDelegate

{

    public class Student

    {

        public delegate void NoReturnWithPara(string name, DateTime now);

        /// <summary>

        /// 匿名函数向lambda演化的过程

        /// </summary>

        public static void show()

        {

            //普通委托

            NoReturnWithPara method = new NoReturnWithPara(Study);

            //使用匿名函数

            NoReturnWithPara method1 = new NoReturnWithPara(

                delegate (string name, DateTime now)

                {

                    Console.WriteLine("{0} {1}在学习", name, now);

                });

            //匿名函数向lambda演化,去掉delegate，加入=>

            NoReturnWithPara method2 = new NoReturnWithPara(

                (string name, DateTime now)=>

                {

                    Console.WriteLine("{0} {1}在学习", name, now);

                });

            //匿名函数向lambda演化,去掉类型，因为委托函数会自动标识类型

            NoReturnWithPara method3 = new NoReturnWithPara(

                (name, now) =>

                {

                    Console.WriteLine("{0} {1}在学习", name, now);

                });

            //匿名函数向lambda演化,去掉new，这也是最终形式

            NoReturnWithPara method4 = (name, now) =>

                {

                    Console.WriteLine("{0} {1}在学习", name, now);

                };

            //匿名函数向lambda演化,如果方法体只有一行，可以去掉大括号

            NoReturnWithPara method10 = (name, now) => Console.WriteLine("{0} {1}在学习", name, now);

            method10("zjx",DateTime.Now);

        }

        public static void Study(string name, DateTime now)

        {

            Console.WriteLine("{0} {1}在学习",name,now);

        }

    }

}

4.其他多种委托使用lambda

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace MyDelegate

{

    public class Student

    {

        public delegate void NoReturnWithPara(string name, DateTime now);

        public delegate int WithReturnWithPara(int x,int y);

        public delegate string WithReturnNoPara();

        /// <summary>

        /// 委托向lambda演化的过程

        /// </summary>

        public static void show()

        {//没有参数，返回一个string类似,可以省略return和大括号

            WithReturnNoPara meth = () => "我爱学习";

            //有两个int参数，返回int类型

            WithReturnWithPara meth2 = (x, y) => x + y;

            ///////////////////////////在开发中基本不需要自己定义委托，可以使用下面方法/////////////////////////////////

            //Action是一个委托，无返回值  <定义参数类型>

            Action action1 = () => { };//无参数无返回值

            Action<string> action2 = s =>{ };//有参数无返回值，且只有一个参数时可以去掉参数的小括号

            Action<int, string, DateTime> action3 = (x, y, z) => { };//可以有多个参数，自定义

            //Func是一个委托，有返回值  <定义参数类型，和返回值类型>

            Func<string> func1 = () => "我爱学习"; //<只有一个类型>,该类型是指返回值类型

            Func<string, int, DateTime> func2 = (x, y) => DateTime.Now;//<参数类型，参数类型，返回值类型>

        }

    }

}

5.lambda向linq的扩展

public static void LinqShow()

        {

            //-----------------------定义一个1到99的数组-------------------------

            List<int> intlist = new List<int>();

            for(int i=;i<;i++)

            {

                intlist.Add(i);

            }

            //-----------------------打印大于55的数字----------------------------

            //-----------------------传统方法-----------------------------------

            foreach(int i in intlist)

            {

                if(i>)

                {

                    Console.WriteLine(i);

                }

            }

            //-----------------------linq方法-----------------------------------

            var linq = from s in intlist

                       where s >

                       select s;

            foreach(int i in linq)

            {

                Console.WriteLine(i);

            }

            //-----------------------linq方法扩展为lambda------------------------

            foreach (int i in intlist.Where<int>(m => m > ))

            {

                Console.WriteLine(i);

            }

            //上面foreach可详写为：

            foreach (int i in intlist.Where<int>(//Where是Linq下的一个Func委托，有返回值

                (m) => { return m > ; }//匿名函数，使用lambda表达式

                )

                )

            {

                Console.WriteLine(i);

            }

        }

巴特西

委托（作用：解耦），lambda的演化

最新文章

热门文章