闲着没事就把以前学习时的笔记拿出来整理了一下，个人感觉有点用，就想拿出来跟园友共享一下。有些基础性的内容比如基本概念、语法什么的就不发了。
内容：1、构造方法（函数） 2、继承 3、访问修饰符 4、静态和非静态 5、隐藏基类方法 6、重写基类方法 7、抽象方法 8、接口 9、多态和接口 10、值类型与引用类型 11、ref和out 12、类型转换 13、异常处理 14、string字符串处理 15、string常用方法 16、StringBulider 17、File类读取文件 18、文本高亮 19、泛型集合List<T>和Dictionary<TKey，TValue> 20、装箱和拆箱 21、读写数据（Ststem.IO） 22、文件流（FileStream） 23、StreamReader和StringWriter 24、File和Directory 25、序列化 26、Directory类的静态方法 27、正则表达式 28、Regex类 29、字符串提取 30、贪婪模式 31、字符串替换 32、byte数组和字符串的转换 33、委托 34、多播委托 35、事件 36、委托和事件的区别 37、var类型 38、扩展方法 39、XML
1、构造方法（函数）：在对象创建的时候初始化字段
public 类名([参数])
{
//执行内容，如this.name=name;(有参数)
}
构造方法没有返回值，void也不写
创建对象时如果没写构造方法系统默认有一个无参的构造方法，一旦用户添加了构造方法，原来默认的无参的构造方法就没有了
默认初始值为：int：0； bool：false； string：null； char：‘ ’；
构造方法的作用：初始化字段（实例化类的时候传入初始值）
调用构造方法：
1）除了new对象的时候，不能直接使用构造方法名调用构造方法
2）this调用构造方法（难点）（一个构造方法调用另一个构造方法）
为了解决代码的重用才使用this调用构造方法
当一个类中出现多个构造方法重载的时候，同时构造方法都需要为字段赋初值
使用this代表当前类的构造方法来使用，根据this后面的参数决定使用哪一个重载
public 构造方法名（）：this（[参数]）
{
//代码
}
如：
public Person(string name, int age, string sex)
{
this.name = name;
this.age = age;
this.sex = sex;
}
public Person(string name)
: this(name, 0, null)
{
}
2、继承：
多个类都有共同的字段、属性或方法时，可以使用继承
需要写一个学生类、一个老师类、一个校长类
事先写一个Person类，在写其他类的时候继承这个类，Person叫父类，继承他的叫子类
特征：子类既有父类的非私有字段、属性和方法，又有子类独有的字段、属性和方法
一个子类只能有一个父类，一个父类可以有若干个子类
[访问修饰符] class 子类名：父类名
子类调用父类构造方法的问题（难点）
->构造方法的执行顺序：先父类再子类
->关于构造方法的重载：如果不声明调用哪个构造方法默认执行无参的构造方法
避免错误的方法：
->为父类提供无参构造方法
->在子类中指定调用父类有参的构造方法
注意：父类除构造函数（方法）之外的非私有成员都可以被子类所继承，构造方法不可以被继承，但可以被调用，调用方法： [访问修饰符] 构造方法名([参数])：base(父类构造方法的参数)
public Teacher():base("狗蛋”,20,"女")
{ } //直接赋值，实例化对象时不需再赋值
public Teacher(string name, int age, string sex)
: base(name, age, sex)
{
this.className = "C#";//老师类独有的字段
} //继承传递参数，实例化对象时需要赋值
base关键字用于显示声明要调用父类的哪个构造方法，是调用，不是声明不是继承
注意：为避免继承父类时因为构造方法出错，应该为每个声明的类都手动添加一个无参的构造方法
3、访问修饰符
public 最公开的，所有地方都可以访问
private 最隐蔽的，只有本类可以访问
protected 可以在当前类和子类中被访问
internal 只能在本项目中被访问
C#中规定类的访问修饰符只能是public 和internal
类中成员的访问修饰符除以上四种以外还有个（protected internal）即可以在当前类、子类和本项目中被访问
4、静态和非静态
静态使用static标记
静态成员
->如何定义静态成员
在成员前加static关键字
->如何使用静态成员
静态成员不能由实例对象调用，只能用类名调用
使用静态成员，不需要实例化对象
静态成员会在整个应用程序退出时才释放资源，所以这个变量可以在整个程序中共享数据，可用于窗体间传递参数
注意：静态变量过多会占用系统内存，因此声明静态变量时要多加考虑
Main方法是静态的，所以它只能调用静态的方法或参数，若想调用非静态方法，必须new一个类的实例，用实例名调用。
静态类
1）什么情况下要将一个类标记为静态类？
一般情况是，当这个类是一个工具类，里面都是方法，为了让用户调用的时候方便，不需要实例化对象，这时可以将该类标记为static类，此时该类中只能包含静态成员，不能包含实例成员，比如Convert、Console、Read、ReadInt等
2）什么情况下需要在一个普通类中编写一个静态成员，而这个类不能标记为static？
当这个类需要被实例化的时候，如果这个类中有一个成员是所有对象要共享的数据，这时可以将该类中的这个成员标记为静态的，但是这个类还是一个非静态类
3）静态类不能被实例化，不能被继承
4）由于静态成员会在整个程序退出时才释放资源，所以尽量避免写静态字段或静态属性，最好只写静态方法
5）静态类中可以有静态成员和实例成员，因为其不能被实例化，所以静态类中的实例成员无法被调用，也就没有任何意义了
6）静态类不能被继承，也不能继承自其它类，只能继承自Object类
静态构造函数
1）静态构造方法（或字段）在第一次访问这个类的时候执行，并且只执行一次
->静态构造方法与静态类的生命周期（了解）
静态成员属于该类的所有对象。实例成员只属于当前实例
静态类的生命周期：第一次访问类的时候创建，程序结束时才释放
5、隐藏基（父）类方法（了解，用的不多）
当子类和父类有相同名字的方法时，实例化子类调用该方法为子类内的方法，把子类转换成父类后再调用该方法就是父类内的方法了
为了代码规范化，如要有意隐藏父类的方法，要在子类的同名方法前加new关键字，用于 提醒这里是要隐藏父类方法
//隐藏基类方法
class MyBase
{
public void Func()
{Console.WriteLine("我是父类的方法);}
}
class MySub : MyBase
{
public new void Func() //在方法前用new关键字提醒这里是有意隐藏父类方法
{Console.WriteLine("我是子类的方法);}
}
class Program
{
static void Main(string[] args)
{
MySub ms = new MySub();
ms.Func();
// ((MyBase)ms).Func();
MyBase my = ms;
my.Func();
Console.ReadKey();
}
}
6、重写基（父）类方法（多态的体现）
在父类方法前加virtual（虚方法），表示这个方法可以被重写
在子类方法前加override，表示重写基类方法，子类如果不写override就是隐藏
当子类和父类有相同名字的方法时，实例化父类调用的是父类的方法，将子类赋值给父类后，父类调用的就是子类的方法了
一旦父类的方法在子类中被重写，除了实例化父类调用以外，子类或者子类的子类调用时都是调用的最新的那个子类重写方法
此时base和this就有区别了：
如果子类和父类中有名字相同的方法，那么base.Func()就代表父类的方法，this.Func()代表当前类的方法
如果不希望子类再重写，需要在子类方法前加sealed
//重写基类方法
class USB
{
public virtual void Usb() //virtual关键字表示父类方法可以被重写′
{Console.WriteLine("我是父类的方法);}
}
class Phone:USB
{
public override void Usb()//override关键字表示这个方法重写父类的方法
{Console.WriteLine("手机");}
}
class Mp3:USB
{
public override void Usb()
{Console.WriteLine("MP3");}
}
class Program:USB
{
static void Main(string[] args)
{
Console.WriteLine("输入数字");
USB usb = new USB();
switch (Console.ReadLine() )
{
case "1":
usb = new Phone();
break;
case "2":
usb = new Mp3();
break;
default:
break;
}
usb.Usb();
Console.ReadKey();
}
}
隐藏看类型，重写只管新
7、抽象方法
方法前加abstract，圆括号后加分号
[public] abstract void 方法名（参数）；
抽象方法所在的类也必须是抽象的，不能被实例化，类前加abstract
abstract class 类名
抽象成员必须出现在抽象类中，但抽象类中可以有抽象成员和实例成员
抽象类的抽象方法默认可以且必须被重写，所以需要重写时不需要再写virtual，直接在子类方法中写override关键字即可重用
抽象类的成员：方法、属性、索引、事件
注意：抽象类中的所有抽象方法在子类中必须要被重写，如果子类中不重写，那这个子类也必须声明成抽象类，但此时子类也就不能被实例化了
8、接口
[访问修饰符] interface 接口名（接口一般以I开头，I+行为+able）
{
//接口成员，一定是抽象成员
}
成员的定义：与抽象成员的写法一样（没有关键字），没有执行体（方法体）；没有访问修符；
实现：子类“继承”自接口，接口可以看做是子类的“干爹”，补全抽象的方法
调用：和类的使用方法一样，要使用接口中的方法，则将对象赋值给接口变量
多态：和抽象类的实现一样，接口的多继承使得多态的实现变得灵活
子类继承父类，子类实现（继承）接口：class 子类名：父类名，接口名 或class 类名：接口名
个人理解：接口就是把类中的一种特定的功能性方法封装成接口（如开车、飞等），声明类的时候可以继承这个接口，就拥有了这个接口所特有的功能，就可以在类中实现这个功能，那实现后的这个功能就成为了这个类的一个功能性方法。用接口可以实现多继承，一个类可以继承多个接口，也就拥有了多个功能性方法，声明类的时候可以选择性的继承，比如定义老师的时候可以继承说话、吃饭、教课等接口，定义司机的时候又可以继承说话、吃饭、开车等接口
//定义一个接口，表示Driving功能
interface IDrivable
{
void Driving();
}
class Teacher:Person,IDrivable//继承父类和接口
{
public Teacher(string name, int age, string sex):base(name,age,sex)
{//继承父类的构造方法
}
public void Driving()//实现接口的Driving功能
{
Console.WriteLine("我会开车");
}
public override void ShowMe()//重写父类方法
{
Console.WriteLine("我是老师");
}
}
static void Main(string[] args)
{
Teacher tea = new Teacher("张三", 18, "男");
tea.ShowMe();//调用重写后的方法
tea.Driving();//调用实现后的接口方法
Console.ReadKey();
}
9、多态和接口
接口是可以多继承的，多继承同时会引起方法的重名
为避免重名，显示实现接口：
返回值 接口名.方法名（参数）
{
//方法体
}
显示实现接口的这个方法只能由接口变量进行调用
现阶段记住接口使用的语法，然后将接口直接当做抽象类使用（初学阶段）
10、值类型和引用类型
变量可以看做是一个数据
值类型，是一个存储数据的容器，这个数据就是这个类型表示的数据
引用类型，也是一个容器，但是这个容器存储对象的一个引用（地址），真正的数据在另一块内存中，就相当于是一个指向数据的快捷方式
值类型存储在栈里面，引用类型存储在栈和堆里面（堆里存储的是真实数据，栈里面存储的是真实数据在堆里面的内存地址）
值类型和引用类型会涉及到传参和赋值时的不同，要注意区分
委托（delegate）也是引用类型
值类型赋值赋的是真实的值，引用类型赋值赋的是地址
引用类型是一个变量，两个快捷方式，修改一个快捷方式会影响另一个快捷方式；值类型是一个变量和一个复制后的变量，修改一个变量不会影响另一个变量
所有的值类型都继承自System.ValueType类
11、引用传递：ref和out
使用ref或out就可以实现将引用传递过来
定义方法时，在参数类型前加ref或out
调用方法时，在参数前加ref或out
注：定义变量时不需要加ref或out
当一个变量传递给一个方法时，总是复制一份自己的数据，赋值给方法，那么方法中执行的变量就与方法外的那么变量没有关系了，方法内修改变量值，也不会影响方法外的那个变量。有时会要求多个返回操作（方法中的变量有多个在方法外需要使用），此时可以使用ref标记参数，此时在方法中使用的这个变量与方法外的变量就是同一个变量了，相当于可以使用参数实现返回值
out与ref的作用与使用方法相同
out 必须在方法中赋值
ref必须在方法外赋值
12、类型转换
隐式类型转换：兼容类型，小转大
显式类型转换：即强制类型转换 （转换后的类型）要转换的变量
Convert类型转换：系统封装的方法，Convert.ToInt32（）、Convert.ToDouble（）等
其他转换方法：int.Parse()、int.TryParse()（第一个参数表示待转换的字符串，第二个out（result）参数表示数字转换成功后的变量，如果转换失败，返回false，为out result赋值为0）
用int.TryParse()代替try-catch，释放内存，提高性能
不止int类型有TryParse，所有基本类型都有TryParse，用法都一样
13、异常处理（try-catch、try-catch-finally、try-finally）
Exception是一个专门用来封装异常的一个类型
两个属性：message（异常说明文本）和stackTrace（异常抛出的顺序）
抛出异常：throw Exception的一个对象（new一个对象）
从出现异常的try向上依次抛出（方法之间依次调用），直至处理，找到最近的catch捕获异常（用于try-finally语句，catch块在方法以外，执行顺序是try-finally再向上寻找catch执行异常捕获）
Finally用于释放资源，finally{}，程序执行完try-catch后会再执行finally语句块
Finally总会执行，即使try-catch中有return
try
{ }
catch (Exception ex)
{ throw; }
finally
{ }
Try-finally用处不多，用于释放资源
使用异常会降低系统性能，尽量少用
14、string字符串处理
构造函数：string（char[] chs）、string（char ch，int count）
string str = new string（’a‘，’b’，’c’）；//abc
string str = new string（‘a’，3）；//aaa
3.144.ToString（“0.0”）；用于控制格式，会四舍五入
字符串可以当做数组进行处理（使用下标读取，拥有数组的各种属性）
string str = “不可见的你”； 此时str[1]就是“可”了
通过索引得到的数据是char类型，字符串不可改变，使用索引无法修改字符串的数据
要想修改可将字符串变成字符型数组，str.ToCharArray()
string是引用类型
string str = string.Empty；声明一个空字符串
判断字符串是否为空：
str.Length == 0（推荐）
str ==“”
str == string.Empty
String.IsNullOrEmpty(要判断的字符串)（推荐）
15、string常用方法
1）字符串比较：bool isTrue = string.Equals（string a，string b）
String.Equals(str1,str2);
Str1.Equals(str2，StringComparison.OrdinalIgnoreCase); //第二个参数意思是不区分大小写
string.Compare(str1,str2);
Equals方法：
String重载的方法判断两个，一个是==，一个是EqualsHelper
==判断两字符串是否相同
EqualsHelper判断两个字符串中每一个字符是否相同
Object的重载是来自于object类，是继承下来的
在object中使用的是==和Equals方法
Equals方法是一个虚方法，由string重写了，调用的是object.ReferenceEquals方法和EqualsHelper方法
注意：==默认表示判断两个对象的地址是否相同，与object.ReferenceEquals方法一样
String提供的str1.Equals(str2)判断地址是否相同，字符串是否object提供的virtual Eaulse（object）
Equals和==的区别：
Equals会判断两个值的内存地址；==只判断值是否相等。
Compare方法：
int result = String.Compare（str1，str2）；
str1>str2 -> 1 str1 == str2 -> 0 str1<str2 -> -1
string.Compare方法比较两个字符串，这两个字符串字母顺序表示大小，按照字典排序规则进行比较（对于char类型：A>a，B>a，b>A同一个字母，大写>小写，不同字母按照字母顺序后面的大于前面的；对于string类型不是按照埃克森码比较，A>a，b>A，B>a）
2）大小写转换：ToLower()和ToUpper()
3）str1 = str1.Trim([params char[] chs])；去除字符串两边的空格，或chs中出现的字符（重载）
str1 = str1.TrimEnd(params char[] chs)；去除字符串的末尾chs中出现的字符
str1 = str1.TrimStart(params char[] chs)；去除字符串的开头chs中出现的字符
4）合并与分割
合并字符串：string s = string.Join(str1，str2，str3，...)
分割字符串：string[] strArray = str1.Split(‘a’)；
string[] strArray= str1.Split(new char[]{‘a’，’b’}，StringSplitOptions.RemoveEmptyEntries)；去掉a、b和所有空格
5）字符串查找
Contain包含，返回bool类型的值，str1.Contain(“爱”)；
IndexOf检索位置，返回字符串中某个字符的位置（int）找不到则返回-1
str.IndexOf（要找的字符或字符串）
str.IndexOf（要找的字符或字符串，开始寻找的位置）
str.LastIndexOf（）是从后往前寻找，用法同str.IndexOf（）
注意：IndexOf和LastIndexOf中第二个参数（开始寻找的位置）只是为了说明要查找的是字符串中的哪一个字符（如果字符有重复），即按查找顺序在开始位置后的第一个字符，返回的索引依然是该字符在整个字符串中的索引，而不是从查找位置开始的索引。
6）截取子字符串
string s =str1.Substring（开始的位置，子字符串的长度）
String s = str1.Substring（开始的位置）
7）判断字符串的开头和结尾
bool a = str1.StratWith（字符串）；
bool a = str1.EndWith（字符串）；
8）字符串的插入、移除和替换
插入：string str2 = str1.Insert（位置（int），要插入的人字符串（string））；
移除：string str2 = str1.Remove（位置（int），长度（int））；
string str2 = str1.Remove（位置（int））；移除该位置后的所有字符
替换：string str2 = str1.Replace（旧字符串，新字符串）；
9）格式化字符串
String.Format（格式化的字符串，填坑的参数）
string str1 = String.Format（“{0}，{1}”，str2，str3）；
10）判断字符串是否为空
String.IsNullOrEmpty（str）；
10）字符串的方法（总结）
增：添加（+=）、插入（Insert）
删：Remove
改：Replace、 ToUpper、ToLower、Trim、TrimStart、TrimEnd、Split、Join、new String、SubString、Format
查：Contains、IndexOf、LastIndexOf、StartsWith、EndsWith、ToCharArray、Length、Empty
比：Equals、Compare
16、StringBuilder
大量字符串拼接的时候性能非常差，很难完成大型数据的拼接
（Stopwatch对象可以记录程序运行的时间，Start开始计时，Stop结束）
使用StringBuilder：StringBuilder sb = new StringBuilder（）；
sb.Append（要添加的字符串）；//向sb中添加数据
sb.AppendLine（要添加的字符串）；//向sb中添加数据后换行，等价于sb.Append（要添加的字符串+” ”）；
sb.AppendFormat（要添加的字符串）；格式化处理，等价于 sb.Append（string.Format（要添加的字符串））;
string str = sb.ToString；输出或赋值时要转换成string
在处理大型数据的时候，StringBuilder要比普通的string处理快很多，因为处理大型数据要用StringBuilder
17、读取文件
string[] lines = File.ReadAllLines(@"H:传智播客实训资料代码第9天a.csv", Encoding.Default);//按行读取
string[] lines = File.ReadAllText(@"H:传智播客实训资料代码第9天a.csv", Encoding.Default);//读取所有文本
string[] lines = File.ReadLines(@"H:传智播客实训资料代码第9天a.csv", Encoding.Default);//读取一行文本
string[] lines = File.ReadAllBytes(@"H:传智播客实训资料代码第9天a.csv", Encoding.Default);//读取字节
18、文本高亮
->让文本框获得焦点--txtContent.Focus();
->找到要高亮的位置--pos
->选中（高亮）的字符串长度--length
->调用TextBox的选中方法txtContent.Select(pos，length)
19、泛型集合 List<T>和Dictionary<TKey，TValue>
List集合：动态的自定义数组
List<类型> 集合名 = new List<类型>（）；
List用法与ArrayList一样，不同点在于定义时和使用时的类型固定，因此可以完全替代ArrayList
类型[] = list.ToArray()//将List转换成该类型的数组
Dictionary集合：动态的自定义键值对
Dictionary<类型，类型> 集合名 = new Dictionary<类型，类型>（）；
Dictionary用法与Hashtable一样，不同点在于定义时和使用时的类型固定，因此可以完全替代Hashtable
20、装箱与拆箱
直接将值类型赋值给引用类型就是装箱
将存储值类型的引用类型强制转化为对应的值类型就称为拆箱
Object o = 1；//装箱 int n = （int）o；//拆箱
装箱对值类型保持无关性，装箱对引用类型保持相关性
装箱和拆箱会对性能有一定的影响
21、读写数据（I/O操作、System.IO类）
System.IO.Path类，专门处理字符串路径，是一个静态类
string path = @“D:windowsystemfile.txt”；
获取文件名：string fileName = Path.GetFileName(path);
获取后缀名：string fileName = Path.GetExtension(path);
修改后缀名：path = Path.ChangeExtension（待修改的路径，“mp3”）；
获取文件夹名：string fileName = Path.GetDirectoryName(path);
合并路径：path= Path.Combine（路径1，路径2，路径3...）；
临时文件夹：path = Path.GetTempPath（）；
绝对路径：从盘符开始的最精确的路径
相对路径：相对于当前文件同一个目录作为参照的路径
相对路径和绝对路径：区分就看有没有根目录盘符的标记
22、文件流（FileStream）
1）引入命名空间
2）创建FileStream对象FIleStream fs = new FileStream（文件名，FileModel，FileAccess）
FileStream fs = new FileStream(@"D:a.txt", FileMode.Create, FileAccess.Write);
FileModel：对文件的处理方式（打开、创建、追加）
FileAccess：对文件的操作：读、写
3）使用方法操作
写一个字节：fs.WriteByte()
写一个字节片段（将字节数组中的数据写入到fs指定的文件）：
fs.Write(存放字节的数组，开始写字节的数组下标，要写的字节数)
读一个字节：fs.ReadByte()
读一个字节片段（将fs指定的文件中的数据读取到字节数组）：
fs.Read(存放字节的数组，开始存放字节的数组下标，要读的字节数)
4）释放资源
fs.Close()和fs.Dispose()方法（两个都要调）
23、StreamReader和StreamWriter
StreamReader：专门用来读取文本文件的流
1）引入命名空间：IO
2）new一个FileStream指向文件
3）new一个StreamReader，构造函数参数是FileStream的对象
4）调用方法
StreamReader有一个属性EndOfStream：判断当前的流位置是否在文件流的末端，一般用来判断文件是否读完
StreamWriter：专门用来写入文本文件的流
1）引入命名空间：IO
2）new一个FileStream指向文件
3）new一个StreamWriter，构造函数参数是FileStream的对象
4）调用方法
24、File和Directory对文件和目录操作做了一个封装
增（Create）：创建文件或文件夹
删（Delete）：删除文件或文件夹
改：改名字 File.Move（“1.txt”，“2.txt”）
查：...
判断是否存在（Exists）
移动文件：File.Move（“1.txt”，“21.txt”）
复制文件：Copy
Directory用于处理文件夹（目录）
删除目录的时候如果目录不是空的则会报错，此时需要在Delete内添加一个true
Directory.Delete（“1”，true）;
25、序列化：
序列化：把一个对象的内容存储到磁盘上（文件流）、网络上（网络流）、内存里（内存流），下次需要用到对象数据的时候可以直接拿来用
反序列化：把已经序列化存储到磁盘、网络、内存里的对象数据，提取到项目中的对象中
序列化步骤：
1）创建一个文件流
2）为需要序列化的对象添加标记（[Serializable]表示此对象可以被序列化）
3）创建BinaryFormatter（导入命名空间）
4）调用Seralize方法（bf.Seralize（文件流对象，需要被序列化的对象））
反序列化步骤：
1）创建一个文件流
2）为需要序列化的对象添加标记（[Serializable]表示此对象可以被序列化）
3）创建BinaryFormatter（导入命名空间）
4）调用DeSeralize方法（object ob = bf.DeSeralize(文件流对象)）
反序列化定义接收类型的时候必须根据原序列化的程序集确定类型
建议：在使用序列化的时候尽量避免使用自动属性，因为自动属性在每次编译的时候自动生成的字段名可能不一样，所以在反序列化的时候可能会造成问题
注意：如果序列化和反序列化不在同一项目下，那反序列化的时候需要引用原序列化的程序集
26、关于文件夹下的文件与子文件夹
Directory类的静态方法
获取子文件名：string[] s = Directory.GetFiles（@“D：dir“）；
获取特定后缀名的子文件名：string[] s = Directory.GetFiles（@“D：dir“，”*.txt“）；
获取所有文件夹名：string[] s = Directory.GetDirectories（@“D：dir“）；
27、正则表达式
元字符：
1）.（点）表示除 以外任意的单个字符
2）[ ]表示括号内的任意一个字符（如a[xyz]b表示axb或ayb或azb）
3）^在[ ]括号内表示取反（如^[a-z]表示除小写字母以外的所有字符）
4）^匹配一串字符的开始（^abc表示以abc为开头的任意字符串）
5）$匹配一串字符的结尾（abc$表示以abc为结尾的任意字符串）
5）|表示“或”，优先级最低（如a|bc表示a或bc，（a|b）c表示ac或bc）
6）（）可以改变优先级、提取组
7）*表示限定前面的字符出现任意次数（abc*表示ab、abc、abcccc......（abc）*表示abc、abcabc）
8）+ 至少出现一次，也可出现多次（xa+y表示xay、xaay...）
9）？表示出现0次或1次
10）{n}限定前面的表达式出现n次
11）{n，m}至少出现n次，最多出现m次
12）{n，}至少出现n次
13）d表示0-9，D表示d的反面
14）s表示空白符，S表示s的反面
15）w表示数字、字母、下划线、汉字，W表示w的反面
注：正则表达式的转义符也是，如果要表示*（星），可以写成*，要表示一个，可以写成\
28、Regex类
Regex.IsMatch（待判断的字符串，正则表达式）判断一个字符串是否匹配某个正则表达式
！如果正则表达式没有^和$，那默认不设定开头和结束，此时只要待判断的字符串中含有该正则表达式就返回true
^z|food$：表示以z开头的任意字符串或者以food结尾的任意字符串，都返回true
因为|的优先级最低，所以上边的表达式其实是（^z）|（food$）
Regex.Match（）从某个字符串中提取匹配某个正则表达式的某个子字符串，但只能提取一个
Regex.Matches（）同上，可以提取所有的匹配字符串
Regex.Replace（）字符串替换，把所有匹配正则表达式的字符串替换为对应的字符
29、字符串提取
字符串提取的时候一般不加^和$
Match m = Regex.Match（原字符串，要提取的正则表达式）
m.Value属性表示提取到的字符串
m.Group[n]：提取组，按正则表达式中（）括号对的个数，m.Group[0]表示整个字符串，m.Group[1]表示第一个括号内的内容，所以提取组的时候要从下标1的地方开始
MatchCollection mc = Regex.Matches（原字符串，要提取的正则表达式）
MatchCollection是一个集合，需要foreach遍历输出（遍历时的类型是Match）
30、贪婪模式
定义：当正则表达式提取的时候，如果一个字符或多个字符都能匹配，这时会按照使用最多字符的方式来匹配。
正则表达式默认采用贪婪模式，尽多的匹配
在限定符后面使用问号用来终止贪婪模式，即只会提取匹配的第一个
string s = “aaaa bbbbbbbb”；string s1 = “[a-zA-Z]+”； 匹配结果：aaaa
string s = “aaaa bbbbbbbb”；string s1 = “[a-zA-Z]+？”； 匹配结果：a
31、字符串替换
String s =Regex.Replace（原字符串，待替换的正则表达式，替换后的字符串）;
如：string s = Regex.Replace(s, "-+", "-");//把字符串s中的所有-替换成一个-
提取组替换：
string s = "aaa13812345678bbb";
s = Regex.Replace(s, @"(d{3})(d{4})(d{4})", "$1****$3");//把手机号中间4位替换成4个*
32、byte数组和字符串的转换
byte[] bt= System.Text.Encoding.UTF8.GetBytes(str);
string str = System.Text.Encoding.UTF8.GetString(bt);
33、委托（delegate）
委托是一种数据类型（和类一样），可以将方法赋值给委托对象，可以理解为方法类型
定义（在命名空间下，或添加一个cs文件，和类的定义一样）：
1）使用delegate关键字
2）这个委托将来要存储的方法如果没有返回值，那么委托也要定义成void，参数也要与方法保持一致
3）委托是一个数据类型，用的时候需要传递一个变量
4)创建委托对象的时候可以不用new，系统编译时会自动给我们new
定义委托类型：public delegate void ChangeTxtDelegate(string str);
创建委托对象：public ChangeTxtDelegate changeTxt; //Form1中
给委托赋值：f1.changeTxt = ChangeText; //Form2中
调用委托：changeTxt(txt); //Form1中，此种调用方法为简写，实际上是changeTxt.invoke（txt）；
创建委托对象时也可直接对其赋值：ChangeTxtDelegate changeTxt = new ChangeTxtDelegate(ChangeText) ;
用法（窗口间传值）：委托要声明在需要被传值的对象内，比如Form1要提取Form2中的数据（即Form2往Form1传值），就应该把委托声明在Form1中，在Form2中写一个方法获取要传的数据，并且赋值给Form1的委托，最后在Form1中调用委托就ok了。（委托声明位置不绝对，还需要考虑当前活动窗口的问题，要声明再活动窗口中，有时也可声明在被提取值的窗口内）
作用：可以在某个代码内部，嵌入一段外部代码（外部写一个方法赋值给委托或在定义方法时把委托类型作为参数，调用时把方法名作为参数传递给委托对象，那么委托就执行该方法，不同的外部项目可以写不同的方法赋值给委托，可以实现一个委托选择性执行多种方法的灵活性），相当于是注入
什么情况下使用委托？
当一个类型中需要嵌入一段代码，但是这段代码具有不确定性，是根据使用这个类型的用户来确定代码的，这时就可以在该类型中使用一个委托，保证在某种情况下会调用该委托，用户将对应的方法传递给该委托，就会调用这个方法
可以把静态方法或者私有方法赋值给委托了变量，赋值后只要能使用到该委托变量的地方就能使用该方法，打破了访问修饰符的限制
一般在调用委托前或者触发事件前，都要判断委托变量或事件是否为null，如果为null则不调用
34、多播委托
MyDelegate md = new MyDelegate(M1)； md+=M2；（增加某个方法）md-=M4；（去掉某个方法）
使用委托时，如果不是+=而是直接用=赋值，则会将前面增加的所有方法都覆盖掉
多播委托可以存储多个方法，委托中方法调用的顺序与增加方法时的顺序是一致的，但是，不要依赖于这个顺序（微软没有承诺这样的顺序，万一以后改了就GG了）
多播委托中，如果要是有返回值，只会得到最后一个方法返回的结果。可以通过调用GetInvocationList（）方法返回当前委托中的所有方法，返回值类型时一个Delegate数组（委托数组），再用foreach遍历调用所有方法
所有定义的委托都继承自抽象类MulticastDelegate，而MulticastDelegate又继承自Delegate抽象类
多播委托内部是将绑定在当前委托对象上的每个方法，都转换成一个委托对象，并且存储在了一个叫_invocationList的object数组中。当调用委托的时候，其实就是循环遍历_invocationList数组，并且调用其中的每个委托
多播委托中，如果其中的某个方法执行时发生了异常，则后面的方法不再执行。
多播委托中只能存储同一类型的委托，即返回值、参数都相同
35、事件
事件是在特定条件下执行的动作，这个动作是由用户确定的。如Button的Click事件，其动作是由程序员写的，因此可以用委托来实现这个功能，写不同的方法赋值给委托变量。
但用委托模拟方法有两个缺点：
1）定义的委托可以在类外部的任何地方被触发，即非特定条件下也可以调用。因为委托变量是public修饰，改为private就不能在外部赋值了。
2）由于委托可以用=（等号）赋值，所以就有可能把前面已经注册的事件处理程序都覆盖掉。
而用事件就可以解决以上问题：
1）用事件必须先定义一个委托，否则无法使用事件
2）实例化委托变量的时候，在委托类型名前面、访问修饰付的后面加event关键字，就定义了一个事件
3）使用方法与委托一样，只是避免了以上两个问题
4）由于事件只能有+=或-=赋值，所以就避免了用=（等号）赋值时覆盖前面事件处理程序的问题
5）由于事件不能在定义事件的类以外被触发，所以也就避免了冒充事件触发的问题。
36、委托和事件的区别（面试常考）
委托和事件没有可比性，委托是数据类型，事件是委托类型的变量
委托可以用+=、-=、=赋值，可以在类的外部被调用
事件只能用+=、-=赋值，不能在类的外部被调用
事件的内部是用委托实现的
事件的作用和委托变量（不是委托，是委托变量）一样，只是在功能上受到一定的限制
37、var类型
var只能用作局部变量，可以赋任何类型的值。
var a = 1；和int a = 1；两者完全一样
var不能作为类的成员的类型，不能用作参数，不能用作返回值，只能用作局部变量
38、扩展方法（不修改微软系统方法源代码，实现系统方法的增加）
1）添加一个静态类
2）在静态类中增加一个静态方法，方法参数是：（this+要扩展的类名+变量名，该方法的参数）
如要在string类中添加一个验证是否是Email格式的扩展方法：
public static bool IsEmail(this string str)
{
return Regex.IsMatch(str, @"^w+@w+.w+$");
}
string a = "1321321@qq.com";
Console.WriteLine(a.IsEmail());
扩展方法只是看起来像类中的方法，其实不是，所以在扩展方法中也访问不到类中原来的私有成员
因为会扰乱系统方法，所以不建议使用，尽量不用
39、XML
XML是用一种格式化的方式来存储数据，可以用记事本打开
1）XML有且只有一个根元素
2）有开始标签就必须得有结束标签，且区分大小写
3）元素的属性值要用引号
读取XML文件，通过XDocument（需要添加命名空间）
读取整个XML文件： XDocument xd = XDocument.Load（XML文件路径）
循环遍历每个节点：
1）获取根节点 XElement xeRoot = xd.Root；（xeRoot.ToString（）表示XML文档的内容）
2）递归遍历XML中的每个节点
遍历xeRoot下面的所有子节点：
public static void GetEle(XElement xe)
{
foreach (XElement ele in xe.Elements())
{
Console.WriteLine(ele.Name);
GetEle(ele);
}
}
GetEle(xeRoot);
例：读取XML数据
<CFX>
<MSG>
<交易码val="1000" />
<流水号val="100000000000000001" />
<金额val="1234567890.12" />
<付款机构val="1234" />
<付款单位账号val="12345678901234567890" />
<收款机构val="1234" />
<收款单位账号val="12345678901234567890" />
</MSG>
<MSG>
<交易码val="1000" />
<流水号val="100000000000000002" />
<金额val="1234567890.12" />
<付款机构val="1234" />
<付款单位账号val="12345678901234567890" />
<收款机构val="1234" />
<收款单位账号val="12345678901234567890" />
</MSG>
</CFX>
VS中读取XML的数据：
XDocument xd = XDocument.Load("ytbank.xml"); //加载XML文件
XElement xeRoot = xd.Root; //获取根节点
foreach (XElement item in xeRoot.Elements()) //遍历根节点，获取第一级子节点（MSG）
{
foreach (XElement itema in item.Elements()) //遍历第一级子节点，获取第二级子节点
{
Console.WriteLine("{0}：{1}", item.Element(itema.Name).Name, item.Element(itema.Name).Attribute("val").Value); //获取节点名和属性值
}
Console.WriteLine("==================================");
}
XML写入：
XDocument xdoc = new XDocument(); //创建一个XML对象
XElement xeleRoot = new XElement("Websites"); //创建一个根节点
xdoc.Add(xeleRoot); //将根节点添加到XML文件中
xeleRoot.SetElementValue("baidu", "http://www.baidu.com"); //添加一个节点以及内容
XElement xeleGoogle = new XElement("website"); //创建一个节点
xeleGoogle.SetAttributeValue("url", "http://www.google.com"); //添加属性和属性值
xeleGoogle.SetElementValue("name", "谷歌"); //为节点添加子节点
xeleGoogle.SetElementValue("age", "14");
xeleGoogle.SetElementValue("boss", "谢盖尔");
xeleRoot.Add(xeleGoogle); //将节点添加进根节点
xdoc.Save("website.xml"); //保存一个XML文档路径