5语法基础_Lamda,扩展方法,匿名类，linq的使用

目录：

　　1、lambda演变史及其使用

　　2、自定义自己的Linq扩展方法

　　3、linq就是微软方便开发者在c#快捷的对数据做处理 封装好的一个linq语法

 

1、lambda演变史及其使用

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

namespace MyLinq
{
 
    public class LambdaShow
    {
        public delegate void NoReturnNoPara();
        public delegate void NoReturnWithPara(string x, string y);//1 声明委托
        public delegate int WithReturnNoPara();
        public delegate string WithReturnWithPara(out int x, ref int y);
        private void DoNothing()
        {
            Console.WriteLine("This is DoNothing");
        }

        private void Study(string x, string y)
        {
            Console.WriteLine("This is Study");
        }
        public void Show()
        {
            //lambda演变历史
            {
                //.NetFramework1.0/1.1时代 
                NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
                NoReturnWithPara noReturnWithPara = new NoReturnWithPara(this.Study);
                noReturnWithPara.Invoke("1", "1");
            }

            int i = 10;
            {
                //.NetFramework2.0  匿名方法，增加了一个delgate关键字 可以访问局部变量
                NoReturnWithPara noReturnWithPara = new NoReturnWithPara(delegate (string x, string y)
                {
                    Console.WriteLine(i);
                    Console.WriteLine("This is Study");
                });
                noReturnWithPara.Invoke("1", "1");
            }
            { 
                Console.WriteLine("***********************.NetFramework3.0****************************");
                //.NetFramework3.0  去掉delegate关键字，添加了一个=>  goes to
                NoReturnWithPara noReturnWithPara = new NoReturnWithPara((string x, string y) =>
                {
                    Console.WriteLine(i);
                    Console.WriteLine("This is Study");
                });
                noReturnWithPara.Invoke("1", "1");
            }
            {
                NoReturnWithPara noReturnWithPara = new NoReturnWithPara((x, y) => // 通过委托自动推断来的（语法糖）
                {
                    Console.WriteLine(i);
                    Console.WriteLine("This is Study");
                });
                noReturnWithPara.Invoke("1", "1");
            }
            {
                NoReturnWithPara noReturnWithPara = new NoReturnWithPara((x, y) => Console.WriteLine("This is Study")
                );
                noReturnWithPara.Invoke("1", "1");
            }
            {
                NoReturnWithPara noReturnWithPara = (x, y) => Console.WriteLine("This is Study");
                noReturnWithPara.Invoke("korey", "杰克");
            }
            {
                Action<string, string> action = (x, y) => Console.WriteLine($"{x}_{y}");
                Action<string> action1 = x => Console.WriteLine($"{x}"); // 如果只有一个参数的时候，可以省略小括号 
                Func<string, string> func = x => "1";  //如果有返回值，而且方法体只有一行，可以省略return; 

                Func<string> func1 = () => "1";  //如果有返回值，而且方法体只有一行，可以省略return;
            }
            //lambda表达式就是什么？
            //其实是一个方法， 在中间语言中，为其分配了一个方法名称；
            // 通过反编译之后，发现Lambda表达式生成在一个名称为<> 密封类中的一个方法； 

            {
                //lambda在多播委托相同lambda表达式 其实生成的是不同的方法名字
                NoReturnWithPara noReturnWithPara = new NoReturnWithPara(this.Study);
                noReturnWithPara += this.Study;
                noReturnWithPara += (x, y) =>
                {
                    Console.WriteLine($"{x}_{y}");
                };
                noReturnWithPara -= this.Study;
                noReturnWithPara -= (x, y) => { Console.WriteLine($"{x}_{y}"); };  //尽管移除了 但是 还是会输出
                noReturnWithPara("1", "1");
                //lambda表达式在多播委托中不能被移除？ 
                // 是的 因为在通过反编译查看的时候 lambda生成的其实是两个不同名字的方法
                   

            }
            
        }

    

    }
}

2、扩展方法的使用,固定套路：1定义静态类 2静态方法 3第一个参数前使用this

    public static class linqtoSB
    {
        public static void linqToSbs<T>(this List<T> t)
        {
            Console.WriteLine("做自己的扩展方法啊逻辑");
        }
    }
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {

            List<string> list = new List<string>();

            list.linqToSbs(); 
} 
} 
}

3、linq就是微软方便开发者快速对数据做处理 封装好的一个语法

// Linq To Xml：封装通用对Xml文件的操作，可变的逻辑通过委托来传递
// Linq To sql：封装通用的sql操作 https://www.cnblogs.com/jara/p/3473996.html不知道怎么写Linq查询看这里

上面都是通过 扩展方法+委托 把可变的逻辑封装组合  例如 linq.Where(x=>x.id==1

   var list = studentList.Where<Student>(s => s.Age < 30)//条件过滤
                                     .Select(s => new//投影
                                     {
                                         Id = s.Id,
                                         ClassId = s.ClassId,
                                         IdName = s.Id + s.Name,
                                         ClassName = s.ClassId == 2 ? "0" : "1"
                                     })

同下

   ///如果需要一个方法满足需求，那就是泛型方法
        /// <summary>
        /// 代码重用 
        /// </summary>
        /// <param name="resource"></param>
        /// <returns></returns>
        public static List<T> JerryWhere<T>(this List<T> resource, Func<T, bool> func)
        {
            var list = new List<T>();
            foreach (var item in resource)
            {
                if (func.Invoke(item)) //  /* if (item.Age < 30)*///bool //item做为一个参数  返回一个bool 
                {
                    list.Add(item);
                }
            }
            return list;
        }

)