目录
.NET FrameWork框架
.NET平台(类库)
快速启动vs
*.sln文件的使用(在解决方案里)
*.csprog文件的使用(在项目文件夹里)
排除语法错误
设置行号
设置字体
恢复出厂设置
自动切换运行的项目
C#的3种注释符
C#常用的快捷键
region的用法：
VS红/绿波浪线
变量命名规则
C#中的占位符
什么是异常
转义符
@与字符串配合的作用
隐式（强制）类型转换的条件
Convert类型转换
程序的调试
字符串转换其它类型
三元运算符的注意事项
常量的定义
枚举的使用
结构的使用
函数的调用
全局静态字段
方法中的高级参数用法out、ref、params
什么是属性
访问修饰符
静态和非静态的区别
静态类的使用
new关键字的作用
this关键字
命名空间的引入
在一个项目中引用另一个项目的类
string类型的常用方法
子类有没有继承父类的构造函数？
new关键字的两个作用
字节数组---字符串
字符串--->字节数组
检查程序运行的时间
属性的概念及作用
英文对照
静态和非静态的区别
析构函数
构造函数的概念
this关键字的用法
命名空间的概念及其用法
值类型和引用类型区别
字符串的使用
增强字符串的用法StringBuilder
使数组反转的方法
继承的概念及其注意事项
里氏转换
protected修饰符的作用
ArrayList
ArrayList集合的长度问题
随机数的使用
Hastable键值对集合
Path类的用法
File类的用法
用File类操作文件的数据
List<数据类型>的使用
Dictionary<类型, 类型>
装箱、拆箱的概念
文件IO流的实例代码
IO流复制大文件的实例代码
使用IO流操作文本文件实例
如何遍历一个文件夹的目录
移动文件夹需要如何异常处理
抽象类的介绍
实现多态的手段
c#中的访问修饰符
多线程中的AutoResetEvent类和ManualResetEvent类的区别
序列化与反序列化的代码示例
部分类概念
sealed密封类的概念
接口的基本概念
Directory类的使用
Process进程类的使用
前台线程和后台线程
创建XML代码实例
C#数据库的操作
.NET FrameWork框架
类似于JVM，由两个重要组件组成：CLR公共语言运行时；统一的.NET类库集。
类似网络基站
.NET平台(类库)
包含I/O，数据库支持，线程，XML解析，数据结构
类似中国移动互联网平台。
快速启动vs
win+r devenv
*.sln文件的使用(在解决方案里)
点击之后走vs，可以直接看该项目的解决方案。
*.csprog文件的使用(在项目文件夹里)
项目文件，包含项目信息，可以双击打开。
排除语法错误
生成——生成解决方案（用于在编译之前排查语法错误）。
设置行号
工具——选项——文本编辑器——C#——行号L
设置字体
工具——选项——环境——字体和颜色
恢复出厂设置
工具——导入和导出——重置
自动切换运行的项目
在解决方案右键属性，当前选定内容。
C#的3种注释符
1.单行注释 //
2.多行注释 /*要注释的内容*/
3.文档注释 /// 多用来解释类或者方法
C#常用的快捷键
对齐代码：ctrl+k+d 注意代码不能出现语法错误
弹出智能提示：ctrl+j
光标最前/最后切换选中状态：shift+end；shift+home 上/下
注释选中代码：ctrl+k+c
取消注释选中代码：ctrl+k+u
折叠冗余代码：#region 后面写说明 #endregion
查看源代码：F12
高亮查询：ctrl+shift+上/下
查看方法都在哪使用了：shift+F12
一次修改多个变量的名称：F2
构建代码：F6
运行代码：F5
逐行调试：F10
逐过程调试：F11（可以进入方法体）
移动代码：alt+上/下
多行修改：alt+鼠标拖动
删除整行：shift+del
选中部分代码自动生成方法：ctrl+R+M
快速生成构造函数：ctor tab
快速引入命名空间：alt+shift+F10
region的用法：
选中想要折叠的代码，ctrl+K+S
VS红/绿波浪线
红色代表语法有错误，绿色代表存在一定的风险
变量命名规则
开头可以@_字母，之后为字母，数字，下划线（其它的不行）
C#中的占位符
"{0}{1}{2}",a,b,c;//用变量去填坑,没填满的会报异常错误
什么是异常
语法上没有任何错误，只不过在运行过程由于某些原因出现了问题。
转义符
\n：换行（苹果系统或者控制台）
\t：制表
\b：删除前面的字符（注意：放在字符串的两端没有效果）
\r\n：换行（win系统）
\：表示一个\ 可以这样用@"F:\fjld\fd\a\q.txt"取消在字符串中的转义作用
@与字符串配合的作用
1.取消在字符串中的转义作用
2.将字符串按照原格式输出。
隐式（强制）类型转换的条件
两种类型兼容
目标类型大于源类型（强制则相反）
运算时会根据大的数据类型自动提升
{0:0.00}保留两位小数
Convert类型转换
类型不兼容时，类型转换。注意：面上要过得去
程序的调试
1.F11逐语句调试(单步调试)
2.F10逐过程调试
3.断点调试（在打断点处停止，即）
调试——窗口——监视
字符串转换其它类型
int number=int.Parse("字符串")
int number=int.TryParse("字符串",out num) 注意：不会出现异常，num为整数型，返回值为bool，转换失败num为0
三元运算符的注意事项
语法:表达式1?表达式2:表达式3;
注意：表达式2的结果类型必须跟表达式3的结果类型一致，并且也要跟整个三元表达式的结果类型一致。
常量的定义
在声明变量的最前面加const
枚举的使用
【public】enum 名称{
值1=4， //可以赋值，用于把枚举转换成int值为4
值2，
值3，
}
枚举声明到命名空间的下面，标识这个命名空间下所有的类都可以使用这个枚举。
枚举就是简单的变量类型。
枚举类型可以和int类型相互转换。
int类型的值当无法转换成枚举时候，直接转原值。
注意：所有的类型都能调用ToString()转换成string类型，用.ToString()返回值为字符串
将字符串转枚举类型：枚举类型 name=（枚举类型）Enum.parse(typeof(枚举的类型),要转换的字符串)；不能转换时抛出异常（数字型字符串不能转换时返回原值）。
结构的使用
作用：一次性声明多个不同类型的变量(字段)
结构中的变量叫字段，可以用修饰符修饰
【public】struct 结构名{
public string _name;
public int _age;
}
结构名 名
名.name="xxxx";
名.age=18;
函数的调用
跟Main函数在同一个类中可以直接调用，不在同一个类中需要用类名点上方法名调用。
全局静态字段
用于全局访问
方法中的高级参数用法out、ref、params
out:用于返回多个值，函数参数定义形式如下（out int a，out bool b，out string c），函数参数调用如下（out a1，out b1，out c1）注意：函数定义内部必须给out变量赋值。
ref:能够将一个变量带入一个方法中进行改变，改变完成后，再讲改变后的值带出方法。
params:将实参列表中跟可变参数数组类型一致的元素都当做数组的元素去处理。注意：params可变参数必须是形参列表中的最后一个元素。
什么是属性
属性的作用就是保护字段、对字段的赋值和取值进行限定。属性的本质就是两个方法，一个叫get()一个叫set()。
访问修饰符
public：公开的公共的，在哪都能访问。
private：私有的，只能在当前类的内部进行访问，出了这个类就访问不到了。
静态和非静态的区别
1.在非静态类中，既可以有实例成员，也可以有静态成员。
2.在调用实例成员的时候，需要使用对象名.实例成员;在调用静态成员的时候，需要使用类名.静态成员名;
总结：静态成员必须使用类名去调用，而实例成员使用对象名调用。静态函数中，只能访问静态成员，不允许访问实例成员。
静态类的使用
如果你想要你的类当做一个"工具类"去使用，这个时候可以考虑将类写成静态的。静态类在整个项目中资源共享。只有在程序全部结束之后，静态类才会释放资源。
new关键字的作用
1.在内存中开辟一块空间
2.在开辟的空间中创建对象
3.调用对象的构造函数进行初始化对象
this关键字
1.代表当前类的对象
2.在类当中显示的调用本类的构造函数 :this(参数，参数，参数。。。全部参数)
命名空间的引入
如果在当前项目中没有这个类（在其它项目中），需要我们手动的导入这个类所在的
1.用鼠标去点
2.alt+shift+F10
3.记住命名空间，手动的去引用
在一个项目中引用另一个项目的类
添加引用——引用命名空间
string类型的常用方法
ToCharArray()——将字符串转换为char数组
new string(char[] chs)——能够将char数组转换为字符串
Length——获得当前字符串中字符的个数
ToUpper()——将字符转换成大写形式
ToLower()——将字符串转换成小写形式
Equals(lessonTwo,StringComparison.OrdinalIgnoreCase)——比较两个字符串，可以忽略大小写
Split()——分割字符串，返回字符串类型的数组。
Substring()——解决字符串。在截取的时候包含要截取的那个位置。
IndexOf()——判断某个字符串在字符串中第一次出现的位置，如果没有返回-1、值类型和引用类型在内存上存储的地方不一样。
LastIndexOf()——判断某个字符串在字符串中最后一次出现的位置，如果没有同样返回-1
StartsWith()——判断以....开始
EndsWith()——判断以...结束
Replace(old，new)——将字符串中某个字符串替换成一个新的字符串
Contains()——判断某个字符串是否包含指定的字符串
Trim()——去掉字符串中前后的空格
TrimEnd()——去掉字符串中结尾的空格
TrimStart()——去掉字符串中前面的空格
string.IsNullOrEmpty()——判断一个字符串是否为空或者为null
string.Join()——将数组按照指定的字符串连接，返回一个字符串。
子类有没有继承父类的构造函数？
子类并没有继承父类的构造函数，但是。子类会默认的调用父类无参数的构造函数，
创建父类对象，让子类可以使用父类中的成员。
所以，如果在父类中重新写了一个有参数的构造函数之后，那个无参数的就被干掉了，
子类就调用不到了，所以子类会报错。
解决办法：
1)、在父类中重新写一个无参数的构造函数。
2)、在子类中显示的调用父类的构造函数，使用关键字:base()
new关键字的两个作用
1)、创建对象，调用对象的构造函数进行初始化对象。
2)、隐藏从父类那里继承过来的同名成员。隐藏的后果就是子类调用不到父类的成员。
字节数组---字符串
Encoding.Default.GetString(字节数组)
字符串--->字节数组
Encoding.Default.GetBytes(字符串)
检查程序运行的时间
Stopwatch sw=Stopwatch.Startnew();
//要检测的代码段
sw.stop();
TimeSpan ts=sw.Elapsed;
Console.WriteLine(ts);
属性的概念及作用
属性的作用就是保护字段、对字段的赋值和取值进行限定。
属性的本质就是两个方法，一个叫get()一个叫set()。
既有get()也有set()我们诚之为可读可写属性。
只有get()没有set()我们称之为只读属性
没有get()只有set()我们称之为只写属性
//代码实例
private string name;
public string Name
{
get { return name; } //内部可以写逻辑用于限定
set{ this.name=value; } //内部可以写逻辑用于限定
}
英文对照
Field字段
Method方法
Property属性
静态和非静态的区别
1)、在非静态类中，既可以有实例成员，也可以有静态成员。
2)、在调用实例成员的时候，需要使用对象名.实例成员;在调用静态成员的时候，需要使用类名.静态成员名;
总结：静态成员必须使用类名去调用，而实例成员使用对象名调用。
静态函数中，只能访问静态成员，不允许访问实例成员。
实例函数中，既可以使用静态成员，也可以使用实例成员。
静态类中只允许有静态成员，不允许出现实例成员。
注意：1)、如果你想要你的类当做一个"工具类"去使用，这个时候可以考虑将类写成静态的。
2)、静态类在整个项目中资源共享。只有在程序全部结束之后，静态类才会释放资源。
析构函数
定义在类中（类中的一个构造方法），当程序结束的时候 ，析构函数才执行，帮助我们释放资源
//实例
~类名()
{
业务逻辑
}
构造函数的概念
作用：帮助我们初始化对象(给对象的每个属性依次的赋值)
构造函数是一个特殊的方法：
1)、构造函数没有返回值，连void也不能写。
2)、构造函数的名称必须跟类名一样。
注意：创建对象的时候会执行构造函数
构造函数是可以有重载的。
类当中会有一个默认的无参数的构造函数，当你写一个新的构造函数之后不管是有参数的还是无参数的，那个默认的无参数的构造函数都被干掉了。
this关键字的用法
1)、代表当前类的对象
2)、在类当中显示的调用本类的构造函数 :this
//实例
public 类名(参数，参数):this(参数，参数...所有参数一次传值进入){减少了部分赋值代码}
//代码如下，调用了当前类的构造函数
public Person(string name, char gender):this(name,0,gender)
{
//this.Name = name;
//this.Gender = gender;
}
命名空间的概念及其用法
可以认为类是属于命名空间的。
如果在当前项目中没有这个类的命名空间，需要我们手动的导入这个类所的命名空间。
如何引入命名空间：
1)、用鼠标去点
2)、alt+shift+F10
3)、记住命名空间，手动的去引用
如何引入另一个项目中的类：
1)、添加引用（项目导航菜单里鼠标左键引入）
2)、引用命名空间
值类型和引用类型区别
值类型：int、double、bool、char、decimal、struct、enum
引用类型：string（不可变）、自定义类、数组
存储：
值类型的值是存储在内存的栈当中。
引用类型的值是存储在内存的堆中。
字符串的使用
- 可以将string类型，看做是char类型的一个只读数组，如str[索引]值为一个字符类型
- 字符串转字符数组：char[] chs = str.ToCharArray();
- 字符数组转字符串：string str=new string(chs);
- 比较2个字符串(可忽略大小写)：str1.Equals(str2,StringComparison.OrdinalIgnoreCase);
- 分割字符串(返回字符串类型的数组)：str.Splite(字符数组,StringSplitOptions.RemoveEmptyEntries);//第二个参数可以去除空格字符串数组
- 截取指定字符串：str.Substring(index,要截取的个数);
- 判断字符串出现的位置：str.IndexOf();
- 判断字符串以....开始：str.StartsWith();
- 替换字符串：str.Replace(old,new);
- 去除前后空格：str.Trim();
- 去除开始/结束空格：str.TrimStart()/str.TrimEnd();
- 判断是否包含某个字符串：str.Contains();
- string.IsNullOrEmpty()：判断一个字符串是否为空或者为null
- string.Join("连接符字符串",数组)：将数组按照指定的字符串连接，返回一个字符串。
增强字符串的用法StringBuilder
StringBuilder sb = new StringBuilder();sb.Append(字符串);sb.ToString();
使数组反转的方法
Array.Reverse(数组);
继承的概念及其注意事项
子类继承了父类的属性和方法，但是子类并没有继承父类的私有字段。
子类并没有继承父类的构造函数，但是。子类会默认的调用父类无参数的构造函数。这是因为要创建父类对象，让子类可以使用父类中的成员。
注意：如果在父类中重新写了一个有参数的构造函数之后，那个无参数的就被干掉了，子类就调用不到了，所以子类会报错。
解决办法：
1)、在父类中重新写一个无参数的构造函数。
2)、在子类中显示的调用父类的构造函数，使用关键字:base()，如同:this()的使用方式。
里氏转换
父类引用指向子类对象，没重载的情况调用父类方法，重载了就调用子类方法。
is：表示类型转换，如果能够转换成功，则返回一个true，否则返回一个false
as：表示类型转换，如果能够转换则返回对应的对象，否则返回一个null
protected修饰符的作用
受保护的：可以在当前类的内部以及该类的子类中访问。
ArrayList
类似于数组，为可变长度的存储空间，可以存放任意类型的数据
用法：
ArrayList list = new ArrayList();
list.Count //长度
list.Add(数据);//添加数据
list.AddRange(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 });//把1，2...数据依次添加
list.AddRange(list);//把list里面的数据依次添加
list.Clear();//清空所有元素
list.Remove(数据);//删除单个元素 写谁就删谁
list.RemoveAt(索引);//根据下标去删除元素
list.RemoveRange(index, count);//根据下标去移除一定范围的元素
list.Sort();//升序排列
list.Reverse();//反转
list.Insert(index, "插入的");//在指定的位置插入一个元素
list.InsertRange(0, new string[] { "张三", "李四" });//在指定的位置插入一个集合
list.Contains(元素);//判断是否包含某个指定的元素
ArrayList集合的长度问题
每次集合中实际包含的元素个数(count)超过了可以包含的元素的个数(capcity)的时候，集合就会向内存中申请多开辟一倍的空间，来保证集合的长度一直够用。
随机数的使用
Random r = new Random();
int num = r.Next(0, 10);//随机0-9
Hastable键值对集合
Hastable的使用：
Hashtable ht = new Hashtable();
ht.Add(1, "张三");//键不可重复添加
ht[1] = "把张三干掉";//重复添加为覆盖操作，非重复为创建
ht.ContainsKey("abc");//集合中是否包含键abc
ht.Clear(); //移除集合中所有的元素
ht.Remove(键);//删除键对应的字典
foreach (var item in ht.Keys)//循环字典的键
Path类的用法
获得文件名：Path.GetFileName(str);
获得文件名但是不包含扩展名：Path.GetFileNameWithoutExtension(str);
获得文件的扩展名：Path.GetExtension(str);
获得文件所在的文件夹的名称：Path.GetDirectoryName(str);
获得文件所在的全路径：Path.GetFullPath(str);
连接两个字符串作为路径：Path.Combine(@"c:\a" , "b.txt");
File类的用法
创建一个文件：File.Create(@"C:\Users\SpringRain\Desktop\new.txt");
删除一个文件：File.Delete(@"C:\Users\SpringRain\Desktop\new.txt");
复制一个文件：File.Copy(@"C:\Users\SpringRain\Desktop\code.txt", @"C:\Users\SpringRain\Desktop\new.txt");
剪切一个文件：File.Move(@"C:\Users\SpringRain\Desktop\code.txt", @"C:\Users\SpringRain\Desktop\newnew.txt");
用File类操作文件的数据
//将文件读取到字节数组中
byte[] buffer = File.ReadAllBytes(@"C:\Users\SpringRain\Desktop\1.txt");
//将字节数组转换成字符串
string s = Encoding.UTF8.GetString(buffer);
//将字符串写入到指定文件中
string s="今天天气好晴朗，处处好风光";
//将字符串转换成字节数组
byte[] buffer= Encoding.Default.GetBytes(s);
File.WriteAllBytes(@"C:\Users\SpringRain\Desktop\1.txt", buffer);
//一行一行读取
string[] contents = File.ReadAllLines(@"C:\Users\SpringRain\Desktop\抽象类特点.txt", Encoding.Default);
foreach (string item in contents)
{
Console.WriteLine(item);
}
//直接读取所有
string str = File.ReadAllText("抽象类特点.txt", Encoding.Default);
//一行一行写入
File.WriteAllLines(@"C:\Users\SpringRain\Desktop\new.txt", new string[] { "aoe", "ewu" });
//a直接全部写入
File.WriteAllText(@"C:\Users\SpringRain\Desktop\new.txt", "张三李四王五赵六");
//不发生覆盖的写入
File.AppendAllText(@"C:\Users\SpringRain\Desktop\new.txt", "看我有木有把你覆盖掉");
List<数据类型>的使用
用法与ArrayList类似
可以ToArray()，ToList()使泛型集合与数组相互转换
Dictionary<类型, 类型>
使用方式与HashTable类似
Dictionary<int, string> dic = new Dictionary<int, string>();
dic.Add(1, "张三");
dic.Add(2, "李四");
dic.Add(3, "王五");
dic[1] = "新来的";
foreach (KeyValuePair<int,string> kv in dic)
{
Console.WriteLine("{0}---{1}",kv.Key,kv.Value);
}
foreach (var item in dic.Keys)
{
Console.WriteLine("{0}---{1}",item,dic[item]);
}
装箱、拆箱的概念
装箱：就是将值类型转换为引用类型。
拆箱：将引用类型转换为值类型。
看两种类型是否发生了装箱或者拆箱，要看，这两种类型是否存在继承关系
注意：使用泛型集合而不使用ArrayList集合的目的是防止拆装箱。
文件IO流的实例代码
//使用FileStream来读取数据
FileStream fsRead = new FileStream(@"C:\Users\SpringRain\Desktop\new.txt", FileMode.OpenOrCreate, FileAccess.Read);
byte[] buffer = new byte[1024 * 1024 * 5];
//3.8M 5M
//返回本次实际读取到的有效字节数
int r = fsRead.Read(buffer, 0, buffer.Length);
//将字节数组中每一个元素按照指定的编码格式解码成字符串
string s = Encoding.UTF8.GetString(buffer, 0, r);
//关闭流
fsRead.Close();
//释放流所占用的资源
fsRead.Dispose();
Console.WriteLine(s);
Console.ReadKey();
//使用FileStream来写入数据
//using (FileStream fsWrite = new FileStream(@"C:\Users\SpringRain\Desktop\new.txt", FileMode.OpenOrCreate, FileAccess.Write))
//{
// string str = "看我游牧又把你覆盖掉";
// byte[] buffer = Encoding.UTF8.GetBytes(str);
// fsWrite.Write(buffer, 0, buffer.Length);
//}
//Console.WriteLine("写入OK");
//Console.ReadKey();
IO流复制大文件的实例代码
注意：将创建文件流对象的过程写在using当中，会自动的帮助我们释放流所占用的资源。
//1、我们创建一个负责读取的流
using (FileStream fsRead = new FileStream(soucre, FileMode.Open, FileAccess.Read))
{
//2、创建一个负责写入的流
using (FileStream fsWrite = new FileStream(target, FileMode.OpenOrCreate, FileAccess.Write))
{
byte[] buffer = new byte[1024 * 1024 * 5];
//因为文件可能会比较大，所以我们在读取的时候 应该通过一个循环去读取
while (true)
{
//返回本次读取实际读取到的字节数
int r = fsRead.Read(buffer, 0, buffer.Length);
//如果返回一个0，也就意味什么都没有读取到，读取完了
if (r == 0)
{
break;
}
fsWrite.Write(buffer, 0, r);
}
}
}
使用IO流操作文本文件实例
使用StreamReader来读取一个文本文件
using (StreamReader sr = new StreamReader(@"C:\Users\SpringRain\Desktop\抽象类特点.txt",Encoding.Default))
{
while (!sr.EndOfStream)
{
Console.WriteLine(sr.ReadLine());
}
}
//使用StreamWriter来写入一个文本文件
using (StreamWriter sw = new StreamWriter(@"C:\Users\SpringRain\Desktop\newnew.txt",true))//true为不覆盖
{
sw.Write("看我有木有把你覆盖掉");
}
如何遍历一个文件夹的目录
//封装一个遍历文件夹目录大方法
public void GetAllFiles(string path)
{
var dir=new DirectoryInfo(path);
foreach(var file in dir.GetFiles()) //GetFiles()获得所有文件对象
{
Console.WriteLine("文件名：{0}",file.Name);
}
foreach(var directory in dir.GetDirectories()) //GetDirectories获得所有文件夹对象
{
Console.WriteLine("文件夹名：{0}",directory.Name);
this.GetAllFiles(directory.FullName);
}
}
移动文件夹需要如何异常处理
public void MoveFile(string sourceFilePath,string destinationFilePath)
{
var temp=Path.GetTempFileName();
File.Copy(destinationFilePath,temp);
try
{
File.Move(sourceFilePath,destinationFilePath);
}
catch (Exception)
{
File.Copy(temp,sourceFilePath);
throw;
}
}
抽象类的介绍
1.抽象成员必须标记为abstract,并且不能有任何实现。
2.抽象成员必须在抽象类中。
3.抽象类不能被实例化
4.子类继承抽象类后，必须把父类中的所有抽象成员都重写。
（除非子类也是一个抽象类，则可以不重写）
5.抽象成员的访问修饰符不能是private
6.在抽象类中可以包含实例成员。
并且抽象类的实例成员可以不被子类实现
7.抽象类是有构造函数的。虽然不能被实例化。
8.如果父类的抽象方法中有参数，那么。继承这个抽象父类的子类在重写父类的方法的时候必须传入对应的参数。
如果抽象父类的抽象方法中有返回值，那么子类在重写这个抽象方法的时候 也必须要传入返回值。
注意：如果父类中的方法有默认的实现，并且父类需要被实例化，这时可以考虑将父类定义成一个普通类，用虚方法来实现多态。
如果父类中的方法没有默认实现，父类也不需要被实例化，则可以将该类定义为抽象类。
实现多态的手段
虚方法:将父类的方法标记为虚方法 ，使用关键字 virtual，这个函数可以被子类重新写一个遍。
抽象类:当父类中的方法不知道如何去实现的时候，可以考虑将父类写成抽象类，将方法写成抽象方法。
c#中的访问修饰符
public :公开的公共的
private：私有的，只能在当前类的内部访问
protected：受保护的，只能在当前类的内部以及该类的子类中访问。
internal：只能在当前项目中访问。在同一个项目中，internal和public的权限是一样。
protected internal：protected+internal
注意：1)、能够修饰类的访问修饰符只有两个：public、internal。2)、子类的访问权限不能高于父类的访问权限，会暴漏父类的成员。
多线程中的AutoResetEvent类和ManualResetEvent类的区别
详见——引用自CSDN一篇博客
序列化与反序列化的代码示例
将某个对象传输给对方电脑
Person p = new Person(); //例如：人这个对象，假设这个示例类已经定义好了
p.Name = "霍金";
p.Age = 27;
p.Gender = '男';
using (FileStream fsWrite = new FileStream(@"C:\Users\SpringRain\Desktop\111.txt", FileMode.OpenOrCreate, FileAccess.Write))
{
//开始序列化对象
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(fsWrite, p);
}
Console.WriteLine("序列化成功");
//接收对方发送过来的二进制 反序列化成对象
Person p;
using (FileStream fsRead = new FileStream(@"C:\Users\SpringRain\Desktop\111.txt", FileMode.OpenOrCreate, FileAccess.Read))
{
BinaryFormatter bf = new BinaryFormatter();
p = (Person)bf.Deserialize(fsRead);
}
部分类概念
用partial修饰class，将两个相同类名的partial class当做一个类使用。(用于多人协作)
sealed密封类的概念
不能够被其他类继承，但是可以继承于其他类。
接口的基本概念
1.只要一个类继承了一个接口(包括抽象类)，这个类就必须实现这个接口中所有的成员
2.接口不能被实例化。也就是说，接口不能new(不能创建对象)。
3.接口中的成员不能加“访问修饰符”，默认就是public。
4.接口中的成员不能有任何实现（必须“光说不做”）。
5.接口中只能有方法、属性、索引器、事件，不能有“字段”和构造函数。
6.接口与接口之间可以继承，并且可以多继承。
7.接口并不能去继承一个类，而类可以继承接口（类可以继承多个接口）。
8.实现接口的子类必须实现该接口的全部成员。
注意：抽象类的方法被子类实现时必须在实现方法前+override；但是子类实现的接口的方法不用+任何修饰符
Directory类的使用
用于操作文件夹
创建文件夹：Directory.CreateDirectory(@"C:\a");
删除文件夹：Directory.Delete(@"C:\a",true); //true里面有内容也可以删除，否则会抛出异常
剪切文件夹：Directory.Move(@"c:\a", @"C:\Users\SpringRain\Desktop\new");
获得指定文件夹下所有文件的全路径：string[] path = Directory.GetFiles(@"C:\Users\SpringRain\Desktop\Picture","*.jpg"); //第二个参数可以过滤文件
获得指定目录下所有文件夹的全路径：string[] path = Directory.GetDirectories(@"C:\Users\SpringRain\Desktop\new");
判断指定的文件夹是否存在：Directory.Exists(@"C:\a\b");
Process进程类的使用
获得当前程序中所有正在运行的进程：Process[] pros = Process.GetProcesses();
关闭一个进程：pros[0].Kill();
通过进程打开一些应用程序：Process.Start("calc");
通过一个进程打开指定的文件：
ProcessStartInfo psi = new ProcessStartInfo(@"C:\Users\SpringRain\Desktop\1.exe");
Process p = new Process();
p.StartInfo = psi;
p.Start();
前台线程和后台线程
多数线程都是前台线程(主线程也是)，后台线程是前台线程结束之后会自动关闭。
Thread t1=new Thread(Test);
t1.IsBackground=true;
t1.Start(); //开启线程
t1.Abort(); //结束线程
创建XML代码实例
//通过代码来创建XML文档
//1、引用命名空间
//2、创建XML文档对象
XmlDocument doc = new XmlDocument();
//3、创建第一个行描述信息，并且添加到doc文档中
XmlDeclaration dec = doc.CreateXmlDeclaration("1.0", "utf-8", null);
doc.AppendChild(dec);
//4、创建根节点
XmlElement books = doc.CreateElement("Books");
//将根节点添加到文档中
doc.AppendChild(books);
//5、给根节点Books创建子节点
XmlElement book1 = doc.CreateElement("Book");
//将book添加到根节点
books.AppendChild(book1);
//6、给Book1添加子节点
XmlElement name1 = doc.CreateElement("Name");
name1.InnerText = "金瓶梅"; //InnerXml可以写入标签
book1.AppendChild(name1);
name1. SetAttribute("Name", "充气娃娃"); //设置属性
doc.Save("Order.xml"); //保存文件,在debug目录中
//如果文件存在 加载XML
doc.Load("Books.xml");
//获得文件的根节点
books = doc.DocumentElement;
//获得子节点 返回节点的集合
XmlNodeList xnl = books.ChildNodes;
//XmlNodeList xnl = doc.SelectNodes("/Order/Items/OrderItem");
// Console.WriteLine(node.Attributes["Name"].Value);
//XmlNode xn = doc.SelectSingleNode("/Order/Items/OrderItem[@Name='190']");
//xn.Attributes["Count"].Value = "200";
C#数据库的操作
//Data Source路径；Initial Catalog 数据库名称
string connString = "Data Source=.;Initial Catalog=mytest;Integrated Security=True";
using (SqlConnection sqlcnn = new SqlConnection(connString))
{
sqlcnn.Open();
string strsql="sql"
using (SqlCommand cmm = new SqlCommand(strsql,sqlcnn))
{
using(SqlDataReader reader=cmm.ExecuteReader())
{
while(reader.Read()){ reader[''column''] }
}
}
}
