详细记录 委托、匿名方法到lambda的=＞转变过程

详细记录 委托、匿名方法到lambda的=>转变过程

一、委托

1、什么是委托 即将方法声明一个变量形式的别名

例如 委托类型 变量名= new 委托类型（方法名）// 不懂就先看代码

class Program
    {
        //1、定义委托
        delegate void MYdelegate(int x1, int x2);
        static void Main(string[] args)
        {
            MYdelegate d;//声明委托变量
            //Program()是构造函数 实例化Program类  
            //委托变量d绑定Add方法 就是包装/别名 即d就是add方法
            d = new MYdelegate(new Program().Add);
            d(3,4); //例如  可以这样调用
            MyMethod(d);//也可以将委托变量当参数传递
            Console.ReadKey();

        }

        //委托的方法 方法的定义与委托相同 即返回类型和参数的类型、个数相同
        void Add(int x1, int x2)
        {
            int sum = x1 + x2;
            Console.WriteLine("两个数的和为：" + sum);
        }
        //方法参数是委托类型
        private static void MyMethod(MYdelegate myd)
        {
            //在方法中调用委托
            myd(1, 2);
        }
    }

委托就是方法定义一个别名 或者说包装成一个变量了 且可以作为参数传递给其他方法

2、常用的Func委托（系统定义好了 直接用于封装方法 比较常用）
Func委托：可以带有一个返回值的方法，它可以传递0或者多到16个参数类型，和一个返回类型。

public delegate TResult Func<in T, out TResult>(T arg);
//Func后面可以跟很多类型，最后一个类型则是返回值类型
//前面的类型为参数类型
static int Test2(string str)
{
    Concole.WriteLine(str);
    return 1;
}
static void Main()
{
    Func<stirng, int> a = Test2;
    Concole.WriteLine(a("Test"));
}

Func委托 只是将委托给封装一下 改变了形式 将参数和返回类型封装成泛型T

二、匿名方法

1、什么是匿名方法
就是没有定义名字的方法 因为没有名字所以只能在定义的时候被调用

例1、有名字的方法

        delegate void VoteDelegate(string name);
        static void Main(string[] args)
        {

            VoteDelegate voteDelegate = new VoteDelegate(new Friend().Vote);
            voteDelegate("Somebody");
            Console.Read();
        }
        public class Friend
        {
            public void Vote(string nickname)
            {
                Console.WriteLine("姓名为：{0}来帮我你投票啦", nickname);
            }
        }

改写例1
将Vote方法变成匿名函数

 delegate void VoteDelegate(string name);
        static void Main(string[] args)
        {

            VoteDelegate voteDelegate = delegate (string nickname)
            {
                Console.WriteLine("姓名为：{0}来帮我你投票啦", nickname);
            };
            voteDelegate("Somebody");
            Console.Read();
        }

三、Lambda表达式的演变 =>

1、=>读作 “goes to”
个人理解：lambda表达式就是匿名方法和委托的结合

  static void Main(string[] args)
        {
            //C#1.0   创建参数为string返回类型为int 的委托实例
            Func<string, int> delegatetest1 = new Func<string, int>(Callbackmethod);
            //C#2.0   用匿名方法创建委托实例
            Func<string, int> delegatetest2 = delegate (string text)
            {
                return text.Length;
            };
            //C#3.0
            Func<string, int> delegatetest3 = (string text) => text.Length;

            //可以省略参数
            Func<string, int> delegatetest4 = (text) => text.Length;
            //
            Func<string, int> delegatetest5 = text => text.Length;

            Console.WriteLine("使用lambda表达式返回字符传的长度为："+delegatetest5("sabcjbcsnbavb"));
            Console.Read();
        }
        //委托的回调方法
        private static int Callbackmethod(string text)
        {
            return text.Length;
        }

原本的表达式越来越简洁 但更不容易理解啦
只需要记住 “=>”的做左边是参数 右边是表达式即函数主体就好啦

四、简单的应用

 delegate int myDel(int a);
        static void Main(string[] args)
        {

            myDel myDelegate = x => x * x;
            int j = myDelegate(5);
            Console.Write(j);
            Console.ReadKey();
        }

或者

 static void Main(string[] args)
        {
            Func<int, int> myDeint;
            myDeint = x => x * x;
            int j = myDeint(5);
            Console.Write(j);
            Console.ReadKey();
        }

以上两个输出结果都是25
可以对比一下 Func和delegate的用法