Unity 2-9 C#高级教程
任务1：字符串和正则表达式
任务1-1&1-2：字符串类string
System.String类（string为别名）
注：string创建的字符串是不可变的，一旦进行了初始化，就不能改变其内容了
string的声明：string s = "....";
字符串长度：int length = s.Length;
比较string大小：直接使用 == 即可：(s == "xxx")
字符串的连接：直接使用 + 即可：s = "..." + s;
这里s的修改不是直接修改其内容，而是重新赋值，耗费性能
-- 新建字符串用来存储连接后的字符串，并使引用s指向这个新字符串，旧的进入GC
字符串中按索引取得字符：s[index];
遍历字符串：for循环
常用方法：
CompareTo() -- 比较字符串内容，各个字符依次比较
若两个字符串相等则返回0，若当前字符串在字母表排序比较靠前则返回-1，否则返回1
s.CompareTo(s1); // 返回值为int，0表示相等，-1表示s靠前，1表示s靠后
应用：如人名的排序等
Replace() -- 用另一个字符或者字符串替换字符串中给定的字符或者字符串
string newS = s.Replace('a', 'b'); // replace 'a' with 'b'
string newS = s.Replace("a", "bbbb");
Split() -- 在出现给定字符的地方，把字符串拆分称一个字符串数组
string[] strArray = s.Split(','); // 通过','将字符串分割
SubString() -- 在字符串中检索给定位置的子字符串
"www.devsiki.com".SubString(4, 7);
// 从index=4之后的位置开始截取，长度为7的子字符串，devsiki
若不给定长度，则会一直取到原字符串结尾
ToLower()/ ToUpper() 把字符串转换成小写/大写形式
Trim() -- 删除首尾的空白
string newS = " adfa ad a ".Trim(); // "adfa ad a"
应用：如玩家在输入用户名的时候，首尾是不能有空格的
对于中间的空格而言，可以使用Replace(" ", "");
IndexOf() -- 取得字符串第一次出现某个给定字符串或者字符的位置
int index = s.IndexOf("dev"); // 返回第一个字符对应的index值，若不存在，则返回-1
Concat() -- 合并字符串
CopyTo() -- 把字符串中指定的字符复制到一个数组中
Format() -- 格式化字符串
Insert() -- 把一个字符串实例插入到另一个字符串实例的制定索引处
Join() -- 合并字符串数组，创建一个新字符串
任务1-3&1-4&1-5：StringBuilder类
Sysytem.Text.StringBuilder
StringBuilder类比string的效率更高：
比如StringBuilder.Append("xxx"); 和string之间的+号连接操作的比较：
string: 每次修改都需要开辟另外的存储空间
StringBuilder: 若当前空间足够，直接修改即可
创建：
StringBuilder sb = new StringBuilder("..."); -- 将一个string传递给构造函数
StringBuilder sb = new StringBuilder(20); -- 初始长度
StringBuilder sb = new StringBuilder("...", 100); -- 字符数量小于100时就不需申请内存
如果超过100个字符时，会重新申请一个200(2倍)的内存区域并赋值，删除原来的
一般来说，预估sb可能的大小，在进行初始化的时候申请该大小的内存区域
方法：
Append(string) -- 在字符串末尾追加一个字符串
sb.Append("xxx");
-- s = s + "xxx";
Insert(index, string) -- 从特定index开始插入字符串
sb.Insert(0, "http://");
Remove(startIndex, length) -- 从当前字符串中删除指定长度的字符串
sb.Remove(0, 3); // 删除前三个字符
Replace() -- 用某字符/字符串替换另一个字符/字符串
sb.Replace(".", "");
注意：sb.Replace('.', ''); 是不行的，不能替换成空字符，但是可以替换成空字符串
ToString() -- 将stringBuilder中存储的字符串，提取成一个(不可变的)string
任务1-6：VS插件Resharper
安装：VS中，工具 -> 扩展和更新 -> 联机 -> 搜索resharper -> 选择ReSharper(图标c#)
任务1-7：正则表达式及其方法
正则表达式 Regular Expression: 表述一个字符串的书写规则
用途：
1. 检索：通过正则表达式，从字符串中获取我们想要的部分
2. 匹配：判断给定的字符串是否符合正则表达式的过滤逻辑
等等：验证、提取、分割、替换等
正则表达式由元字符（普通字符和特殊字符）组成
（元字符在下一任务中详述）
常用的判断正则表达式的c#方法：
System.Text.RegularExpressions下的Regex类
IsMatch() -- 返回bool判断字符串是否匹配正则表达式
bool IsMatch(string input, string pattern);
参数: input: 要搜索匹配项的字符串。
pattern: 要匹配的正则表达式模式。
返回结果: 如果正则表达式找到匹配项，则为 true；否则，为 false。
bool IsMatch(string input, string pattern, RegexOptions options);
options: 枚举值的一个按位组合，这些枚举值提供匹配选项。
返回结果: 如果正则表达式找到匹配项，则为 true；否则，为 false。
bool IsMatch(input, pattern, RegexOptions options, TimeSpan matchTimeout);
matchTimeout: 超时间隔，或System.Text.RegularExpressions.
Regex.InfiniteMatchTimeout指示该方法不应超时。
返回结果: 如果正则表达式找到匹配项，则为 true；否则，为 false。
Match() -- 在字符串中搜索指定的正则表达式的第一个匹配项。
返回一个包含有关匹配的信息的对象。
Match Match(string input, string pattern);
Match Match(string input, string pattern, RegexOptions options);
Match Match(input, pattern, RegexOptions options, TimeSpan matchTimeout);
Matches() -- 与Match()不同的是，返回的是MatchCollection，包含所有的匹配项
重载方法的参数与Match()完全相同
Replace() -- 将匹配正则表达式的所有地方用新的字符串替换
Replace(string input, string pattern, string replacement)
input是源字符串，pattern是匹配的条件，replacement是替换的内容，
就是把符合匹配条件pattern的内容转换成replacement
如：string result = Regex.Replace("abc", "ab", "##");
//结果是##c,就是把字符串abc中的ab替换成##
Replace(input, pattern, replacement, RegexOptions options)
RegexOptions是一个枚举类型,用来做一些设定.
// 比如：如果在匹配时忽略大小写就可以用RegexOptions.IgnoreCase
Replace(input, pattern, MatchEvaluator evaluator);
evaluator是一个代理，简单而言是一个函数指针，把一个函数做为参数参进来
由于C#里没有指针就用代理来实现类似的功能。
可以用代理绑定的函数来指定你要实现的复杂替换.
Replace(input, pattern, MatchEvaluator evaluator, RegexOptions options);
关于Regex.Options：
Split() -- 在正则表达式匹配的位置，将文本拆分为一个字符串数组，并返回
string[] Split(string input, string pattern);
string[] Split(string input, string pattern, RegexOptions options);
string[] Split(input, pattern, RegexOptions options, TimeSpan matchTimeout);
@符号：避免编译器去解析字符串中的转义字符，而作为正则表达式的语法(元字符)存在
如：string s = @"www.baidu.com
lkjsdflkj"; -- 这里的
就是
，没有其他意义
任务1-8~1-13：特殊元字符 (定位元字符、基本语法元字符、反义字符、重复描述字符、择一匹配符、分组操作符)
定位元字符：
字符 说明
匹配单词的开始或结束
B 匹配非单词的开始或结束
^ 匹配必须出现在字符串的开头或行的开头
string str = "I am Blue cat";
Console.WriteLine(Regex.Replace(str, "^","开始:")); // "开始:I am Blue cat"
$ 匹配必须出现在以下位置：字符串结尾、字符串结尾处的
之前或行的结尾。
A 指定匹配必须出现在字符串的开头（忽略 Multiline 选项）。
z 指定匹配必须出现在字符串的结尾（忽略 Multiline 选项）。
z 指定匹配必须出现在字符串的结尾或字符串结尾处的
之前 (忽略 Multiline 选项)
G 指定匹配必须出现在上一个匹配结束的地方。
与 Match.NextMatch() 一起使用时，此断言确保所有匹配都是连续的。
基本语法元字符：
字符 说明
. 匹配除换行符以外的任意字符
w 匹配字母、数字、下划线、汉字 (指大小写字母、0-9的数字、下划线_)
W w的补集 （ 除“大小写字母、0-9的数字、下划线_”之外）
s 匹配任意空白符 (包括换行符/n、回车符/r、制表符/t、垂直制表符/v、换页符/f)
S s的补集 (除s定义的字符之外)
d 匹配数字 (0-9数字)
D 表示d的补集 (除0-9数字之外)
实例：
string input = Console.ReadLine();
string pattern = @"^d*$"; // 正则表达式: 全数字--因为d不是转义字符，需要@
if(Regex.IsMatch(input, pattern)） {
Console.WriteLine("Valid");
}
反义字符：
字符 说明
W
S
D
B 匹配不是单词开头或结束的位置
[^x] 匹配除了x以外的任意字符
[^adwz] 匹配除了adwz这几个字符以外的任意字符
中括号：
[ab] 匹配中括号中的字符
[a-c] a字符到c字符之间的字符 (a/b/c)
实例：查找除了ahou以外的所有字符
string strFind1 = "I am a Cat!", strFind2 = "My Name's Blue cat!";
Regex.Replace(strFind1/2, @"[^ahou]","*"));
// strFind1->**a**a**a*
// strFind2->****a*******u***a**
重复描述字符：
字符 说明
{n} 匹配前面的字符 =n次
{n,} 匹配前面的字符 >=n次
{n,m} 匹配前面的字符 n~m次
? 重复零次或一次 =0/1
+ 重复一次或更多次 >=1
* 重复零次或更多次 >=0
实例：校验输入内容是否为合法QQ号（备注：QQ号为5-12位数字)
string regexQq = @"^d{5,12}$";
择一匹配符：
字符 说明
| 将两个匹配条件进行逻辑“或”（Or）运算。
实例：
1. 查找数字或字母
string str = "ad(d3)-df";
string regexPattern = @"[a-z]|d";
MatchCollection newStr = Regex.Matches(str, regexPattern);
可用foreach(Match char in newStr) 来遍历得到的结果
2. 示例二：将人名输出（"zhangsan;lisi,wangwu.zhaoliu"）
string strSplit = "zhangsan;lisi,wangwu.zhaoliu";
string regexSplitstr = @"[;] | [,] | [.]";
// 使用string regexSplitstr = @"[;,.]"; 也可以
string[] resArray = Regex.Split(strSplit, regexSplitstr);
分组操作符：
用小括号来指定子表达式(也叫做分组)
实例：校验IP4地址 (如: 192.168.1.4, 为四段, 每段最多三位, 每段为0~255，且第一位不为0) string regex = @"^(((2[0-4]d|25[0-5]|[01]?dd?).){3}(2[0-4]d|25[0-5]|[01]?dd?))$";
Regex.IsMatch(inputStrIp4, regexStrIp4));
任务2：委托、Lambda表达式和事件
任务2-1&2-2：什么是委托
如果要把方法当做参数来传递的时候，就要通过委托
简单而言：委托是一个类型，可以赋值一个方法的引用给该类型
-- 之前的变量都是赋值数据的
委托的声明：
使用一个类的两个阶段：
定义类：告诉编译器这个类由什么字段和方法组成
定义后可以使用对象：用这个类去实例化对象
使用一个委托的两个阶段：
定义委托：告诉编译器这个委托可以指向哪些类型的方法
创建该委托的实例：
定义委托的语法：
delegate void IntMethodInvoker(int x);
定义了名为IntMethodInvoker的委托，指向的方法带有一个int参数，方法返回void
创建委托的实例/ 使用委托：
第一种创建委托的方式：构造函数
第一种使用委托的方式：通过委托名
private delegate string GetAString(); // 定义委托，指向的方法没有参数，返回string static void Main() { int x = 40; // 创建一个委托实例，指向对象x的ToString()方法，没有写() // 注：此时没有调用该方法，只是将委托stringMethod指向了x的ToString()方法 GetAString stringMethod = new GetAString(x.ToString); // 通过委托实例stringMethod来调用指向的方法 Console.WriteLine(stringMethod()); // 通过委托调用的方法，和直接调用方法的结果是一样的 }
第二种创建委托的方式：直接通过函数名
GetAString stringMethod = x.ToString;
第二种使用委托的方式：通过Invoke方法从而调用委托指向的方法
stringMethod.Invoke();
把委托类型的实例当做参数来使用：
private delegate void PrintString(); PrintString method = Method1; PrintStr(method); method = Method2; PrintStr(method); // 输出 "Method1 Method2" static void PrintStr(PrintString print) { print(); // 将PrintString类型的委托作为参数传入PrintStr方法 } static void Method1() { Console.WriteLine("Method1"); } static void Method2() { Console.WriteLine("Method2"); }
任务2-3：Action委托
除了上一节提到的自定义的委托类型，系统内置/预定义的委托类型：Action和Func
Action委托指向的是返回值为void，且没有参数的方法
Action a = MethodName;
Action委托的扩展<泛型>：可以指向返回值是void，而且有参数的方法 (最大支持16个参数)
-- 参数列表必须和指向的方法的参数列表顺序对应
Action<int> a = MethodName; // 有一个int参数
Action<int, bool> a = MethodName; // 有一个int和一个bool参数
-- 指向重载方法时，系统会自动匹配参数合适的方法
任务2-4：Func委托
Func委托指向的是有返回值，且没有参数的方法
Func<int> f = MethodName; // 必须有一个泛型，表示返回值类型
Func委托的扩展：可以指向有返回值，且有参数的方法 (最大支持16个参数)
Func<string, int> f = MethodName; // 参数为string, 返回值为int
-- 最后一个是返回类型，其他的都是参数类型
任务2-5&2-6：通用类型的方法 -- 实例：冒泡排序
冒泡排序：从小到大
第一轮开始：
0号与1号比较，若0号大，则0号和1号交换位置；
1号与2号比较，若1号大，则1号和2号交换位置；
以此类推，一轮过后，最大的数字被交换到数组的最后；
第二轮开始：
0号与1号比，一直比到n-2号与n-1号比
一轮过后，次大的数字被交换到数组的n-1处
n轮过后，数组有序
改进：
当进行一轮比较之后，没有数字发生位置交换，则判定已经为有序数组，终止循环
int类型的冒泡排序：
bool swapped = true; do{ swapped = false; for(int i =0;i<sortArray.Length -1;i++){ if(sortArray[i]>sortArray[i+1]){ int temp= sortArray[i]; sortArray[i]=sortArray[i+1]; sortArray[i+1]=temp; swapped = true; } } }while(swapped);
扩展-->通用的冒泡排序：通过泛型+委托的方式实现
实例：对雇员类Employee，按照Salary进行排序
class Employee{ public Employ(string name,decimal salary){ this.Name = name; this.Salary = salary; } public string Name{get;private set;} public decimal Salary{get;private set;} public static bool CompareSalary(Employee e1,Employee e2){ return e1.salary>e2.salary; } }
通过泛型定义排序方法：
// 1. 通过委托的方式将比较函数传递过来
// 2. 因为不同类的比较方法是不同的，故针对每个类写出对应的比较大小方法即可
见Employee.CompareSalary ()
// 3. 调用该方法的时候通过comparison委托将对应类的比较方法传入即可
public static void Sort<T> (List<T> sortArray, Func<T, T, bool> comparison)
public static void Sort<T>(T[] sortArray,Func<T,T,bool> comparision ){ bool swapped = true; do{ swapped = false; for(int i=0;i<sortArray.Count-1;i++){ if(comparision(sortArray[i+1],sortArray[i])){ T temp = sortArray[i]; sortArray[i]=sortArray[i+1]; sortArray[i+1]=temp; swapped = true; } } }while(swapped); }
使用：
static void Main(){ Employee[] employees = { new Employee("Bunny",20000), new Employee("Bunny",10000), new Employee("Bunny",25000), }; Sort<Employee>(employees, Employee.CompareSalary); }
任务2-7：多播委托
多播委托：指向了多个方法的委托
用处：使用多播委托，可以按照顺序调用多个方法，但是只能得到最后一个方法的结果
一般把多播委托的返回类型声明为void
多播委托包含一个逐个调用的委托集合，若其中一个抛出异常，整个迭代就会停止
如何进行多播委托：
Action action = Test1;
action += Test2; // 添加一个委托的引用给action
// 此时action() 会顺序执行Test1()和Test2()
action -= Test1;
// 删除引用，可以直接删除
action -= Test2;
// 报错 -- 当一个委托没有指向任何方法时，会出现空指针异常
如何取得多播委托中所有的委托：
Delegate[] delegates = action.GetInvocationList();
foreach(Delegate d in delegates) {
d.DynamicInvoke(null); // 单独调用 -- 如果需要参数，则需传递
}
任务2-8：匿名方法
之前使用委托都需要先定义一个方法，然后将方法指定给委托的实例。
匿名方法：
定义一个没有方法名的方法 -- 本质就是方法，只不过没有定义名字
用delegate关键字
不用声明返回类型，直接在方法中返回即可
Func<int,int,int> plus = delegate (int a,int b){ return a + b; }; int res = plus(34,34); Console.WriteLine(res);
匿名方法无法直接调用，只能通过委托进行调用
一般来说，匿名方法用于进行回调
任务2-9：Lambda表达式
Lambda表达式：匿名方法的简写形式
Lambda表达式的书写规则：
1. 不用写delegate
2. 不用写参数类型，因为在委托中已经定义了参数类型
3. 使用 => 表示这是一个Lambda表达式
实例：
Func<int,int,int> plus = delegate (int a,int b){ return a + b; }; --> Lambda Func<int,int,int> plus = (a,b)=> { return a + b; };
=>的左边列出了参数（只有一个参数的时候可以不写括号）；
=>的右边为匿名方法的方法体（只有一个语句时可以不写大括号；
且需要return的时候可以不写return关键字）
如：Func<int int> f = a => a+1; // 因为有返回值int，所以传入参数a，返回a+1
Lambda表达式外部的变量：
通过Lambda表达式可以访问外部的变量
如：int somVal = 5;
Func<int, int> f = x => x + somVal;
这个时候，如果没有正确使用，会变得非常危险：
因为一个方法的使用一般是通过传递的参数决定的
而由于可以访问外部变量，导致执行也会被外部变量的变化而影响，结果不可控
任务2-10：事件
之前学了委托：
实例：
class Program { public delegate void MyDelegate(); // 定义委托类型 public MyDelegate myDelegate; // 声明委托变量，作为成员变量 static void Main(string[] args) { Program program; program.myDelegate = Test(); // 委托指向方法 myDelegate(); // 调用委托指向的方法 } static void Test() { ... } }
事件(event)：具有特殊签名的委托，是类/对象向其他类/对象通知发生的事情的一种委托
事件基于委托，为委托提供了一个发布/订阅机制
实例 -- 在上例中修改
在声明委托变量的时候，加上event关键字
public event MyDelegate myDelegate; -- 这就是一个事件了
事件的性质：
1. 委托可以声明成一个局部变量，但是事件只能作为一个类的成员变量
2. 事件的命名一般为NameEvent
3. 事件的返回值是一个委托类型
任务2-11&2-12：观察者设计模式 && 委托和事件的区别
观察者设计模式：
有观察者和被观察者，当被观察者做出某个操作时，触发事件，所有观察者做出对应操作
例: Unity中，点击开始按钮 (被观察者)，很多方法如加载场景打开音乐 (观察者)就随之调用
实例：猫与老鼠
有三只动物，猫(名叫Tom),还有两只老鼠（Jerry和Jack）,当猫叫的时候，触发事件(CatShout)，然后两只老鼠开始逃跑(MouseRun)
猫类：
class Cat { private string name; public Cat(string name) { this.name = name; } public void CatShout() { // 被观察者的状态改变 Console.WriteLine(name + " mew); } }
鼠类：
class Mouse { private string name; public Mouse(string name) { this.name = name; } public void RunAway() { Console.WriteLine(name + " run away"); } }
Main()：
class Program { public static void Main(string[] args) { Cat cat = new Cat("Tom"); Mouse mouse1 = new Mouse("Jerry"); Mouse mouse2 = new Mouse("Jack"); cat.CatShout(); } }
这个时候Cat.CatShout()并不能将消息广播给Mouse
需要手动修改，在该函数中传递两个Mouse，并调用mouse.RunAway()
-- 无扩展性，若添加了其他老鼠，需要修改Cat的代码 -- 耦合性高
解决方法：优化1 -- 通过委托
在Cat中定义一个委托，让观察者将自己的对应操作添加到委托中
在CatShout()中调用这个委托即可
在Cat中：
public Action CatShouting; // 在CatShout()中调用这个委托 public void CatShout() { if(CatShouting!=null) { // 安全判断 CatShouting(); } }
在Main中：
cat.CatShouting += mouse1.RunAway; // 进行注册
优点：
如果有新的老鼠，直接在Main中注册即可，不需要改写Cat类
缺点：
每次新建观察者时，都需要进行注册
因为每一个观察者都需要进行注册
解决方法：优化2 -- 将猫的对象传给Mouse的构造函数，在构造函数中进行注册
在Mouse的构造函数中传入一个猫的对象
public Mouse(string name, Cat cat) {
cat.CatShouting += this.RunAway;
缺点：但是委托CatShouting在外界可以直接被调用
如在Main中调用 cat.CatShouting();
这就比较危险了
因为Cat自身的状态改变cat自己知道就好，不应该通过外界调用
解决方法：优化3 -- 通过事件
在Action的声明中加上event：
public event Action CatShoutingEvent; -- 命名规则+event
此时，这个事件就不能在外部通过类的对象进行调用了，只能在类内部进行调用
但是依然可以在外部进行注册
这里的CatShoutingEvent事件可以看做是在发布一个消息
Mouse()中的cat.CatShoutingEvent += this.RunAway; 可以看做是订阅了这个消息
-- 事件的发布/订阅机制
事件与委托的联系和区别：
1. 事件是一种特殊的受限制的委托，是委托的一种特殊应用
(不能在外部被调用的委托)
2. 常使用委托来进行回调
比如做一个动画，动画完成后进行操作：
因为动画需要时间来完成，因此传递给它一个委托，动画执行完后调用委托
这个委托指向的方法就叫回调函数
常使用事件来进行外发接口，给其他类进行注册
任务3：LINQ -- 数据查询
任务3-1&3-2：LINQ的基础使用(表达式) && 扩展写法(方法)
实例：武林高手数据查询
创建武林高手类 MartialArtMaster
class MartialArtMaster { public int Id {get; set;} public string Name {get; set; } public int age {get; set; } public string Menpai {get; set; } public string Kongfu {get; set; } public int level {get; set; } }
创建武学类 Kongfu
class Kongfu { public int Id {get; set; } public string Name {get; set; } public int Lethality {get; set; } // 杀伤力 }
联系：要想知道武林高手的某个武学的杀伤力，需要通过两个类才能得知
在Main中初始化武林高手和武学
创建完数据，尝试使用LINQ进行数据查询
1. 查询武林高手中所有级别 level>8的：
普通方法：通过foreach遍历查找，将查找到的符合的武林高手存入res数组即可
LINQ方法 -- 表达式写法：
var res = from m in masterList // 设置查询集合：在masterList列表中，m指代每个对象 where m.level > 8 // where 查询条件 select m; // 把符合要求的m的集合返回 foreach(var element in res) { ... 输出 }
若select语句为 select m.Name; 则返回的为m的Name属性 -- string[]
LINQ方法 -- 方法写法：
var res = masterList.Where(FilterMethod); // FilterMethod是一个委托，方法需要满足 bool MethodName(MartialArtMaster m); // 会遍历masterList中的所有元素，并作为参数传入FilterMethod // 如果返回值为false，则被过滤掉 static bool FilterMethod(MartialArtMaster m) { return m.level > 8; }
一般情况会将委托写成Lambda表达式的形式：
var res = masterList.Where( master => master.Level > 8);
2. 假设限制条件有多个
LINQ表达式：
var res = from m in masterList
where m.Level > 8 && m.Menpai == "丐帮"
select m.Name;
LINQ方法 + Lambda表达式：
var res = masterList.Where(m => m.Level > 8 && m.Menpai = "丐帮");
LINQ方法也一样。
任务3-3&3-4：LINQ集合联合查询
LINQ联合查询：
联合两个列表进行查询
-- 两个列表进行联合查询，结果是n*m条记录
第一个列表的任意一条记录，会跟第二个列表的所有记录进行组合生成新的m个记录
var res = from m in masterList
from k in kongfuList
select new {master = m, kongfu = k};
// new 新建临时对象，一共两个字段，master和kongfu
得到的结果为66条记录
但是有55条记录是没用的，这两个列表是有关联的 -- Kongfu的值
var res = from m in masterList
from k in KongfuList
where m.Kongfu == k.Name
selece new {master = m, kongfu = k} ;
这时，返回的就只有11条记录了
实例：要取得技能杀伤力>90的武林高手名字
var res = from m in masterList
from k in kongfuList
where m.Kongfu == k.Name && k.Power > 90
select m.Name;
联合查询的扩展方法的写法：
masterList.SelectMany()
public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector);
参数：两个Func委托；
第一个Func：参数为第一个列表的元素，返回值为第二个列表
用途：将第二个列表加入第一个列表，做联合查询
m => kongfuList -- m不做任何操作(但也要传入)，返回值为kongfuList
m指的是masterList中的元素
第二个Func：参数为两个列表的元素，返回值为需要返回的元素
用途：进行联合查询
(m, k) => new {master = m, kongfu = k}
k指的是kongfuList中的元素
var res = masterList.SelectMany( m=>kongfuList,
(m,k)=>new {master=m, kongfu=k}); // res存放的为66条联合查询的记录
由于上面LINQ扩展方法返回的是结果列表
可以直接进行Where()操作
.Where(x => x.master.Kongfu == x.kongfu.Name);
x指的是前面的SelectMany返回的66条记录中的元素
// 此时，res存放的为11条过滤后的联合查询的记录
再添加条件判断Power是否大于90
.Where(x=>x.master.Kongfu == x.kongfu.Name && x.kongfu.Power > 90);
任务3-5：对结果进行排序 -- orderby
order by一般位于where关键词后
默认从小到大排序
实例：
var res = from m in masterList
where m.Level>8 && m.Menpai == "丐帮"
orderby m.Age (descending)
select m;
// 如果在orderby后有descending关键字，则降序排序，否则默认为升序
按多个字段进行排序
在orderby后用逗号把字段进行分割
如：orderby m.Age, m.Level
-- 按照age排序，如果age相同的，再按照level排序
扩展方法：OrderBy() / OrderByDescending()
var res = masterList.Where(m=>m.Level>8 && m.Menpai == "丐帮").OrderBy(m=>m.Age);
var res = masterList.Where(m=>m.Level>8 && m.Menpai == "丐帮").OrderBy(m=>m.Age).OrderBy(m=>m.Level);
可以用两个OrderBy方法进行多个字段排序吗？
-- 不行，第二次OrderBy会把所有记录重新排序，覆盖了第一次的排序
解决方法：ThenBy()
var res = masterList.Where(m=>m.Level>8 && m.Menpai == "丐帮").OrderBy(m=>m.Age).ThenBy(m=>m.Level);
任务3-6：Join on集合联合查询
另一种联合查询：Join on
var res = from m in masterList
join k in kongfuList on m.Kongfu equals k.Name
select new {mastar=m, kongfu=k} ;
// 将masterList和kongfuList做连接，连接条件为 m.Kongfu equals k.Name
任务3-7&3-8：对结果进行分组操作 into groups && group by
分组查询1：into groups
实例：
把武林高手按照所学功夫分类，看看那种功夫学习人数最多
1. 联合查询 -- 把masterList Join on KongfuList中
var res = from k in kongfuList
join m in masterList on k.Name equals m.kongfu
select new {kongfu = k, master = m};
// 得到每个功夫都有对应学习的武林高手
2. 对每种功夫进行分组 -- into groups
var res = from k in kongfuList
join m in masterList on k.Name equals m.kongfu
into groups
select new {kongfu = k, count = groups.Count() };
// into groups 表示按照k.Name或m.kongfu进行分组
// 因为已经分组了，因此无法继续输出m了
// 定义字段count，保存groups.Count()值
3. 如果想要在按照所学人数的多少进行排序
var res = from k in kongfuList
join m in masterList on k.Name equals m.kongfu
into groups
orderby groups.Count()
select new {kongfu = k, count = groups.Count() };
分组查询2：group by into
按照自身字段分组 -- 只对一个集合操作时，按照自身的字段的值进行分组
实例：将武林高手的集合按照武林门派进行分组，并返回每一门派的人数
var res = from m in masterList
group m by m.Menpai into g
select new {menpai = g.Key , count = g.Count())
// 将m按照m.Menpai进行分组，放到g中
// 因为已经进行了分组， 只有组的信息了，所以单个成员的属性是获取不到的
// g.Key -- 表示按照哪个属性分的组
任务3-9：量词操作符 any all
用途：判断
Any() --
实例：判断集合当中是否有属于丐帮的人
Any() 传入一个判断是非的委托
bool res = masterList.Any( m => m.Menpai == "丐帮");
// 如果有，则返回true
All() --
实例：判断集合当中是否都属于丐帮
All()使用方法和Any()相同
bool res = masterList.All( m => m.Menpai == "丐帮");
任务3-10：LINQ总结
一般微软的语言都支持LINQ的语法
LINQ可以支持从很多数据源进行查询
上述例子我们都是对Objects进行查询
还有xml, sql, dataset, entities等数据源
LINQ to Objects部分的命名空间是System.Linq
任务4：反射和特性
任务4-1：反射和特性 -- Type类
任务4-2：反射和特性 -- Assembly程序集类
任务4-3：Obsolete特性
任务4-4：Contional特性
任务4-5：调用者信息特性
任务4-6：DebuggerStepThrough特性
任务4-7：创建自定义特性
任务5：线程、任务和同步
任务5-1：进程和线程的概念
进程 - Process
任何时刻，单核CPU只能运行一个进程，其他进程处于等待状态
一个进程至少包含一个线程，也可以有多个线程
一般情况下一个应用程序启用一个进程
同一个进程的内存空间对于它的进程来说是共享的，每个线程都可以享用这部分内存空间
比如进程中的变量，是它的线程都可以访问的
互斥链 (Mutual Exclusion -- Mutex)：防止多个线程同时读写某一块内存区域
先使用的时候加锁，后使用的人看到锁就排队，直到锁打开再进行使用
信号量 (Semaphore)：保证多个线程不会互相冲突
某些内存区域只能供给固定数目的线程使用，超过的线程需要排队
这时当线程在使用时，钥匙减1，没有钥匙时就需要排队了。
Mutex可以看成是Semaphore的一个特殊情况 (n=1)，但是因为Mutex简单、效率高，因此能用mutex就用mutex
使用线程的情况：
示例：在Main函数中，一段代码用于下载文件，一段代码用于移动文件
一个线程中的代码是从上到下执行的，于是需要等待文件下载完，才能执行其他代码
-- 多线程：在一个线程中执行下载文件的代码，在另一个线程中移动文件，还有Main线程执行其他代码
-- 一般会对比较耗时的操作另外开启一个线程
任务5-2：线程开启方式1 -- 异步委托
通过委托开启线程 action.BeginInvoke();
Action<int> a = Test;
a.BeginInvoke(100, null, null); // 开启一个新的线程去执行a引用的方法
// BeginInvoke的最后两个参数的作用见后，其他参数作为参数传递给引用方法
如果委托引用的方法有返回值 func.BeginInvoke();
Func<int, int> f = Test;
f.BeginInvoke(100, null, null);
// 因为这个方法是异步执行的，因此新的线程可能需要很长的运行时间
// 当新的线程执行完的时候，才能得到返回值
// 返回值是IAsyncResult类型的，这个返回值可以取得线程的状态
IAsyncResult ar = f.BeginInvoke(100, null, null);
// 用循环进行判断
while(!ar.IsCompleted) { // 新线程操作没有完成
Thread.Sleep(10); // Main线程休息10ms，用来控制检测频率，不需要一直检测
}
// 新线程操作完成了，取得异步委托的返回值
int res = f.EndInvoke(ar);
任务5-3：检测委托线程的结束 -- 通过等待句柄和回调函数
上一节中使用循环来监测线程是否结束
还有两种方式可以检测委托线程的结束：等待句柄和回调函数
等待句柄：
当我们通过BeginInvoke开启一个异步委托的时候，返回的结果是IAsyncResult，我们可以通过它的AsyncWaitHandle属性访问等待句柄。这个属性返回一个WaitHandler类型的对象，它的WaitOne()方法可以等待委托线程完成其任务，WaitOne方法可以设置一个超时时间作为参数（要等待的最长时间），如果发生超时就返回false。
bool isEnd = ar.AsyncWaitHandle.WaitOne(1000);
-- 等待当前线程结束，再执行下面的代码
-- 参数表示超时时间(ms)，若等待超过这个时间，会直接返回true/false来表示线程是否结束
Func<int, int> f = Test; IAsyncResult ar = f.BeginInvoke(100, null, null); bool isEnd = ar.AsyncWaitHandle.WaitOne(1000); if(isEnd) { int res = f.EndInvoke(ar); }
异步回调方法：
BeginInvoke() 的最后两个参数，之前都是写的null
倒数第二个参数是一个满足AsyncCallback委托的方法
AsyncCallback委托定义了一个以IAsyncResult类型为参数，且返回类型是void，表示回调函数
当线程结束的时候会调用这个委托指向的方法
Func<int, int> f = Test;
IAsyncResult ar = f.BeginInvoke(100, OnCallBack, null);
static void OnCallBack(IAsyncResult ar) {
}
怎么取得返回值呢？ -- 在回调函数里面取得
倒数第一个参数用来给回调函数传递数据
对于最后一个参数，可以传递任意对象，以便从回调方法中访问它。
(我们可以设置为委托实例，这样就可以在回调方法中获取委托方法的结果）
Func<int, int> f = Test; IAsyncResult ar = f.BeginInvoke(100, OnCallBack, f); static void OnCallBack(IAsyncResult ar) { Func<int, int> f = as.AsyncState as Func<int, int>; int res = f.EndInvoke(ar); Console.WriteLine(res); }
将回调函数改写成Lambda表达式：-- 更加简便
Func<int, int> f = Test; f.BeginInvoke(100, ar => { int res = f.EndInvoke(ar); Console.WriteLine(res); } , null); // 因为Lambda表达式可以直接访问到外部变量 // 因此没有必要通过最后一个参数传递f进去
任务5-4：线程开启方法2 -- 通过Thread类
通过Thread开启线程 -- System.Threading;
// 创建线程，但并没有启动
Thread thread = new Thread(DownloadFile); // 传入委托给构造函数
// 启动线程
thread.Start();
获取线程ID：
在线程中，Thread.CurrentThread.ManagedThreadId.
传递参数1：-- 通过Start()传递，参数的类型必须为object类型
Thread thread = new Thread(DownloadFile); // 不变
thread.Start("...."); // 通过Start传递参数
static void DownloadFile(object filename) {...}
传递参数2：-- 通过新建类，并将线程的方法定义为类中的实例方法
新建类，将所有需要传递的参数以成员的方式存在新建类中
class MyThread { private string filename; private string filepath; public MyThread(string name, string path) { filename = name; filepath = path; } public void DownloadFile() { 方法体 -- 可以直接访问私有数据 } }
此时在外部将对象的普通方法作为委托传递给Thread构造函数即可（之前的是静态方法）
MyThread myThread = new MyThread("name", "path");
Thread thread = new Thread(myThread.DownloadFile);
thread.Start();
通过Lambda表达式：
Thread thread = new Thread(()=>{
方法体;
});
thread.Start();
任务5-5：线程的其他概念 -- 后台前台线程、线程的优先级、线程的状态
前台线程和后台线程：
有一个前台线程在运行的话，应用程序的进程就在运行
即如果有前台线程在运行，但是Main方法结束了，那么应用程序的进程仍然在运行，直到所有线程结束
但是如果Main方法结束了，那么后台线程会被强制结束
当所有的前台线程运行完毕，如果还有后台线程运行的话，所有的后台线程会被终止掉。
默认情况下：
使用Thread类创建的线程是前台线程
使用线程池创建的线程是后台线程
用Thread创建线程的时候，可以通过.IsBackground来设置前台/后台
Thread thread = new Thread(...);
thread.IsBackground = true; // 设置为后台线程
线程的优先级：
线程由操作系统调度，一个CPU同一时间只能运行一个线程。
当有很多线程需要CPU去执行的时候，线程调度器会根据线程的优先级去判断先去执行哪一个线程
如果优先级相同的话，就使用一个循环调度规则，逐个执行每个线程。(每个线程分配时间相同)
在Thead类中，可以设置Priority属性 (线程的基本优先级)。
Priority属性是一个ThreadPriority枚举定义的一个值。
定义的级别有Highest, AboveNormal, BelowNormal 和 Lowest。
控制线程：
1. 获取线程的状态 -- Running / Unstarted
当调用thread.Start()后，新线程处于Unstarted状态
当操作系统的线程调度器选择了要运行的线程，才会变为Running状态
使用Thread.Sleep() 可以让当前线程休眠进入WaitSleepJoin状态
2. 使用 thread.Abort() 强制停止线程
调用这个方法，会在终止要终止的线程中抛出一个ThreadAbortException类型的异常
我们可以try catch这个异常，然后在线程结束前做一些清理的工作。
3. 如果需要等待线程的结束，可以调用 thread.Join()
表示把Thread加入进来，停止当前线程，并把它设置为WaitSleepJoin状态
直到加入的线程完成为止，再继续执行下面的代码
任务5-6：线程开启方法3 -- 线程池
创建线程需要时间。
如果有不同的小任务要完成，就可以事先创建许多线程 , 在应完成这些任务时发出请求。
这个线程数最好在需要更多的线程时增加,在需要释放资源时减少。
系统自带一个ThreadPool类，用于管理线程。
这个类会在需要时增减池中线程的线程数，直到达到最大的线程数。
在双核 CPU中，默认设置为1023个工作线程和 1000个 I/o线程。
也可以手动指定在创建线程池时应该立即启动的最小线程数，以及线程池中可用的最大线程数。
如果有更多的作业要处理，且线程池中线程的个数也到了极限，
那么最新的作业就要排队，且必须等待线程完成其任务。
线程池默认创建出来的任务都是后台线程
注意：不能把线程池的线程修改为前台线程
不能修改线程池中线程的优先级和名称
线程池中的线程只能用于运行时间段的任务
实例：开启工作线程
static void ThreadMethod(object state) {
// 需要一个object类的参数
}
Main() {
ThreadPool.QueueUserWorkItem(ThreadMethod);
// 如果想要传递数据，在ThreadMethod后写上逗号和实参即可
任务5-7&5-8：线程开启方法4 -- 任务
通过任务开启线程 -- 三种方式
第一种 -- 和Thread有些类似
任务Task其实是线程的一种封装
Task t = new Task(TaskMethod); // 将委托指向的方法传递过来
t.Start();
第二种 -- 通过TaskFactory 工厂模式
TaskFactory tf = new TaskFactory();
// 通过任务工厂 TaskFactory 可以对许多task进行操作
Task t = tf.StartNew(TaskMethod);
连续任务：
如果一个任务t1的执行时依赖于另一个任务t2的，即t1需要在t2执行完成后才开始执行
-- 使用连续任务解决 -- task.ContinueWith()
实例：
Task t1 = new Task(DoFirst);
Task t2 = t1.ContinueWith(DoSecond);
Task t3 = t1.ContinueWith(DoSecond);
Task t4 = t1.ContinueWtih(DoError, TaskContinuationOptions.OnlyOnFaulted);
任务层次结构：
在一个任务中启动另一个新的任务，即新的任务为当前任务的子任务
若父任务执行完，但子任务没有执行完，则父任务状态会设置为WaitingForChildrenToComplete；当子任务也执行完了，则父任务的状态为RunToCompletion
实例：
static void Main() { var parent = new Task(ParentTask); partent.Start(); Thread.Sleep(2000); Console.WriteLine(parent.Status); Thread.Sleep(4000); Console.WriteLine(parent.Status); } static void ParentTask() { var child = new task(ChildTask); child.Start(); Thread.Sleep(1000); } static void ChildTask() { Thread.Sleep(5000); }
任务5-9：线程中会遇到的问题 -- 争用条件和死锁
争用条件 Race Conditions：
A race condition occurs when two threads access a shared variable at the same time.
多个线程同时访问一个变量时，造成的读写冲突
实例：
线程要执行的委托指向的方法：
class MyThreadObject { private int state = 5; // shared variable public void ChangeState() { state++; if(state == 5) { // 目前来看这个条件永远不会满足 输出state=5; } state = 5; } }
在Main中通过线程执行上述方法：
class Program { ... Main ... { MyThreadObject myThread = new MyThreadObject(); Task t = new Task(ChangeState); t.Start(myThread); // 启动线程 // 定义函数，执行多次myThread.ChangeState() static void ChangeState(Object o) { // 把Object类型转换成原来类型 MyThreadObject myThread = o as MyThreadObject; while(true) { myThread.ChangeState); } } }
运行：没有任何输出 -- 因为只有一个线程时按照顺序执行，判断处并不会出现state=5的情况
修改 -- 增加一个线程，同时执行ChangeState()
增加一个 Task t = new Task(ChangeState); t.Start(myThread);
或使用TaskFactory
运行：输出大量的state=5
原因：当一个线程执行到state=5的时候，另一个线程正好进行判断condition
争用条件的解决方法 -- 对当前的shared对象加锁
锁 lock()：向系统申请对指定对象加锁，锁定该对象
如果对象没有被锁定，那么可以j进行访问
如果对象被锁定了，则需要等待锁定解除后才能进行访问
实例：lock(object) {}
while(true) { lock(myThread) { // 对myThread对象加锁 myThread.ChangeState(); // 同一时间，只能有一个线程执行这个操作 } // 解锁 }
死锁 Deadlocks：由锁产生的问题
当两个线程同时申请到了一个锁，而两个线程在解锁之前遇到了另一个锁又是对方申请到的第一
个锁，此时两个线程都在等待对方解锁第一个锁，产生了死锁
实例：
public class SampleThread{ private StateObject s1; private StateObject s2; public SampleThread(StateObject s1,StateObject s2){ this.s1= s1; this.s2 = s2; } public void Deadlock1(){ int i =0; while(true){ lock(s1){ // 先锁s1 lock(s2){ // 后锁s2 s1.ChangeState(i); s2.ChangeState(i); i++; Console.WriteLine("Running i : "+i); }}}}} public void Deadlock2(){ int i =0; while(true){ lock(s2){ // 先锁s2 lock(s1){ // 后锁s1 s1.ChangeState(i); s2.ChangeState(i); i++; Console.WriteLine("Running i : "+i); }}}}} Main... { var state1 = new StateObject(); var state2 = new StateObject(); new Task(new SampleTask(s1,s2).DeadLock1).Start(); new Task(new SampleTask(s1,s2).DeadLock2).Start(); }
解决方法：
在编程的开始设计阶段，设计锁定的顺序即可
比如上例中：
两个方法都必须按照先锁定s1后锁定s2的顺序（或反过来）