lambda表达式 泛型委托 委托 匿名函数 系统自带的泛型委托

在使用的时候，如果要使用带返回值 带参数的的委托，则用Func<>

如果需要使用带参数不带返回值的委托，则用系统的Action<>

如果需要使用不带参数不带返回值的委托，则用系统的Action

注意：Func<>中的参数只有一个的时候，参数是返回值，当有多个参数的时候，最后一个参数是返回值，其他是参数。

下边的是代码来实现这一些功能：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            #region 匿名方法和lamnda表达式

            
            //匿名方法的使用
            MyDelegate md = delegate () {
                //这就是匿名函数的函数体
                Console.WriteLine("aaaaaaa");               
            };
            md();//执行该匿名函数
            // 有参数没有返回值
            MyDelegate1 md1 = delegate (string str) {
                Console.WriteLine("hello  " + str);
            };
            md1("wbs");
            //有参数有返回值的匿名函数
            AddDelegate ad = delegate (int n1, int n2, int n3) {
                return n1 + n2 + n3;
            };
            Console.WriteLine(ad(3, 4, 5));
           
            //没有参数没有返回值的匿名方法使用Lambda表达式
            MyDelegate lmd = () => {//=>右边是方法体
                //里面是方法体
                Console.WriteLine("lambda表达式");               
            };
            lmd();//执行该lambda表达式
            //有参数没有返回值的方法使用Lambda表达式           
            MyDelegate1 lmd1 = (m) => {//这儿的m是参数，不用加（）也可以,即直接写m=>{};
                //lambda表达式不需要传递数据类型，因为在用delegate定义委托的时候已经定义了参数的类型
                Console.WriteLine("参数是    " + m);
            };
            lmd1("a");
            //有参数有返回值的lambda表达式
            AddDelegate addlmd = (x, y, z) => { return x + y + z; };
            int result = addlmd(10, 20, 30);
            Console.WriteLine("结果是    "+result);
            //带参数带返回值的lambda表达式
            AddDelegate1 addlmd2 = (arr) => {
                for(int i = 0; i < arr.Length; i++) { Console.Write(arr[i]); }
                return arr.Sum();//返回数组的和
            };
            Console.WriteLine("的和为     " + addlmd2(1, 2, 3, 4, 5));
            #endregion



            #region 系统自带的泛型            
            //需要保存一个无参数无返回值的方法
            Action a = M;//action的非泛型委托是一个屋返回值的委托
            a();
            //需要保存一个string类型的参数，但是没有返回值的方法
            MyDelegate<string> mdd = M;
            mdd("hello");
            Action<string> mddd = M;//action的泛型委托，是一个屋返回值，但是参数有多个，可以变化委托
            mddd("action 泛型委托");
            Action<string> lmdaction = m => { Console.WriteLine(m); };
            lmdaction("一个参数");
            Action<string,string > ss = (m, n) => { Console.WriteLine(m + "  " + n); };
            ss("两个参数", "bbbbbb");
            //如果要用有返回值的委托，但是不一定需要参数，用Func
            Func<int, int, int, int> fun = M2;//有多个参数，有一个返回值的，Func的参数只有一个的时候，这个参数只能是返回值，当有多个参数的时候，最后的一个参数是返回值
            int r = fun(1, 2, 3);
            Console.WriteLine("三个参数的Func"+r);
            //自己定义一个有输出参数的泛型
            int z1;
            MyDelegate3 md3 = M3;
            int b = md3(1, 2, out z1);
            Console.WriteLine(b + "   " + z1);
            #endregion


            #region 使用lambda表达式
            List<int> list = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            IEnumerable<int> er=list.Where(Condition);//返回大于6的个数
            foreach(var aa in er)
            {
                Console.WriteLine(aa);
            }
            //可以用lambda表达式简化上边的代码
            IEnumerable<int> err = list.Where(m => { return m > 6; });//当参数中需要传递一个委托的时候，用lambda表达式比匿名方法定义很方便
            //where中需要传递一个
            #endregion


            Console.ReadKey();
        }
        static bool Condition(int x)
        {
            //此方法是给list.where中的参数定义的方法、
            return x > 6;//在list集合中返回大于6的个数
        }
        public static int M2(int x,int y ,int z)
        {
            return x + y + z;
        }
        public static void M(string str)
        {
            Console.WriteLine(str);
        }
        public static  void M()
        {
            Console.WriteLine("action~~~");
        }
        public static int M3(int x,int y ,out  int z)
        {
            z = 99;
            return x + y + z;
        }
    }
    public delegate void MyDelegate();//定义一个委托
    public delegate void MyDelegate1(string str);
    public delegate int AddDelegate(int n1, int n2,int n3);
    public delegate int AddDelegate1(params int[] arr);
    public delegate void MyDelegate<T>(T args);//泛型委托,当多个委托的参数和返回类型不一致的时候，可以定义一个泛型委托，可以进行任意的参数和返回类型。
    //但是系统提供了泛型委托Action<>
    public delegate int MyDelegate3(int x, int y, out int z);//out参数是一个输出类型
}

 

这是最终的显示窗口，在学习的过程中可以变注释，边测试来学习

 

如果有疑问，直接留言哦^_^