C#新语法

        //7.1.2委托语法糖，编译时 会自动 new一个 Action委托来装 这个 匿名方法
        list.ForEach(delegate(C01Dog d){
            Console.WriteLine(d.Name + "," + d.Age);
        });

    } 
    #endregion

    #region 7.2 系统泛型委托 - Predicate - 返回bool
    ///
    /// 7.2 系统泛型委托 - Predicate - 返回bool
    ///
    static void TestPredicate()
    {
        List list = GetDogList();
        //list = list.FindAll(new Predicate(delegate(C01Dog d) { return d.Age > 1; }));
        //使用FindAll方法，可以帮我们 根据条件 筛选 出一个新的集合
        list = list.FindAll(delegate(C01Dog d) { 
            return d.Age > 1; 
        });

        list.DeleteItem(delegate(C01Dog d) {
            return d.Age == 2;
        });

        list.ForEach(delegate(C01Dog d) { Console.WriteLine(d.Name + "," + d.Age); });

        //List listNew = list.MyFindAll(delegate(C01Dog d) { return d.Age > 1; });
    } 
    #endregion

    #region 7.2 自己实现一个 根据条件查找的 方法 - Predicate - 返回bool
    ///
    /// 自己实现一个 根据条件查找的 方法
    ///
    static List MyFindAll(this List list, Predicate predicate)
    {
        //创建新集合
        List newList = new List();
        //遍历老集合
        foreach (T item in list)
        {
            //如果老集合里的 item 符合 条件，则 把item 添加到 新集合中
            //调用传入的 predicate委托 方法，作为 是否符合条件的判断
            if (predicate(item))
            {
                newList.Add(item);
            }
        }
        return newList; 
    } 
    #endregion

    #region 7.2 自己实现一个 根据条件删除的 方法 - Predicate - 返回bool值的委托
    ///
    /// 7.2 自己实现一个 根据条件删除的 方法 - Predicate - 返回bool值的委托
    ///
    static void DeleteItem(this List list, Predicate deleteWhere)
    {
        //要删除的元素集合
        List deletedItems = new List();
        //遍历 数据集合 根据条件找到要删除的元素 添加到 删除元素集合中
        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
    ///
    /// 7.3 系统泛型委托 - Comparison - 返回 int
    ///
    static void TestComparison()
    {
        List 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 - 自定义返回值类型
    ///
    /// 7.4 系统泛型委托 - Func - 自定义返回值类型
    ///
    static void TestFunc()
    {
        List list = GetDogList();
        //业务：完整写法：将 dog集合 转成 smallDog集合

        //7.4.1 使用集合的扩展方法 Select 生成一个新的集合，传入 Func 委托对象
        var it2 = list.Select(new Func(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 list2 = list.MySelect(
            new Func(delegate(C01Dog d)
        {
            return new C02SmallDog() { Name = d.Name };
        })
        );

        //7.4.4 模拟一个Select方法，直接传入匿名方法
        List listNew = list.MySelect(delegate(C01Dog d)
        {
            return new C02SmallDog() { Name = d.Name };
        });
    } 
    #endregion

    #region 7.4 自己模拟一个 Select 方法，用来将一个集合转成另一个集合
    ///
    /// 7.4 自己模拟一个 Select 方法，用来将一个集合转成另一个集合
    ///
    static ListMySelect(this Listlist, Funcfunc)
    {
        ListlistNew = new List();
        //遍历老集合元素
        foreach (T1 item in list)
        {
            //调用 func 委托 将 老集合元素 转成 另一个 元素 返回
            TR re = func(item);
            //将转换后的 新元素 ，存入新集合
            listNew.Add(re);
        }
        //返回新集合
        return listNew;
    } 
    #endregion

    #region 7.4* 系统泛型委托 结合 匿名类使用 - Func - 自定义返回值类型
    ///
    /// 7.4* 系统泛型委托 结合 匿名类使用 - Func - 自定义返回值类型
    ///
    static void TestFuncRetrunAnoyClassList()
    {
        List list = GetDogList();
        //业务：完整写法：将 dog集合 转成 只包含狗名字的 对象 集合
        //使用 Select 方法 遍历 list集合，并转成 一个 匿名类对象 的集合
        //                              (返回真实对象类型为： WhereSelectListIterator)
        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
    ///
    /// 8.0 Lambda表达式 和 语句Lambda
    ///
    static void TestLambda()
    {
        List list = GetDogList();
        list.ForEach(new Action(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 查询方法
    ///
    /// 8.2 标准查询运算符 - Where 查询方法
    ///
    static void SQOWhere()
    {
        List list = GetDogList();
        //在集合中 筛选出 青壮年 公狗们
        List 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 投射方法（返回一个 新的集合）
    ///
    /// 8.3 标准查询运算符 - Select 投射方法（返回一个 新的集合）
    ///
    static void SQOSelect()
    {
        List list = GetDogList();

        List listNew = list.Select(d => new C02SmallDog() { Name = d.Name }).ToList();
    }
    #endregion

    #region 8.4 标准查询运算符 - Order 排序方法
    ///
    /// 8.4 标准查询运算符 - Order 排序方法
    ///
    static void SQOOrder()
    {
        List list = GetDogList();
        //8.4.1 升序排列
        //List listSorted = list.OrderBy(d => d.Age).ToList();
        //8.4.2 降序排列
        //List listSorted = list.OrderByDescending(d => d.Age).ToList();
        //8.4.3 多条件排序
        //List listSorted = list.OrderBy(d => d.Age).ThenBy(d => d.ID).ToList();
        //8.4.4 多条件倒序
        List listSorted = list.OrderBy(d => d.Age).ThenByDescending(d => d.ID).ToList();

        listSorted.ForEach(d => Console.WriteLine(d.ToString()));
    }
    #endregion

    #region 8.5 标准查询运算符 - Join 连接集合
    ///
    /// 8.5 标准查询运算符 - Join 连接集合
    ///
    static void TestJoin()
    {
        List listDog = GetDogList();
        List 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 为集合元素分组
    ///
    /// 8.6 标准查询运算符 - GroupBy 为集合元素分组
    ///
    static void SQOGroupBy()
    {
        List list = GetDogList();
        //按照集合中 狗的 性别 分组
        //IEnumerable> it = list.GroupBy(d => d.Gender);
        //按照集合中 狗的 姓名 分组
        var it = list.GroupBy(d=>d.Name);
        //将 小组迭代器 转成 小组 集合
        IList> listGroup = it.ToList();
        //遍历 小组
        foreach (IGrouping group in listGroup)
        {
            //输出 小组 的 分组条件
            Console.WriteLine("小组：" + group.Key);
            //遍历 小组里 所有的 元素
            foreach (C01Dog item in group)
            {
                Console.WriteLine(item.ToString());
            }
            Console.WriteLine("-----------------------------------------");
        }
    } 
    #endregion

    #region 8.7 标准查询运算符 - Skip + Take 分页数据
    ///
    /// 8.7 标准查询运算符 - Skip + Take 分页数据
    ///
    static void SQOPagedList()
    {
        List 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 GetPagedListByIndex(List list,int pageIndex)
    {
        int pageSize = 2;
        return list.Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
    }
    #endregion

    #region 9.0 Linq 语句
    ///
    /// 9.0 Linq 语句 : 编译后，会生成 对应 的 标准查询 运算符！ 所以说，Linq只是类似与sql的一种更加友好的 语法糖 语法而已。
    ///
    static void TestLinq()
    {
        List list = GetDogList();
        List 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
}