小白零基础C#学习笔记

一、概述

　　1、.Net

　　　　1)、.Net平台

　　　　2)、.Net Frameword框架

　　　　说明：是.Net平台中不可缺少的一部分，提供了一个稳定的运行环境来保证.Net平台开发的各种应用能够正常运转。

　　2、解决方案、项目、类

　　　　解决方案：公司；

　　　　项目：部门；

　　　　类：员工

　　3、注释符

　　　　a)、注销

　　　　b)、解释

　　　　　　1)、单行注释　　//

　　　　　　2)、多行注释　　/**/

　　　　　　3)、文档注释　　///　　多用来注释类或者方法

　　　　　　　　ctrl + k + d　　==》　　对其排版

　　　　　　　　ctrl + k + c　　==》　　批量注释

　　　　　　　　ctrl + k + u　　==》　　批量取消注释

　　　　　　　　#region　　#endregion　　==》赋予块给定名称，折叠代码

　　4、命名

　　　　1)、camel命名（首单词字母小写，其余每个单词首字母大写，如：highSchoolStudent）==》多用于变量命名

　　　　2)、Pascal命名（每个单词首字母都要大写，如：HighSchoolStudent）==》多用于类或方法命名

　　5、命名空间

　　　　类是属于命名空间的。

　　　　　　1)、鼠标引用；

　　　　　　2)、Alt + Shift + F10；

　　　　在一个项目中引用另一个项目的类：

　　　　　　***添加引用；

　　　　　　***引用命名空间；

　　6、程序集：一个或多个类型文件和资源文件的集合，和命名空间类似。

二、语法

　　1、常量：程序中不会发生变化，固定不变的量。

　　　　整数常量：二进制、八进制、十进制、十六进制

　　　　浮点数常量：float、double

　　　　字符常量：'值'

　　　　字符串常量："值"

　　　　bool常量：true / false

　　　　null：没有任何内容

　　2、转义符：' \ ' + 特殊字符　　==》特殊意义的字符

　　　　\ n　　==》换行

　　　　\ "　　==》打印结果" \" "

　　　　\ t　　==》table键空格

　　　　\ b　　==》退格键Backspace（放到字符串两端无效果）

　　　　\ r \ n　　==》Windows操作系统不认识，只认识 \ r \ n

　　　　\ \ 　　==》表示一个 \

　　　　@　　==》取消 \ 在字符串中的转义作用：将字符串按源格式输出

　　3、变量：在计算机中存储数据

　　4、数据类型：

　　　　1)、整数：int 只能存整数

　　　　2)、小数：double 既能存整数又能存小数 小数点后15~16位

　　　　3)、金钱：decimal 存金钱，后面加上单位m（money）

　　　　4)、字符串：string 存储多个文本，可为空，被双引号引起来（英文半角状态下）

　　　　5)、字符：char 存储单个字符，最多最少只能有一个，不能为空，被单引号引起来（英文半角状态下）

　　5、类型转换：

　　　　隐式类型转换：等号两边参与操作数的类型必须一致，如果不一致，满足下列条件会发生自动转换

　　　　　　两种类型兼容（int 和 double 都是数字类型）；

　　　　　　目标类型大于源类型（小的转大的）；

　　　　显式类型转换：

　　　　　　两种类型兼容：int -- double；

　　　　　　大的转小的：double --> int　　==》double d;　　int a = (int) d;

　　6、运算符

　　　　算术运算符：+=　　-=　　eg：int num =10;　　num +=20;　　==》num = num + 20;

　　　　关系运算符：>、<、>=、<=、==

　　　　逻辑运算符：&& 逻辑与　　||逻辑或　　！逻辑非

　　7、三元表达式

　　　　表达式1 ？表达式2 ：表达式3

　　　　1)、表达式1 一般为一个关系表达式；

　　　　2)、表达式1 为 true，则 表达式2 的值就是整个三元表达式的值；

　　　　3)、表达式1 为 false，则 表达式3 的值就是整个三元表达式的值；

　　　　eg：　　int max = n1 > n2 ? n1 : n2;

　　　　注意：表达式2 的结果类型必须与表达式3的结果类型一致，与整个三元表达式的结果类型一致。

　　8、程序调试

　　***　1)、单步调试：

　　　　　　设置断点　　==》点击空白处

　　　　　　单步运行　　==》F11逐句调试

　　　　　　观察变量　　==》鼠标放在变量名上观察

　　　　监视==》调试-->窗口-->监视

　　　　2)、逐过程调试　　==》F10

　　***　3)、断点调试（程序运行到断电出就不再执行）

　　9、关键字

　　　　a、break作用：

　　　　　　1)、跳出 switch - case 结构；

　　　　　　2)、中断当前循环；

　　　　b、goto 语句：

　　　　　　eg：goto : end;

　　　　　　　　end : Console.WriteLine("跳到这儿来了");

　　　　c、continue：

　　　　　　1)、跳过当次循环；

　　　　　　2)、while 循环中使用 continue 和break 都一样，只作用于一层循环；

　　　　d、return：

　　　　　　1)、在方法中返回要返回的值；

　　　　　　2)、立即结束本次方法；

　　　　e、new：

　　　　　　*创建对象：

　　　　　　　　1)、在内存中开辟空间；

　　　　　　　　2)、在开辟的空间中创建对象；

　　　　　　　　3)、用对象的构造函数进行初始化对象；

　　　　　　*隐藏从父类那里继承过来的同名成员（隐藏后子类调不到父类的成员）。

　　　　f、this：

　　　　　　1)、代表当前类的对象；

　　　　　　2)、在类当中显式的调用本类的构造函数；　　==》this()

　　10、静态字段：public static int i = 0;　　（供全局使用）

　　11、不使用第三方变量来交换变量值：

　　　　int n1 = 10;

　　　　int n2 = 20;

　　　　n1 = n1 - n2;　　// n1= -10　　n2= 20

　　　　n2 = n1 + n2;　　// n1= -10　　n2= 10

　　　　n1 = n2 - n1　　// n1= 20　　n2= 10

三、基础知识

　　1、方法：一堆代码重用的机制。

　　　　[ public ] static 返回值类型 方法名( [ 参数列表 ] )

　　　　{

　　　　　　方法体；

　　　　}

　　　　调用：类名 . 方法名( 参数 )

　　2、重载：方法的名称相同，参数类型不同。

　　　　1)、如果参数个数相同，类型就不能相同；

　　　　2)、如果参数类型相同，个数就不能相同；

　　***：与返回值无关

　　3、递归：自己调用自己；

　　4、几种参数：

　　　　1)、params 可变参数：将实参列表中跟可变参数数组类型一致的元素都当作数组的元素处理。

　　　　　　eg：static void Main(string[] args)

　　　　　　{

　　　　　　　　//int[] s = { 87,89,90};

　　　　　　　　Test( 87,89,90 );

　　　　　　}

　　　　　　public static void Test(params int[] score)

　　　　　　{

　　　　　　　　int sum = 0;

　　　　　　　　for(int i=0 ; i < score.length ; i++)

　　　　　　　　　　sum += score[i];

　　　　　　}

　　　　2)、out 参数：

　　　　　　在一个方法中，返回多个相同类型的值的时候，可以考虑返回一个数组，但是如果返回多个不同类型的值的时候，返回数组就不行了，这个时候可以考虑使用out参数。==》侧重于在一个方法中返回多个不同类型的值。

　　　　　　out 参数在方法内部必须被赋值；

　　　　3)、ref 参数：

　　　　　　将一个变量带入一个方法中进行改变，改变完成后将改变后的值带出方法。

　　5、冒泡排序

　　　　eg：int [ ] nums = { 9,8,7,6,5,4,3,2,1,0 };

　　　　　　for( int i = 0 ; i < nums.length - 1 ; i++ )

　　　　　　{

　　　　　　　　for( int j = 0 ;j < nums.length - 1 - i ; j++ )

　　　　　　　　{

　　　　　　　　　　if( nums[ j ] > nums[ j +1 ])

　　　　　　　　　　{

　　　　　　　　　　　　int temp;

　　　　　　　　　　　　temp = nums[ j ];

　　　　　　　　　　　　nums[ j ] = nums[ j + 1 ];

　　　　　　　　　　　　nums[ j + 1] = temp;

　　　　　　　　　　}

　　　　　　　　}

　　　　　　}

　　　　　　对数组进行反转，等价于 ==》Array.Sort( nums );　　升序排列

　　　　　　　　　　先升序再反转　　　　Array.Reverse( nums );　　降序排列

　　6、多维数组

　　　　二维数组：　　int[ , ] array = new int[ 3,2 ]{ { 3,4 },{ 6,7 },{ 8,9 } };

　　　　　　　　　　　　array.GetLength( 0 );　　//维度数

　　　　　　　　　　　　array.GetLength( 1 );　　//个数

四、面向对象编程

　　对象：看得见摸得着；

　　1、面向对象：写出通用的代码，屏蔽差异。

　　　　1)、封装：Console.WriteLine( "Hello World!" );　　Console的作用

　　　　2)、继承：减少大量冗余代码；

　　　　3)、多态：让不同对象处理同一个消息时产生不同的反应。

　　2、类：具有相同属性和方法被封装抽象出来，成为类。

　　　　a、字段　　Fields

　　　　b、属性　　Property

　　　　c、方法　　Methods

　　***　类不占内存，对象占内存　***

　　3、属性：保护字段，对字段赋值和取值进行限定。

　　　　get 和 set

　　4、访问修饰符

　　　　1)、public：

　　　　2)、private：只能在当前类的内部访问；

　　　　3)、protected：只能在当前类的内部以及该类的子类中访问；

　　　　4)、internal：只能在当前程序集中访问（项目中），同项目中和 public 权限一样

　　　　5)、protected internal：

　　　　　　***　修饰类的访问修饰符只有 public 和 internal　***

　　5、构造函数：初始化对象（给对象的每个属性依次赋值）***　是一种方法。

　　　　1)、没有返回值，不能写void；

　　　　2)、构造函数的名称必须和类名一样；

　　　　　　构造函数可以重载

　　　　***类当中会有一个默认的无参数构造函数，当写一个新的构造函数之后，默认的无参数构造函数会被替换掉。

　　6、索引器

　　　　class program

　　　　{

　　　　　　static void Main( string[] args)

　　　　　　{　　

　　　　　　　　Person a = new Person();
　　　　　　　　a[1] = "刘雨晨";
　　　　　　　　a[2] = "男";
　　　　　　　　a[3] = "20";
　　　　　　　　a.SayHello();
　　　　　　　　Console.ReadKey();

　　　　　　}

　　　　}

　　　　class Person

　　　　{

　　　　　　private string _name;

　　　　　　private string _sex;

　　　　　　private string _age;

　　　　　　public string this[ int index ]

　　　　　　{　　

　　　　　　　　get
　　　　　　　　{
　　　　　　　　　　switch (index)
　　　　　　　　　　{
　　　　　　　　　　　　case 1:return _name;
　　　　　　　　　　　　case 2:return _sex;
　　　　　　　　　　　　case 3:return _age;
　　　　　　　　　　　　default:return null;
　　　　　　　　　　}
　　　　　　　　}

　　　　　　　　set
　　　　　　　　{
　　　　　　　　　　switch (index)
　　　　　　　　　　{
　　　　　　　　　　　　case 1:_name = value;
　　　　　　　　　　　　　　break;
　　　　　　　　　　　　case 2:_sex = value;
　　　　　　　　　　　　　　break;
　　　　　　　　　　　　case 3:_age = value;
　　　　　　　　　　　　　　break;
　　　　　　　　　　}
　　　　　　　　}

　　　　　　}

　　　　　　public void SayHello()
　　　　　　{
　　　　　　　　Console.WriteLine("我叫{0},{1},我{2}岁了",this[1],this[2],this[3]);
　　　　　　}

　　　　}

　　7、垃圾回收机制(GC-- Garbage Collection)：每隔一段时间，都扫描内存，如果有空间未被引用，则立即销毁。

　　　　　　销毁对象时执行析构函数

　　8、静态与非静态：

　　　　1)、在非静态类中，既可以有实例成员，也可以有静态成员;
　　　　2)、在调用实例成员的时候，需要使用对象名.实例成员;
　　　　　　在调用静态成员的时候，需要使用类名.静态成员;

　　　　总结：

　　　　a、静态成员必须使用类名去调用，而实例成员使用对象名调用。
　　　　b、静态函数中，只能访问静态成员，不允许访问实例成员。
　　　　c、实例函数中，访问静态成员和访问实例成员，都可以。

　　　　使用：
　　　　a、想把类当成“工具类”使用，这个时候可以考虑将类写成静态类;
　　　　b、静态类在整个项目中资源共享;

　　9、单例模式

　　　　1)、将构造函数私有化;
　　　　2)、提供一个静态方法，返回一个对象;
　　　　3)、创建一个单例;

　　　　eg：　　Form1.cs：

　　　　　　　　private void button1_Click(object sender, EventArgs e)
　　　　　　　　{
　　　　　　　　　　Form2 frm2 = Form2.GetSingle();
　　　　　　　　　　frm2.Show();
　　　　　　　　}
　　　　　　From2.cs：

　　　　　　　　//全局唯一的单例
　　　　　　　　public static Form2 FrmSingle = null;
　　　　　　　　public static Form2 GetSingle()
　　　　　　　　{
　　　　　　　　　　if (FrmSingle == null)
　　　　　　　　　　{
　　　　　　　　　　　　FrmSingle = new Form2();
　　　　　　　　　　}
　　　　　　　　　　return FrmSingle;
　　　　　　　　}

　　10、嵌套类

　　　　eg：class Program

　　　　　　{　　

　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　OutsideClass oc = new OutsideClass();
　　　　　　　　　　oc.OutsideMethod();
　　　　　　　　　　Console.ReadKey();
　　　　　　　　}

　　　　　　}

　　　　　　class OutsideClass//外部类
　　　　　　{
　　　　　　　　class NestedClass//嵌套类
　　　　　　　　{
　　　　　　　　　　public int _age = 20;
　　　　　　　　}

　　　　　　　　public void OutsideMethod()
　　　　　　　　{
　　　　　　　　　　NestedClass nc = new NestedClass();
　　　　　　　　　　Console.WriteLine(nc._age);
　　　　　　　　}
　　　　　　}

　　11、匿名类

　　　　　　var person = new {Name="张三",Age=20,Gender="男"};
　　　　　　Console.WriteLine(person.Name);
　　　　　　Console.WriteLine(person.Age);
　　　　　　Console.WriteLine(person.Gender);
　　　　　　Console.ReadKey();

　　12、继承

　　　　　　特性：单根性：一个子类只能有一个父类;

　　　　　　　　　传递性：子类并没有继承父类的构造函数，但是子类会默认的调用父类无参数的构造函数，创建父类对象，让子类可以使用父类中的成员。在父类中重新写了一个有参数的构造函数之后，那个无参数的构造函数被干掉，子类调用不到，会报错。

　　　　　　解决办法：
　　　　　　　　　　1)、在父类中重新写一个无参数的构造函数;
　　　　　　　　　　2)、在子类中显式的调用父类的构造函数：:base(name,age,gender)

　　13、装箱和拆箱

　　　　　　装箱：将值类型转换为引用类型；
　　　　　　拆箱： 　　

　　14、重写

　　　　　　如果子类需要重写父类的函数，那么需要将父类要被重写的函数标记为虚方法。

　　15、密封类(sealed)：不能被继承，但可以继承其他类;

　　　　　　　　　　如果函数被sealed关键字标记，那么这个函数不允许被重写;

　　16、多态：一个对象表现出多种类型。

　　　　　　a、虚方法：
　　　　　　　　步骤：1)：将父类的方法标记为虚方法，使用关键字virtual;

　　　　　　b、抽象类：
　　　　　　c、接口：

　　17、里式转换

　　　　　　1)、子类可以赋值给父类;
　　　　　　　　Student s = new Student();
　　　　　　　　Person p = s;

　　　　　　2)、如果父类装的是子类对象，那么可以将这个父类强转为子类对象。
　　　　　　　　Student ss = (Student)p;
　　　　　　　　if(p is Student) Teacher t=p as Teacher;
　　　　　　　　　　is：表示类型转换，如果能够转换成功，则返回一个true，否则返回一个false;
　　　　　　　　　　as：表示类型转换，如果能够转换则返回对应的对象，否则返回一个null;

　　18、抽象类：当父类中的方法不知道如何去实现的时候，可以考虑将父类写成抽象类，将方法写成抽象方法。

　　19、接口：一个规范，能力。(I..able)

　　　　　　**不允许写具有方法体的函数;
　　　　　　**接口中成员不允许被添加访问修饰符，默认就是public;
　　　　　　**接口中只能有方法、属性、所引器、事件，不能有字段和构造函数;
　　　　　　**接口与接口之间可以继承，并且可以多继承;
　　　　　　**实现接口的子类必须实现该接口的全部成员;
　　　　　　**一个类可以同时继承一个类并实现多个接口，接口必须写在类之前;
　　　　　　public class Student：Person,IStudyable 　　

　　20、字符串string：

　　　　　　　字符串的不可变性：指针指向堆空间

　　21、字符串可看做是char类型的一个只读数组;

　　　　　　ToCharArray();将字符串转换为char数组;

　　　　　　new string(char[] chs)：将char数组转换为字符串;
　　　　一些属性：

　　　　　　1)、ToLower(); / ToUpper();

　　　　　　2)、Equals(lessonTwo,StringComparison.OrdinalIgnoreCase)：比较两个字符串;

　　　　　　3)、分割字符串：Split();

　　　　　　　　分割并去除“空”：
　　　　　　　　　　string s = "a b dads _ + = ,,, asd";
　　　　　　　　　　char[] chs = {' ','_','+','=',','};
　　　　　　　　　　string[]str = s.Split(chs,StringSplitOptions.RemoveEmptyEntries);

　　　　　　4)、字符串替换：string Replace(string old/alue，string newValue)将字符串中的出现oldValue的地方替换为newValue。例子：名字替换;

　　　　　　5)、取子字符串：string Substring(int startindex)取从位置startindex开始一直到最后的子字符串;

　　　　　　　　　　　　　　string path = @"C:\a\c\c\a\da\d\ad\a\d\ad\a\Amy.exe";
　　　　　　　　　　　　　　int index=path.LastIndexOf("\\");
　　　　　　　　　　　　　　path=path.Substring(index+1);
　　　　　　6)、string Substring(intstartindex，intlength)取从位置startindex开始长度为length的子字符串，如果子字符串的长度不足length则报错;

　　　　　　7)、bool contains(string value)判断字符串中是否含有子串value;

　　　　　　8)、bool StartsWith/EndsWith(string value)判断字符串是否以子串value开始/结束;

　　　　　　9)、int IndexOf(string value)：取子串value第一次出现的位置,包括当前位置,找不到返回-1;

　　　　　　10)、Lastindexof();最后一次出现的位置;

　　　　　　11)、Trim();TrimStrat();TrimEnd();去空格/前面空格/后面空格;

　　　　　　12)、IsNullOrEmpty();
　　　　　　　　　　string str="";
　　　　　　　　　　string.IsNullOrEmpty(str)

　　　　　　13)、Join();将数组按照指定的字符串连接，返回一个字符串。 //张三|李四|王五

　　22、StringBuilder

　　　　　　StringBuilder仅仅是拼接字符串的工具，大多数情况下还需要把它转化为String
　　　　　　　　StringBuilder sb=new StringBuilder();
　　　　　　　　sb.Append(); //追加字符串
　　　　　　　　sb.ToString(); //把StringBuilder转化为字符串
　　　　　　　　sb.Insert();
　　　　　　　　sb.Replace();
　　　　　　　　StringBuilder sb = new StringBuilder(); //效率很高
　　　　　　　　string str = null;

　　　　　　　　//创建一个计时器，用来记录程序运行的时间

　　　　　　　　Stopwatch sw = new Stopwatch();
　　　　　　　　sw.Start();
　　　　　　　　for (int i = 0; i < 100000; i++)
　　　　　　　　{
　　　　　　　　　　//str += i;
　　　　　　　　　　sb.Append(i);
　　　　　　　　}
　　　　　　　　sw.Stop();
　　　　　　　　Console.WriteLine(sw.Elapsed); 　　

　　23、DateTime

　　　　　　　　DateTime.Now
　　　　　　DateTime.Now.ToShortDateString();//拿到当前日期的字符串
　　　　　　DateTime.Now.ToShortTimeString();//拿到当前时间的字符串 　　

　　24、Random

　　　　　　//1、创建能够产生随机数的对象
　　　　　　　　　　Random r=new Random();
　　　　　　//2、让产生的随机数这个对象调用方法来产生随机数
　　　　　　　　　　int rNumber=r.Next(1,10); //范围,左闭右开区间

五、WinForm　

　　1、Winform应用程序是一种智能客户端技术，我们可以使用WinForm应用程序帮助我们获得信息或者传输信息等。

　　2、属性

　　　　*Name：在后台获得前台的控件对象;
　　　　*Anchor：
　　　　*BackgroundImageLayout：背景图片布局;
　　　　*ContextMenuStrip：右键菜单，通过控件属性的此属性绑定;
　　　　*Cursor：设置光标样式;
　　　　*Enabled：控件是否可用;
　　　　*FlatStyle：控件样式，3D、平铺等;
　　　　*Visible：控件是否课可见;

　　3、事件

　　　　注册事件：
　　　　触发事件：

　　　　　　添加静态类Test：
　　　　　　　　public static class Test
　　　　　　　　{
　　　　　　　　　　public static Form1 _frm1Test;//静态字段全局访问

　　　　　　　　}
　　　　　　　　Form1_Load ==》Test._frm1Test=this;
　　　　　　Form1：
　　　　　　　　Form2 frm2 = new Form2();
　　　　　　　　frm2.Show();
　　　　　　Form3：
　　　　　　　　Test._frm1Test.Close();//关闭主窗体，简介关闭所有窗体

　　4、control类：(容器)==》获得当前窗体中所有的控件

　　　　　　Control.ControlCollection con=this.Controls;

　　5、TextBox；

　　　　　　WordWrap自动换行;
　　　　　　ScrollBars：滚动条;
　　　　　　PasswordChar：密码替换符;

六、文件操作

　　File类：(只适用于读小文件，读大文件还是需要文件流)

　　1、读取

　　　　文本：string str = File.ReadAllText(@"G:\E盘装不下的假期学习资源\C#程序设计基础入门 视频\下载必看文　　档.txt",Encoding.Default);
　　　　操作每行： File.ReadAllLines

　　2、写入

　　　　1)、替换写入

　　　　　　string str = "我喜欢你颜玲!";
　　　　　　byte[] buffer = Encoding.Default.GetBytes(str);
　　　　　　File.WriteAllBytes(@"G:\E盘装不下的假期学习资源\C#程序设计基础入门 视频\a.txt", buffer);
　　　　　　File.WriteAllLines(@"G:\E盘装不下的假期学习资源\C#程序设计基础入门 视频\a.txt",new string[] {"颜玲我喜欢你!","我真的好喜欢你！"});

　　　　2)、追加写入

　　　　　　File.AppendAllText(@"G:\E盘装不下的假期学习资源\C#程序设计基础入门 视频\a.txt","想看看我的小心心么！");

　　Directory：操作文件夹和目录

　　　　　　Directory.GetDirectories(Path) //获得指定目录下所有文件夹的全路径
　　　　　　Directory.CreateDirectory(Path) //创建文件夹
　　　　　　Directory.Delete(Path,true) //删除文件夹，若文件夹含有文件，则后面的true表示确认删除
　　　　　　Directory.Exists();
　　　　　　FileStream(文件流)：操作字节

　　　　1)、读取

　　　　　　//路径,文件操作，数据操作
　　　　　　FileStream fsRead = new FileStream(@"C:\Users\Jery\Desktop\Amy.txt",FileMode.OpenOrCreate,FileAccess.Read);

　　　　　　byte[] buffer = new byte[1024*1025*5];

　　　　　　//返回本次读取到的有效字节数
　　　　　　int r = fsRead.Read(buffer,0,buffer.Length); //每次读5M内容放到数组里

　　　　　　//将字节数组中每一个元素按照指定编码格式解码成字符串
　　　　　　string s = Encoding.Default.GetString(buffer,0,r);　　//从0开始解码，解码r个

　　　　　　//关闭流
　　　　　　fsRead.Close();

　　　　　　//释放流所占用的资源
　　　　　　fsRead.Dispose();
　　　　　　Console.WriteLine(s);

　　　　2)、将创建文件流对象的过程写在using中，会自动帮助我们释放流所占用的资源

　　　　　　//使用FileStream来写入数据
　　　　　　using (FileStream fsWrite = new 　　　　FileStream(@"C:\Users\Jery\Desktop\Amy.txt",FileMode.OpenOrCreate,FileAccess.Write))
　　　　　　{
　　　　　　　　string str = "看我覆盖掉了没？";
　　　　　　　　byte[] buffer = Encoding.Default.GetBytes(str);
　　　　　　　　fsWrite.Write(buffer,0,buffer.Length);
　　　　　　}
　　　　　　Console.WriteLine("OK");

　　　　3)、文件复制

　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　//将要复制的多媒体文件读取出来，然后写入到指定位置
　　　　　　　　string source = @"C:\Users\Jery\Desktop\第八章\7.Path类.mp4";
　　　　　　　　string target = @"C:\Users\Jery\Desktop\new.mp4";
　　　　　　　　CopyFile(source,target);
　　　　　　　　Console.WriteLine("复制成功");
　　　　　　　　Console.ReadKey();
　　　　　　}
　　　　　　public static void CopyFile(string source, string target)
　　　　　　{
　　　　　　　　//1、创建读取流
　　　　　　　　using (FileStream fsRead = new FileStream(source, FileMode.Open, FileAccess.Read))
　　　　　　　　{
　　　　　　　　//2、创建写入流
　　　　　　　　　　using (FileStream fsWrite = new FileStream(target, FileMode.OpenOrCreate, FileAccess.Write))
　　　　　　　　　　{
　　　　　　　　　　　　byte[] buffer = new byte[1024*1204*5];
　　　　　　　　　　　　//文件可能会比较大，所以读取时应该循环读取
　　　　　　　　　　　　while (true)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　//返回本次实际读取到的有效字节数
　　　　　　　　　　　　　　int r = fsRead.Read(buffer, 0, buffer.Length);
　　　　　　　　　　　　　　//如果返回0，读取完了，跳出循环
　　　　　　　　　　　　　　if (r == 0)
　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　break;
　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　fsWrite.Write(buffer,0,r);
　　　　　　　　　　　　}
　　　　　　　　　　}
　　　　　　　　}
　　　　　　}

　　StreamReader和StreamWriter 操作字符

　　　　　　//用StreamReader读取一个文本文件
　　　　　　using (StreamReader sr = new StreamReader(@"G:\E盘装不下的假期学习资源\C#程序设计基础入门 视频　\a.txt",Encoding.Default))
　　　　　　{
　　　　　　　　while (!sr.EndOfStream)
　　　　　　　　{
　　　　　　　　　　Console.WriteLine(sr.ReadLine());
　　　　　　　　}
　　　　　　}
　　　　　　Console.ReadKey();

　　Path类：

　　　　　　　　Path.GetFileName()
　　　　　　　　Path.GetExtension() //获得扩展名
　　　　　　　　Path.GetFileNameWithoutExtension() //获得文件名但是不包含扩展名

　　BufferedStream：减轻内存缓冲区，一般配合其它流使用

　　　　　　using (FileStream fsRead = new FileStream(@"C:\Users\Jery\Desktop\Amy.txt", FileMode.Open, FileAccess.Read))
　　　　　　{
　　　　　　　　using (BufferedStream bsRead = new BufferedStream(fsRead))
　　　　　　　　{
　　　　　　　　　　byte[] buffer = new byte[1024 * 1024 * 5];
　　　　　　　　　　int r = bsRead.Read(buffer, 0, buffer.Length);

　　　　　　　　　　string str = System.Text.Encoding.Default.GetString(buffer, 0, r);
　　　　　　　　　　Console.WriteLine(str);
　　　　　　　　}
　　　　　　}
　　　　　　Console.ReadKey();

　　　　　　using (FileStream fsWrite = new FileStream(@"C:\Users\Jery\Desktop\Amy.txt", FileMode.Open, FileAccess.Write))
　　　　　　{
　　　　　　　　using (BufferedStream bsWrite = new BufferedStream(fsWrite))
　　　　　　　　{
　　　　　　　　　　string s = "我是新写入的";
　　　　　　　　　　byte[] buffer = System.Text.Encoding.Default.GetBytes(s);
　　　　　　　　　　bsWrite.Write(buffer,0,buffer.Length);
　　　　　　　　}
　　　　　　}
　　　　　　Console.WriteLine("写入成功!");
　　　　　　Console.ReadKey();

　　序列化：将序列化对象的类 标记为可以被序列化的

　　　　static void Main(string[] args)
　　　　{
　　　　　　Person p = new Person();
　　　　　　p.Name = "颜玲";

　　　　　　using (FileStream fsWrite = new FileStream(@"C:\Users\Jery\Desktop\Amy.txt", FileMode.OpenOrCreate, FileAccess.Write))
　　　　　　{
　　　　　　　　BinaryFormatter bf = new BinaryFormatter();
　　　　　　　　bf.Serialize(fsWrite,p);
　　　　　　}
　　　　　　Console.WriteLine("序列化成功!");
　　　　　　Console.ReadKey();

　　　　　　//反序列化读出来
　　　　　　Person p;
　　　　　　using (FileStream fsRead = new FileStream(@"C:\Users\Jery\Desktop\Amy.txt", FileMode.OpenOrCreate, FileAccess.Read))
　　　　　　{
　　　　　　　　BinaryFormatter bf = new BinaryFormatter();
　　　　　　　　p=(Person)bf.Deserialize(fsRead);
　　　　　　}
　　　　　　Console.WriteLine(p.Name);
　　　　　　Console.ReadKey();
　　　　}

　　　　[Serializable]
　　　　public class Person
　　　　{
　　　　　　public string Name
　　　　　　{
　　　　　　　　get;set;
　　　　　　}
　　　　}

七、部分语法

　　1、集合继承关系

　　　　泛型集合 非泛型集合

　　　　　　List<T> Directory<TKey,TValue>
　　　　　　ArrayList Hashtable 　

　　2、 集合：长度可以分宜改变，类型随便

　　　　数组：长度不可变，类型单一
　　　　　　***将一个对象输出到控制台，默认情况下打印的是对象所在类的命名空间
　　　　　　　　int[] nums = {1,2,3,4,5};
　　　　　　　　Console.WriteLine(nums.ToString()); 　　　　结果为：System.Int32[] 　　

　　3、ArrayList长度问题：每次集合中实际包含的元素个数(count)超过了可以包含的元素个数(capcity)时，集合就会向内存中申请多开辟一倍的空间，来保证集合长度一直够用。

　　4、foreach：我们只需要遍历集合中的数据，而不需要对数据进行更改的时候;

　　5、List泛型集合：

　　　　集合转数组：
　　　　List<int> list=new List<int>();
　　　　int[] nums=list.ToArray();

　　6、Dictionary<T Key,T Value>泛型集合(键值对集合)：

----------------------------------------------------------------------------------------------------------------------------------------------------------------

----------------------------------------------------------------------------------------------------------------------------------------------------------------

此笔记可能尚不完善，为本人学习整理，整理不易，仅供参考，如有错误，请联系作者修改，特此分享，谢谢阅读！

----------------------------------------------------------------------------------------------------------------------------------------------------------------

----------------------------------------------------------------------------------------------------------------------------------------------------------------