抽象工厂3层模式
所谓的新语法，就是编译器给我们做了很多工作。
#region 4.0 匿名类 /// <summary> /// 4.0 匿名类 /// </summary> static void TestAnoyClass() { //4.1匿名类 编译后会生成一个 泛型类，包含：两个只读的变量 和 只读属性，并重写了 Object里的所有方法 var cla = new { Name = "James", Age = 18 }; //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()); //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
传递方法利用委托（delegate）。(匿名方法指的是藏匿名称的方法)
/// <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使用委托 语法糖（委托最后编译器会给我们 new ） 直接将 匿名方法 "赋值" 给 委托对象 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);// 原理就是替换 C01DogExtension.Pee(d, 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
namespace P02NewProgramer { /// <summary> /// Dog 类的扩展方法 /// </summary> public static class C01DogExtension（为啥采用static类，缩小查找范围） { /// <summary> /// 扩展方法 的 第一个参数 加 this，这个this只是一个编译时的 标示符（标记） /// 优先调用 对象的 实例方法，没有的话才调用 扩展方法 /// 当编译器 遇到 dog.Pee(DateTime.Now)调用时，那么 会 去 dog对象对应的 Dog类里去找 Pee方法 /// 如果找到了，则调用类里的实例方法，如果没找到，就去当前程序的【扩展方法表】里去找。 /// </summary> public static void Pee(this C01Dog d,DateTime dtNow) { Console.WriteLine(d.Name + ",age=" + d.Age + ",time=" + dtNow.ToString()); } } }
namespace P02NewProgramer { public class C01Dog { public int ID { get; set; } public string Name { get; set; } public int Age { get; set; } public bool Gender { get; set; } public override string ToString() { return "{ID="+ ID + ",name=" + Name + ",age=" + Age + ",Gender=" + Gender+"}"; } public void Pee2(DateTime dtNow) { Console.WriteLine("实例方法="+Name + ",age=" + Age + ",time=" + dtNow.ToString()); } } }
namespace P02NewProgramer { public class FlowDog:C01Dog { } }
#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
Func图解，映射关系
#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()); } } } #endregion