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