.NET 新语法

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;
        }
    }
}