using System;using System.Collections.Generic;using System.Linq;using System.Text;using P03MyStringExtension;namespace P02NewProgramer{    static class Program    {        static void Main(string[] args)        {            //2.1调用带参数默认值的方法，编译后会自动添加默认值到这个方法括号中            //TestParaDefault();            //2.2通过 命名参数 调用 此方法            //TestParaDefault(19);            //使用 命名参数 为 方法的指定参数 赋值，其它的使用默认值            //TestParaDefault(gender: true);            TestLinq();            Console.ReadLine();        }        //var 变量不能 作为  全局变量 使用！        //var a = 123;        #region 1.0 隐式变量        /// <summary>        /// 1.0 隐式变量        /// </summary>        static void TestVar()        {            var a = 1;            a = a + 2;            //a = "";            var b = "";            b = "123123";            Console.WriteLine(b);        }         #endregion        #region 2.0 带默认值的参数        /// <summary>        /// 带默认值的参数        /// </summary>        static void TestParaDefault(int age = 18, bool gender = false)        {            Console.WriteLine(age + ",性别：" + gender);        }        #endregion        #region 3.1属性初始化器        /// <summary>        /// 3.1属性初始化器        /// </summary>        static void TestInitialProperty()        {            //3.1属性初始化器            C01Dog d = new C01Dog() { Name = "小花花~~", Age = 2 };            Console.WriteLine(d.Name);            //编译后相当于            C01Dog d1 = new C01Dog();            d1.Name = "小花花~~";            d1.Age = 2;        }         #endregion        #region 3.2集合初始化器        /// <summary>        /// 3.2集合初始化器        /// </summary>        static void TestInitialCollection()        {            //3.2集合初始化器            List<C01Dog> list = new List<C01Dog>() {                new C01Dog(){ Age=1, Name="小白01"},                new C01Dog(){ Age=2, Name="小白02"},                new C01Dog(){ Age=3, Name="小白03"}            };            //编译后相当于             List<C01Dog> list1 = new List<C01Dog>();            list1.Add(new C01Dog() { Age = 1, Name = "小白01" });            list1.Add(new C01Dog() { Age = 2, Name = "小白02" });            list1.Add(new C01Dog() { Age = 3, Name = "小白03" });        }         #endregion        #region 4.0 匿名类        /// <summary>        /// 4.0 匿名类        /// </summary>        static void TestAnoyClass()        {            //匿名类的作用：临时封装一组数据使用                        //4.1匿名类 编译后会生成一个 泛型类，包含：两个只读的变量 和 只读属性，并重写了 Object里的所有方法            var cla = new { Name = "James", Age = 18 };            //cla.Name = "hahah";            //4.2如果另一个 匿名类对象 的属性 类型 和 顺序 一样，那么会共用同一个匿名类！            var cla2 = new { Name = "James2", Age = 19 };            Console.WriteLine(cla.GetType() == cla2.GetType());//true            //4.3如果另一个聂明雷对象 的属性 名称 和 顺序一样，但 类型不一样，那么 还是使用相同的匿名类，只不过，泛型参数改变而已            var cla3 = new { Name = 123, Age = "James3" };            Console.WriteLine(cla3.GetType()==cla2.GetType());            //因为： 传入不同类型参数 的 泛型类，在运行时，会生成不同的类            //List<string> listStr = new List<string>();            //List<int> listInt = new List<int>();            //Console.WriteLine("两种泛型集合：" + (listStr.GetType() == listInt.GetType()));//false            //4.4如果 属性名相同，类型相同，但是 顺序不同，那么也会重新创建一个 匿名类！            //        属性个数不同，也会生成另一个 匿名类！            var cla4 = new { Age = 19, Name = "James4" };            Console.WriteLine(cla4.GetType() == cla2.GetType());//false            Console.WriteLine(cla.Name + ":" + cla.Age + ",cla=" + cla.ToString());        }         #endregion        /// <summary>        /// 内部类        /// </summary>        public delegate void DGTest(string str);        #region 5.0 匿名方法        /// <summary>        /// 匿名方法        /// </summary>        static void TestAnnoyMethod()        {            //匿名方法，编译后：会生成一个  编译器取名的 静态 方法，和一个 静态的 委托对象            //作用：一次性使用的方法            //5.1使用委托 直接 指定 命名方法            //DGTest dg = new DGTest(TestMethod);            //5.2使用委托 传入 匿名方法            DGTest dg2 = new DGTest(delegate(string str) { Console.WriteLine("我是匿名方法~~跟我过，有好日子！"); });            //DGTest dg21 = new DGTest(匿名方法);            //5.3使用委托 语法糖 直接将 匿名方法 "赋值" 给 委托对象            DGTest dg3 = delegate(string g) { Console.WriteLine(g); };            //5.4最重要的用法：向InvokeAMethod方法中 传入 匿名方法            InvokeAMethod(delegate(string a) { Console.WriteLine("匿名方法驾到~~！" + a); });            InvokeAMethod(delegate { Console.WriteLine("我哈哈哈哈~~~！"); });        }         #endregion        static void InvokeAMethod(DGTest dg)        {            dg("哈哈啊");        }        static void TestMethod(string str)        {         }        #region 6.0 扩展方法        /// <summary>        /// 6.0 扩展方法        /// </summary>        static void TestExtensionMethod()        {            //List<C01Dog> list = new List<C01Dog>() {             //    new C01Dog(){ Age=1, Name="小白01"},            //    new C01Dog(){ Age=2, Name="小白02"},            //    new C01Dog(){ Age=3, Name="小白03"}            //};            //IEnumerable<C01Dog> enu = list.Where(delegate(C01Dog d) { return d.Age > 1; });            //foreach (C01Dog d in enu)            //{            //    Console.WriteLine(d.Name + "," + d.Age);            //}            C01Dog d = new C01Dog() { Name="小白", Age=2 };            d.Pee(DateTime.Now);            //6.1 编译后： 就是直接调用 这个静态方法！并将当前对象 作为第一个参数 传入！            //C01DogExtension.Pee(d, DateTime.Now);            //6.2 可以 让空引用 调用扩展方法，但要注意：如果扩展方法中使用了传入的实例，则会报异常：空指针异常            C01Dog d2 = null;            d2.Pee(DateTime.Now);            //6.3 当扩展方法 在其他程序集里时，需要先添加引用，并在当前类中 导入命名空间            string str = "哇哈哈哈~~";            str.TestMyString();            //6.4 扩展方法可以被"继承"~~            FlowDog fd = new FlowDog();            fd.Pee(DateTime.Now);        }         #endregion        static List<C01Dog> GetDogList() {            return new List<C01Dog>() {                new C01Dog(){ID=1, Age=12, Name="小白02", Gender=true},                new C01Dog(){ID=6, Age=21, Name="小白", Gender=true},                new C01Dog(){ID=2, Age=21, Name="小白", Gender=true},                new C01Dog(){ID=3, Age=3, Name="小白03", Gender=true},                new C01Dog(){ID=4, Age=39, Name="小白03", Gender=false},                new C01Dog(){ID=5, Age=13, Name="小白05", Gender=false}            };        }        static List<C02DogToy> GetDogToyList()        {            return new List<C02DogToy>() {                 new C02DogToy(){ DogID=1,ToyName="狗骨头"},                new C02DogToy(){ DogID=2,ToyName="飞盘"},                new C02DogToy(){ DogID=3,ToyName="沙发"},                new C02DogToy(){ DogID=2,ToyName="球"},                new C02DogToy(){ DogID=1,ToyName="羽毛球"}            };        }        #region 7.1 系统泛型委托 - Action 委托 - 无返回值        /// <summary>        /// 7.1 系统泛型委托 - Action 委托        /// </summary>        static void TestAction()        {            List<C01Dog> list = GetDogList();            //7.1.1调用 List 集合的 ForEach 方法 遍历 集合，每次遍历 一个元素 就会调用一下 传入的 Action委托，并将 元素传入Action参数            list.ForEach(new Action<C01Dog>(delegate(C01Dog d) { Console.WriteLine(d.Name + "," + d.Age); }));            //7.1.2委托语法糖，编译时 会自动 new一个 Action委托来装 这个 匿名方法            list.ForEach(delegate(C01Dog d){                Console.WriteLine(d.Name + "," + d.Age);            });        }         #endregion        #region 7.2 系统泛型委托 - Predicate - 返回bool        /// <summary>        /// 7.2 系统泛型委托 - Predicate - 返回bool        /// </summary>        static void TestPredicate()        {            List<C01Dog> list = GetDogList();            //list = list.FindAll(new Predicate<C01Dog>(delegate(C01Dog d) { return d.Age > 1; }));            //使用FindAll方法，可以帮我们 根据条件 筛选 出一个新的集合            list = list.FindAll(delegate(C01Dog d) {                 return d.Age > 1;             });            list.DeleteItem<C01Dog>(delegate(C01Dog d) {                return d.Age == 2;            });            list.ForEach(delegate(C01Dog d) { Console.WriteLine(d.Name + "," + d.Age); });            //List<C01Dog> listNew = list.MyFindAll<C01Dog>(delegate(C01Dog d) { return d.Age > 1; });        }         #endregion        #region 7.2 自己实现一个 根据条件查找的 方法 - Predicate - 返回bool        /// <summary>        /// 自己实现一个 根据条件查找的 方法        /// </summary>        static List<T> MyFindAll<T>(this List<T> list, Predicate<T> predicate)        {            //创建新集合            List<T> newList = new List<T>();            //遍历老集合            foreach (T item in list)            {                //如果老集合里的 item 符合 条件，则 把item 添加到 新集合中                //调用传入的 predicate委托 方法，作为 是否符合条件的判断                if (predicate(item))                {                    newList.Add(item);                }            }            return newList;         }         #endregion        #region 7.2 自己实现一个 根据条件删除的 方法 - Predicate - 返回bool值的委托        /// <summary>        /// 7.2 自己实现一个 根据条件删除的 方法 - Predicate - 返回bool值的委托        /// </summary>        static void DeleteItem<T>(this List<T> list, Predicate<T> deleteWhere)        {            //要删除的元素集合            List<T> deletedItems = new List<T>();            //遍历 数据集合 根据条件找到要删除的元素 添加到 删除元素集合中            foreach (T item in list)            {                if (deleteWhere(item))//根据 传入的 条件 找到要删除的元素                {                    deletedItems.Add(item);                }            }            //遍历要删除的元素，在数据集合中删除            foreach (T delItem in deletedItems)            {                list.Remove(delItem);            }        }         #endregion        #region 7.3 系统泛型委托 - Comparison - 返回 int        /// <summary>        /// 7.3 系统泛型委托 - Comparison - 返回 int        /// </summary>        static void TestComparison()        {            List<C01Dog> list = GetDogList();            list.Sort(delegate(C01Dog x, C01Dog y)            {                return y.Age - x.Age;            });            list.ForEach(delegate(C01Dog d)            {                Console.WriteLine(d.Name + "," + d.Age);            });        }         #endregion        #region 7.4 系统泛型委托 - Func - 自定义返回值类型        /// <summary>        /// 7.4 系统泛型委托 - Func - 自定义返回值类型        /// </summary>        static void TestFunc()        {            List<C01Dog> list = GetDogList();            //业务：完整写法：将 dog集合 转成 smallDog集合            //7.4.1 使用集合的扩展方法 Select 生成一个新的集合，传入 Func<T,TResult> 委托对象            var it2 = list.Select(new Func<C01Dog, C02SmallDog>(delegate(C01Dog d) { return new C02SmallDog(); }));            //7.4.2 使用集合的扩展方法 Select 生成一个新的集合，直接传入 匿名方法            var it3 = list.Select(delegate(C01Dog d) { return new C02SmallDog(); });            //7.4.3 模拟一个 Select 方法，传入Func委托            List<C02SmallDog> list2 = list.MySelect<C01Dog, C02SmallDog>(                new Func<C01Dog, C02SmallDog>(delegate(C01Dog d)            {                return new C02SmallDog() { Name = d.Name };            })            );            //7.4.4 模拟一个Select方法，直接传入匿名方法            List<C02SmallDog> listNew = list.MySelect<C01Dog, C02SmallDog>(delegate(C01Dog d)            {                return new C02SmallDog() { Name = d.Name };            });        }         #endregion        #region 7.4 自己模拟一个 Select 方法，用来将一个集合转成另一个集合        /// <summary>        /// 7.4 自己模拟一个 Select 方法，用来将一个集合转成另一个集合        /// </summary>        static List<TR> MySelect<T1, TR>(this List<T1> list, Func<T1, TR> func)        {            List<TR> listNew = new List<TR>();            //遍历老集合元素            foreach (T1 item in list)            {                //调用 func 委托 将 老集合元素 转成 另一个 元素 返回                TR re = func(item);                //将转换后的 新元素 ，存入新集合                listNew.Add(re);            }            //返回新集合            return listNew;        }         #endregion        #region 7.4* 系统泛型委托 结合 匿名类使用 - Func - 自定义返回值类型        /// <summary>        /// 7.4* 系统泛型委托 结合 匿名类使用 - Func - 自定义返回值类型        /// </summary>        static void TestFuncRetrunAnoyClassList()        {            List<C01Dog> list = GetDogList();            //业务：完整写法：将 dog集合 转成 只包含狗名字的 对象 集合            //使用 Select 方法 遍历 list集合，并转成 一个 匿名类对象 的集合            //                              (返回真实对象类型为： WhereSelectListIterator<TSource, TResult>)            var it = list.Select(delegate(C01Dog d) {                 return new { Age = d.Age, Date = DateTime.Now };             });            var listNew = it.ToList();        }        #endregion        #region 8.0 Lambda表达式 和 语句Lambda        /// <summary>        /// 8.0 Lambda表达式 和 语句Lambda        /// </summary>        static void TestLambda()        {            List<C01Dog> list = GetDogList();            list.ForEach(new Action<C01Dog>(delegate(C01Dog d) { Console.WriteLine(d.Name); }));            //8.0.1 Lambda 表达式            list.ForEach(d => Console.WriteLine(d.Name));            list.FindAll(d => d.Age > 1);            list.Sort((x, y) => x.Age - y.Age);            var it = list.Select(d => new C02SmallDog() { Name = d.Name });            //8.0.2 语句Lambda            var it2 = list.Select(d =>            {                C02SmallDog sd = new C02SmallDog();                sd.Name = d.Name;                return sd;            });        }         #endregion        #region 8.2 标准查询运算符 - Where 查询方法        /// <summary>        /// 8.2 标准查询运算符 - Where 查询方法        /// </summary>        static void SQOWhere()        {            List<C01Dog> list = GetDogList();            //在集合中 筛选出 青壮年 公狗们            List<C01Dog> listDog = list.Where(d => d.Gender == true && d.Age > 3 && d.Age < 39).ToList();            listDog.ForEach(d => Console.WriteLine(d.ToString()));        }         #endregion        #region 8.3 标准查询运算符 - Select 投射方法（返回一个 新的集合）        /// <summary>        /// 8.3 标准查询运算符 - Select 投射方法（返回一个 新的集合）        /// </summary>        static void SQOSelect()        {            List<C01Dog> list = GetDogList();            List<C02SmallDog> listNew = list.Select(d => new C02SmallDog() { Name = d.Name }).ToList();        }        #endregion        #region 8.4 标准查询运算符 - Order 排序方法        /// <summary>        /// 8.4 标准查询运算符 - Order 排序方法        /// </summary>        static void SQOOrder()        {            List<C01Dog> list = GetDogList();            //8.4.1 升序排列            //List<C01Dog> listSorted = list.OrderBy(d => d.Age).ToList();            //8.4.2 降序排列            //List<C01Dog> listSorted = list.OrderByDescending(d => d.Age).ToList();            //8.4.3 多条件排序            //List<C01Dog> listSorted = list.OrderBy(d => d.Age).ThenBy(d => d.ID).ToList();            //8.4.4 多条件倒序            List<C01Dog> listSorted = list.OrderBy(d => d.Age).ThenByDescending(d => d.ID).ToList();            listSorted.ForEach(d => Console.WriteLine(d.ToString()));        }        #endregion        #region 8.5 标准查询运算符 - Join 连接集合        /// <summary>        /// 8.5 标准查询运算符 - Join 连接集合        /// </summary>        static void TestJoin()        {            List<C01Dog> listDog = GetDogList();            List<C02DogToy> listToy = GetDogToyList();            //把 Dog集合 与 Toy集合 连接生成一个新的集合            //连接查询                                on d.ID  =    t.DogID            //返回的结果是一个 匿名类集合，程序员可以手动 的控制 返回集合里 使用 联合查询两个集合 里的 的哪些属性            var listJoined = listDog.Join(listToy, d => d.ID, t => t.DogID, (d, t) => new { DogId = d.ID, DogName = d.Name, ToyName = t.ToyName }).ToList();            listJoined.ForEach(a => Console.WriteLine(a.ToString()) );                    }         #endregion        #region 8.6 标准查询运算符 - GroupBy 为集合元素分组        /// <summary>        /// 8.6 标准查询运算符 - GroupBy 为集合元素分组        /// </summary>        static void SQOGroupBy()        {            List<C01Dog> list = GetDogList();            //按照集合中 狗的 性别 分组            //IEnumerable<IGrouping<bool, C01Dog>> it = list.GroupBy(d => d.Gender);            //按照集合中 狗的 姓名 分组            var it = list.GroupBy(d=>d.Name);            //将 小组迭代器 转成 小组 集合            IList<IGrouping<string, C01Dog>> listGroup = it.ToList();            //遍历 小组            foreach (IGrouping<string, C01Dog> group in listGroup)            {                //输出 小组 的 分组条件                Console.WriteLine("小组：" + group.Key);                //遍历 小组里 所有的 元素                foreach (C01Dog item in group)                {                    Console.WriteLine(item.ToString());                }                Console.WriteLine("-----------------------------------------");            }        }         #endregion        #region 8.7 标准查询运算符 - Skip + Take 分页数据        /// <summary>        /// 8.7 标准查询运算符 - Skip + Take 分页数据        /// </summary>        static void SQOPagedList()        {            List<C01Dog> list = GetDogList().OrderBy(d => d.ID).ToList();            //假设 每页 2行            //获取第一页 数据            //var pageOne = list.Skip(0).Take(2);            var pageOne = GetPagedListByIndex(list,1);            Console.WriteLine("第一页 数据:");            pageOne.ForEach(i => Console.WriteLine(i.ToString()));            //获取第二页 数据            //var pageTwo = list.Skip(2).Take(2);            var pageTwo = GetPagedListByIndex(list,2);            Console.WriteLine("第二页 数据:");            pageTwo.ForEach(i => Console.WriteLine(i.ToString()));        }        static List<C01Dog> GetPagedListByIndex(List<C01Dog> list,int pageIndex)        {            int pageSize = 2;            return list.Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();        }        #endregion        #region 9.0 Linq 语句        /// <summary>        /// 9.0 Linq 语句 : 编译后，会生成 对应 的 标准查询 运算符！ 所以说，Linq只是类似与sql的一种更加友好的 语法糖 语法而已。        /// </summary>        static void TestLinq()        {            List<C01Dog> list = GetDogList();            List<C02DogToy> listToys = GetDogToyList();            //9.1 从 老集合中 查询 每一个 元素(d) 存入 新集合            var dogs1 = from d in list select d;            //9.2 where条件 从 老集合中 查询 所有 Gender = falser 的 元素，存入 新集合            //var dogs2 = select d from d in list where d.Gender == false ;            var dogs2 = from d in list where d.Gender == false select d;            //9.3 排序条件            var dogs3 = from a in list orderby a.Age orderby a.ID orderby a.Name descending select a;            //9.4 连接查询 注意：连接条件 使用  equals 关键字！！！            var joinedList = from a in list join t in listToys on a.ID equals t.DogID select new { Dog = a, Toy = t };            foreach (var item in joinedList)            {                Console.WriteLine(item.ToString());            }            Console.WriteLine("分组啦~~~-----------------------");            //9.5 分组查询            var groupList = from d in list group d by d.Gender;            foreach (var group in groupList)            {                Console.WriteLine(group.Key.ToString());                foreach (var item in group)                {                    Console.WriteLine(item.ToString());                }            }            //foreach (var d in list)                    }         #endregion    }    public class A    {        public A()        {            Program.DGTest dg = null;        }    }}