C#-委托 lambda 匿名方法 匿名类型

1.lambda 匿名方法 匿名类型

delegate void d1();
d1 d = delegate(){Console.WriteLine("this is a test");};                //使用匿名方法
d1 d += ()=>{Console.WriteLine("this_test2");};                         //使用lambda表达式

var q1 = new {name= "jing",age=25};                                     //匿名类型必须和var配合用
var q2 = from c in a where c.age <20 select new {c.name,c,age = 21};    //匿名类型必须和var配合用
var q3 = a.Where(c => c.age<20).Select(c=>c.name)                       //lambda表达式必须在linq                                         的投影语法中，lambda后面可以使用匿名类型，因为前面有var

匿名方法是委托常用方法的简化

lambda表达式是匿名方法的简化

他们都是包装了委托的意义，但是传递的其实都是方法，特别是有特色的lambda表达式，简化的写法有返回值

可以直接用需要返回值方法的地方

可以直接这样理解：因为lambda表达式传递的是方法，所以要么赋给其他委托来执行，要么放在可以执行方法的地方直接执行（这样返回的就是return回来的东西）

委托里面是方法的引用（指针），把委托给事件，就是把方法的引用给了事件

Event是delegate的抽象和封装，Event提供了安全的方法向delegate对象添加和删除方法

C#定义的三个泛型委托

Func<Tint,Tout> 有参数0-16个，有返回值

Predicate<T>    有参数1个，有bool返回值

Action<T>          有参数0-16个，无返回值

        static void Main(string[] args)
        {
            var arr = new List<int>() { -1, -2, -3, 0, 1, 2, 3, 4, 5, 6 };
            var d1 = new Predicate<int>(More);
            var d2 = new Predicate<int>(Less);
            var a1 = new Func<int,string>(Speak);

            string aa = a1(1123);
            Console.WriteLine(aa);

            Print(arr, d1);
            Print(arr, d2);
            Console.WriteLine("已经全部打印完了，请指示下一步操作");
            Console.ReadKey();
        }
        static string Speak(int i)
        {
            return (i ).ToString();          
        }

        static void Print(List<int> aa, Predicate<int> dl)
        {
            foreach (var item in aa)
            {
                if (dl(item))
                {
                    Console.WriteLine(item);
                }
            }
        }
        static bool More(int i)
        {
            if (i > 0)
            {
                return true;
            }
            return false;
        }
        static bool Less(int i)
        {
            if (i < 0)
            {
                return true;
            }
            return false;
        }

    }

委托的一个实例

delegate void Speak(int i );   // 声明一个委托
spike jy = new spike();    //  声明一个对象

jy.lower += speak;           //  给委托附加方法
jy.lower += delegate  { Console.WriteLine("this is very crazy man!"); };   //  给委托添加匿名方法
jy.lower += (int i )=> Console.WriteLine("sadjfoisajfdoijsadofjodsaj");//匿名方法lambda表达式方式写法
jy.to(10);

我记得委托 +=的时候会覆盖前一个方法的，为什么在执行的时候没有覆盖前一个方法？

我好像记得有一个地方是这样的，但是委托确实是多赋方法，一次运行多个方法的

来自为知笔记(Wiz)