C#学习

                                    C#学习
                                    
<-------------------------------------第一篇----------------------------------------->

1、命名空间： 当需要某个命名空间中的类或者方法时，首先通过使用using指令引入命名空间，
using指令将命名空间名所标记的命名空间内的类型成员导入当前编译单元，从而使用被导入的类型的标识符。
英文单词：
Properties 属性  Methods  方法

2、以.cs结尾的文件称之为类 文件.sln 解决方案文件，代码程序；.csproj ：项目文件，里面包含着当前这个项目的信息，
不允许双击打来；
3、被class修饰的都称之为类 （例如：class  program；）
4、consonle.Writeline("要输出到控制台的文本"); //输出完之后换行
Console.Write("要输出到控制台的文本");         //输出完之后不换行
5、Console.ReadKey(); 表示暂停程序执行，等待用户按下任意键继续；
并且用户按下的任意键将显示到控制台中。
6、Ctrl+K+D:快速对齐代码，Ctrl+K+C:注释所选代码，Ctrl+K+U:取消对所选代码的注释；
7、#Region+“ ”空格， (填写功能注释)  程序。 #Endregion
在函数前输入 “ /// ”，函数前会自动生成注释表，可以填写函数功能和参数意义。
8、如果+号两边有一边是字符串的话，那么此时这个+号就起到连接的作用。
例如 string t = “goo”;
     t =t+"d";         //此时t就表示"good",“+”起连接作用。
如果+号两边都是数字，而不是字符串，那么此时加号就起到相加的作用。
9、占位符 用“{*}”表示（必须从0开始），在后续必须将申请的*全部写上对应的值，例如Consonle.Writeline("{0},{1}",a,b);
类似于函数的变量！---> void type（ int a, int b）;  中的a,b。   
10、接收用户输入的内容函数： string t = ReadLine（）；  //定义一个sting类型的变量用来存储用户输入的内容；
并且程序会在此等待用户输入内容。
11、转义字符： 转义符就是 一个'\'加上一个特殊的字符，组成了一个具有特殊意义的字符。
（1）\" 转义字符相当于英文的  “
（2）\r\n:表示换行，操作系统支持（最好使用此种类型）
     \n:表示换行，操作系统不支持
（3）\b:表示一个退格键，\b放到字符串的两边没有效果
（4）\t 空格的 表示一个Tab键
（5）\\ 表示为一个\
（6）@ 取消\在字符串中的转义作用，使其单纯的表示为一个\
让代码按照你编译的原格式输出；
例如 在程序中如果要寻地址 "C:\Users\hu\Desktop"  这样会报错的，因为\\ 表示一个\,正确的应该是：
"C:\\Users\\hu\\Desktop",但是这样比较繁琐 可以使用@C:\Users\hu\Desktop的方式，取消\\表示一个\，使程序原格式输出；

12、自动类型转换或者隐式类型转换： 条件（1）类型必须兼容（例如：int和double（都是数字类型））
                                   条件（2）必须是小的类型转大的类型
                                   例如： int t; double b = t;//将b的值给t；
13、强制类型转换： 大的转小的 ，结果是精度丢失；
14、Convert类型转换， 此为不兼容转换；所有的类型都可以相互转换。两种不兼容的类型之间的转换。
例如： string a,c;
       int b = Convert.toint32(a);   //将string的类型转化为int类型
       double t = Convert.todouble(c);
15、try-catch 异常捕获
try
{
    可能会出现异常的代码;
}
catch
{
    出现异常后要执行的代码;
}
16、int.TryParse();
尝试着将一个字符串转换成int类型，如果转换成功的话，返回一个true，并且将转换成功后的值
赋值给一个int类型的参数，如果转换失败的话，返回一个false，并且给这个int类型的参数赋值为0
例如：
int number = 0;
bool numberTwo = int.TryParse("ad",out number);

返回的numberTwo值，如果是ture 则转换成功，"ad"的值将存在number里面。返回false 则转换失败；
17、string result = name == x？ y： z：  // 如果name==x 则输出y 否则输出z
result为输出判断的值存放处。
18 枚举类型
public enum Number
{
    大学，
    高中，
    中学，
    小学
}
main()
{
    Number number = Number.大学；
    Number number = Number.中学；
    
}

Number a1 = (Number)enum.Parse(typeof(Number),"2");  //将字符串类型强制转换为枚举类型

输出的结果为：中学                                   // 被转换的字符串 在枚举中没有对应的值，将会抛异常。
19、结构体类型
public struct Student
{
    public int   ming;
    public char  number;
    public float age;    
}

Sudent Name;
Name.ming = hu;
Name.age = 12;

字段跟变量有一个本质的区别：字段可以存储多个值，而变量只能存储一个值。
_ming 是字段, ming 是变量;

20、数组的形式： 数组类型[] 数组名=new 数组类型[数组长度];          数组的长度 number.length   
注意：数组的长度一旦声明了，就不能再被改变了。
例如： int[] number = new int[10];
       int[] number = {1，2，2，3，4，6};
21、冒泡排序法
 int[] number = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
            for (int i = 0; i < 9; i++)
            {
                for (int j = 0; j < 10; j++)
                {
                    if (i < j)           //比较后交换
                    {
                        int t = number[i];
                        number[i] = number[j];
                        number[j] = t;
                    }
                    else                 //比较不成立进入下一次循环
                        continue;                
                }                
            }        
            
            for (int k= 0; k < 10; k++)  //打印出数组元素
            {
                Console.WriteLine(number[k]);
                Console.ReadKey();
            }

22、方法(函数)
语法：
public  static 返回值类型  方法名([参数列表])
{
    方法体;（函数体）
}
public:访问修饰符，公开的，公共的
static:表示静态
返回值类型：如果没有返回值，写void
方法名：Pascal命名规范，要求每个单词的首字母都要大写。
参数列表：完成这个方法，所必须要提供给这个方法的条件。哪怕方法中不需要参数，小括号也不能省略。

参数：
返回值：

方法的调用：
类名.方法名([参数列表]);  函数在哪个类里面，则写哪个类名
例如在Program类里面：
Program.turn();

23、out参数
可以帮助我们在一个方法中返回多个值，不限类型。
使用out参数的时候要求，out参数必须在方法内为其赋值。（即在函数中对out参数进行赋值）
例如 ：
public static string test(out int n)
{
    int a,b,c;
    a = 2;
    b = 3;
    c = a*b;
    n = 10;
    rrturn c;    
}
public static Main()
{
    int n;
    string a = Program.test(out n);
    Console.Write(n);
    //输出结果：6,10;  输出一个out的返回值和一个return的值；
}
24、ref参数：
ref参数侧重于将一个变量以参数的形式带到一个方法中进行改变，
改变完成后，再将改变后的值带出来。
在使用ref参数的时候需要注意：ref参数在方法外必须为其赋值。（即在主函数中必须有赋值）
void number(ref int t)
{
    t++;
}
功能是将number函数的参数t作为返回值进行调用
如果调用number函数，且外部声明且初始了t，则
t的值将会被根据number函数中设定输出出来，在主函数中输出；
注意：
（1）
public  ststic Main()
{
    int t = 10;
    number(t);
    Console.write(t);   //这里输出的t将还是10，因为number中的t虽然++了 但是没有输出出来，无法打印出来。    
}
（2）
public static Main()
{
    int t = 10;
    number(ref t);
    Console.write(t);   //这里输出的t将还是11，因为number中参数ref可以将t返回出来然后打印。    
}
25、方法的重载：
方法的名称，参数不同即可。
参数不同：
参数的类型相同，参数的个数不同
参数的个数相同，参数的类型不同

26、params可变参数数组 将数组的值直接写在形参中，无需外部声明。参数类型必须相同，且是形参参数最后一个。
举例 ：
public static void number (string a,params int[] numbers)  //number数组  ，最后一个形参参数。
{
    int num = 0;
    for(int i; i < numbers.Length; i++)    
        num +=numbers[i];    
    Console.WriteLine("{0}总和是{1}",a,num);
}
static stutic Main(string[] args)
{
    Program.number ("数组1",50,50,20,10);  //数组值直接写在形参参数中，对应的类型必须相同。
    Console.ReadKey();              // 优点，函数参数数量可变
    // 输出结果：数组1总和是130；              
}

27、方法的递归： 在方法内部自己调用自己。
28、 Console.ForegroundConlor = ConsoleColor.blue//给输出窗口设置颜色
29、字段和变量： public string _name ; //字段
                 public string  name;  //变量

<-------------------------------------第二篇----------------------------------------->

面向对象初步理解：使用封装好的方法，实现功能需求。
面向对象三大特征:封装、继承、多态

1、类的语法
[访问修饰符] class 类名
{
    类的成员;
    //字段、属性、方法
    _name;
    ....
}
访问修饰符：public

我们写好了一个类之后，需要创建这个类对象，我们管创建这个类的对象的过程，
称之为类的实例化。
使用关键字 new.
例如：创建一个Number类

在number中创建这个类的对象

Number bie = new.Number();  //创建一个number对象
类中成员中的作用：
 
1） 类中成员如果不加访问修饰符（如public：最低访问权限，即为所有类或组件都可以访问它修饰的量）
    默认是private
    private ：私有的， 只能在类的内部访问。
    如果要在类中访问其他类中的成员，需要在类中用public进行修饰
    如：public string _name;  //这样就可以在其他类中访问_name了;
2） 调用输出时要用this修饰,代表使用当前类的对象；
    例如:
    public string _name;
    public string _age;
    public string _gender;
    Console.Write("{0}-----{1}-----{2}",this._name,this._age,this._gender);
    类不占用内存，对象占用内存
3）seald关键字
seald class thetclass
{
             //关键字sealed修饰符，可防止扩充类重写此方法，称之为密封类    
}
2、属性： 属性的作用就是保护字段，对字段的取值和设值进行限定。
每个字段都应该配备一个属性。这样_name就可以 可读可写了               //在继承中也可以写出如下 效果一样
语法：public string Name    //字段的属性                             // public string Name
    {                                                                //{
        get{return _name;}  //取值作用  返回输出。     只读          //        get;
        set{_name = value;} //赋值作用，给_name赋值    只写          //        set;
    }                                                                //}
当字段没有使用public修饰的时候可以使用属性Name进行访问_name。        
 
public string Gender
get{return _name;}
set{_name = value;}
在属性中可以对字段的值进行保护（通过判断），防止输入内容冲突
例如：
    public int age //年龄是从外部输入的数据，所以从set得到。
    {
        get{return _gender;}              //如果在get中判断保护，则是对字段进行判断。
        set{
            if(value > 100 && value < 0)  //对输入 value的值 进行判断保护
            {
                value = 0;
            }
            _age = value;
        }
    }

3、三种属性
既有get方法也有set方法的属性我们称之为可读可写属性
只有get方法没有set方法我们称之为只读属性
只有set方法没有get方法我们称之为只写属性

4、构造函数
主要作用就是对 对象进行初始化。
构造函数其实就是一个函数，只不过是一个特殊的函数。
语法：
public 构造函数名()
{
    代码;
}
1、 没有返回值，连void也不能写。
2、 构造函数的名称必须跟类名一致。

调用构造函数
new的作用：
1)、在内存的堆中开辟空间
2)、在开辟的堆空间中创建对象
3)、 调用对象的构造函数

5、数据类型：
值类型:int, char, bool,decimal,enum   object[]类型 是所有类型的基类，意思就是可以转换为所有的类型
引用类型：string,数组，自定义类
堆、栈、静态存储区域

值类型：存在栈中
引用类型：存在堆中

6、静态和非静态
静态成员需要被static修饰
非静态不需要
public static string a();  // 静态方法
public string b();         //非静态方法
1） 非静态类中可以出现非静态成员。
2） 在非静态函数中，可以访问非静态和静态成员
3） 在静态方法中，只能访问静态方法，不能访问非静态方法
4） 在静态类中只允许出现静态成员

7、在调用时，静态和非静态的区别：
1） 非静态：在调用实例成员的时候，需要使用对象去调用       
    例如：
        Person p = new Person(); //需要先创建一个对象
        p.M1();
2） 静态：在调用静态成员的时候，必须使用 类名.静态成员名
 例如：
 Console.WriteLine();           //不需要创建对象，直接“.”出来就行
3） 静态类中部允许创建对象的
4） 静态类的优缺点： 静态类资源能够共享。但是非常占用空间，
   只有当所有程序都结束运行后，内存才会释放。所以静态类应该少写。
8、GC：Gargbage Collection      //垃圾回收
当我们程序结束之后，GC会扫描整个内存，发现，如果有的空间没有被指向，
则马上把这块空间销毁。

9、在一个项目中引用另一个项目的类
1）、 添加要引用的类所在的项目。
2）、 引用命名空间

10、访问修饰符
public :公开的，公共的
private:私有的，只能在类的内部访问，出了这个类之后，就访问不到了。
private double b;
能够修饰类的访问修饰符只有两个：
1）、 public
2）、 internal：表示只能在当前程序集的内部进行访问，出了这个程序集就访问不到啦。
对于咱们而言，现阶段就将程序集理解为当前项目。

11、字符串
由于字符串的不可变性，当我们进行字符串的赋值、转换等操作的时候，会产生大量的内存垃圾。
当需要对字符串进行大量的操作时，推荐使用StringBuilder
StringBuilder sw = new StreamWriter;

sw.****();  //这样建立

字符串是只读变量，无法被更改。所以，需要将string类型的字符串转换成char类型的字符，
更改后再转换回string；
例如：
    string str = "asdfgh";
    char[] st = str.ToCharArray();  //string转为char类型数组。char[] sr = str.ToCharWrray();
    st[1] = 'b';
    str = new string(st);           //char类型数组转char类型  str =new string（str）；
    Console.WriteLine(str);
    Console.ReadLine();
字符串的一些方法：
例如：
string str = Console.ReadLine();
1） str = str.length       // 输入字符的长 n度

2） str = str.ToUpper();  //将字符字母转成大写模式

3） str = str.ToLower();  //将字符字母转成小写模式

4） Equals("要比较的字符串",StringComparison.OrdinalIgnoreCase);  //比较字符串，忽略大小写。不分输入的大小写

5） Split(new char[]{'要分割的字符串'},StringSplitOptions.RemoveEmptyEntries); //分割字符串，返回一个字符串类型的数组
将不需要的字符串从字符中分割出去
例如：
string str = "55256+++++!@#$%^&*"
将除了数字以外的都分割出去
str.Split(new char[]{'+++++!@#$%^&*'},StringSplitOption.RemoveEmptyEntries);
输出的结果：str 只剩下“55256”了
str = str Replace("旧的字符串","新的字符串");   //字符串替换方法
6） Substring(int startlndex,int length);       //截取字符串 取从位置startlndex 器长度为length的字符
                                                //如果长度不足length 则会报错
7） bool Contains(string value);                //判断字符串中是否含有某个字符  bool类型
例如： string a = "asdf";
if(a.Contains("d"))
{
    Console.ReadLine("字符串中包含b");    
}
else
{
    Console.ReadLine("字符串中不包含b");        
}

8） bool StartsWith(sting value);              //判断字符串是不是以某个字符开始的
    bool EndWith(string value);                //判断字符串是不是以某个字符结尾的
9） int IndexOf(string valu ,int number);      //查找某个字符在字符串中第一个出现的位置
例如：                                         //number:用来设置索引的起始位置，默认为0（即为不写number的值）
string name = "天王盖地虎，小鸡炖蘑菇";
int names =  name.IndexOf("王");               // 结果：names的值就为2

   int LastxOf(string valu ,int number);     // 最后出现的位置

10） Trim();      //割去字符串中所有的空格字符
     TtimStart(); //割去字符串中从开始到有字符的空格字符
     TtimEnd();   //割去字符串中从结尾处的空格字符串

 

12、继承
我们在写类的过程当中，会发现，在多个类当中会存在一些相同的属性和方法。
为了解决这种代码冗余，于是乎，我们使用继承来解决这个问题。

我们把一些类当中所共同具有的属性和方法单独的拿出来封装成一个父类。
然后让其他类去继承这个父类。

 

如果一个类继承了另一个类，我们管这个类称之为子类，管被继承的那个类称之为父类。
或者 管这类称之为派生类，管被继承的那个类称之为基类。

语法：
:要继承的类
例如：

public class Person    // 人 类         //父类
                                        //子类
public calss Student  //学生 类

当Student；类要继承Person类时，如下     //前提： Person中有Student类需要的方法
public class Student:Person             //这样Person中的方法就可以在Student中调用

子类继承父类的方法和属性
子类不能继承父类的私有字段： private 定义的字段
子类并没有继承父类的构造函数，而是会默认的调用父类那个无参数的构造函数，
当你在父类中写了一个有参数的构造函数之后，那个默认的无参数的构造函数就被干掉了，
此时子类就调不到那个无参数的构造函数了。
解决办法：
1)、在父类中重新写一个无参数的构造函数。                        例如:public Person  {     }
2)、让子类去显示的调用父类有参数的构造函数。使用关键字:base()

例如：
public string Main()
{
    Student t = new Student("大明"，23，119)；    
}
//父类
public class Person
{
    public string Name
    {
        get;
        set;    
        
    public string Age
    {
        get;
        set;
    }
    public Person(string name,string age)   //父类构造函数  包含参数name和age
    {
        this.Name = name;
        this.Age = age;        
    }    
}
//子类 （派生类）
public class Stduent:Person                 //继承Person类
{
    public string ID
    {
        get;
        set;
    }    
    public Student(string name,string age ,string id)        //子类调用父类构造函数
    : base(name,age)  
    {                                                        //
        this.ID = id;        
    }    
}
继承特性:
单根性：一个子类只能有一个父类。即为一个儿子只能有一个爹
继承具有传递性：通俗的讲为：爷类、父类、子类。
父类可以继承爷类，父类可以继承子类。

在类中调用自己的构造函数方法：
使用this关键字
例如：
public string Main(string args)
{
    Student t = new Student("大明"，23，119)；    
}
public class Student
{
    public string Name
    {
        get;
        set;    
    }    
    public char Age
    {
        get;
        set;
    }
    public int ID
    {
        get;
        set;
    }
    public Person(string name,char age,int id)   //
    {
        this.Name = name;
        this.Age = age;
        this.ID = id;
    }    
    public Person(string name,char age):this(name,age,0)  //使用this关键字调用自己的构造函数，
    {
        //函数中就不用再写this.Age = age;
    }    
    public Person(char age,int id):this(null,age,id)     //构造函数中没有name参数，用null
    {
        //函数中就不用再写this.Age = age;                    
    }
    
}
13、里氏转换
1） 子类对象可以赋值给父类
2） 如果这个父类中装的是子类的对象，那么可以将这个父类强转为对应的子类对象
判断是否能够转换的 关键字
is:类型转换，如果转换成功，返回一个true，否则返回一个false。
as:类型转换，如果转换成功，则返回对应的对象，如果转换失败，返回一个null。

[1]as:
Person p = new Student();   //Student已经继承了Person
Teacher t = p as Teacher;  //返回t的值如果成功t的值为对应的值，否则返回null =0

[2]is:
 if (p is Student)         //判断是否能转换
{
    Student s = (Student)p;
    Console.WriteLine("成功");
}
else
{
    Console.WriteLine("不能转换!!!");
}
Console.ReadKey();

14、file类文件

1） bool t = File.Exists(@"C:\Users\hu\Desktop\C#学习笔记.txt");              //判断指定的文件是否存在，返回一个bool类型的数据

2） File.Create(@"C:\Users\hu\Desktop\new.txt");                              //创建一个文件

3） File.Delete(@"C:\Users\hu\Desktop\new.txt");                              //删除指定的文件，文件被彻底删除！！也不存在回收站中！！！

4） File.Copy(@"C:\Users\hu\Desktop\new.txt", @"C:\Users\hu\Desktop\1.txt");  //复制一个文件，第一个参数为源文件，后面的为新文件
                                                                          
5） File.Move(@"C:\Users\hu\Desktop\new.txt", @"F:\new.txt");                //剪切一个文件，第一个参数为源文件目录，后面的为剪切到的目录

15、ArrayList数组集合

  ArrayList list = new ArrayList();             //新建集合数组，长度可以改变，不固定。可任意改变
 
  list.Add(1);                                  //添加单个元素  1为第一个元素
   
  list.AddRange(new int[] { 1, 2, 3, 4, 6, 5 });//添加多个数组元素   

  list.Clear();                                 //删除所有元素
 
  list.Remove(list[0]);                         //删除单个元素 或者是list.Remove(“123”);
   
  list.RemoveRange(1, 5);                       //删除指定数量的元素 第一个参数是删除的起始位置，第二个是删除往后元素的个数

  list.Insert(1, "插入的元素");                 //在指定的位置插入元素  1为插入的位置，
 
  list.Sort();                                  //将list数组按从小到大排列出来
    for (int t = 0; t < list.Count; t++)        //输出list中的所有元素                        
    {
        Console.WriteLine(list[t]);
    }

集合的两个属性
Count ：获取这个集合中实际包含的元素个数
Capcity ：获取这个集合可以包含的元素个数

16、Hashtable集合
用来实现某个类型的值代替另外一个类型的值。或者理解为键值对集合。某一个键，对应某一个集合

var推断类型
var可以通过变量的值来推断出来这个变量的类型。
例如：
{
    var n1 = 0.23;   
    var n2 = ture;
    Console.Write(n1,GetType());    // 获取n1的类型  结果：double
    Console.Write(n2,GetType());    // 获取n2的类型  结果：bool
}
实例:
static void Main(string[] args)
{
    Hashtable t = new Hashtable();  //创建一个Hashtable的对象     
    t.Add('a',100);                 //键a 对应集合数组元素100
    t.Add(5,"wangwu");            
    foreach (var item in t.Keys)    //类似于for循环结构  item 表示集合中元素的标识符   t.key：要访问集合或数组的名称
    {                               //循环中的每个类型    in 表示是在哪一个集合或数组里面 var:表示所有类型的元素
        Console.WriteLine("键 ：{0}  值 ：{1}",item,t[item]);
    }
    Console.ReadKey();
    
      //t[x]  表示键x对应的集合值
}
t.Clear();                         //删除所有集合
bool t.ContainsKey(object key);    //检测是否包含某个键 返回一个bool类型数据
t.Remove(x);                       //删除指定的x键
注意：一个键只能对一个集合的值
一个集合的值可以对应多个键值

17、编码和File类读取文件
/*读取3.txt中内容*/
string[] str = File.ReadAllLines(@"C:\Users\hu\Desktop\3.txt", Encoding.Default);
for (int i = 0; i < str.Length; i++)
{
    Console.WriteLine(str[i]);
}

string str = File.ReadAllText(@"C:\Users\hu\Desktop\3.txt", Encoding.UTF8); //指定打开文件的编码形式

byte[] buffer = File.ReadAllBytes(@"C:\Users\hu\Desktop\3.txt");            //获取文件并以字节数组输出

string str = System.Text.Encoding.UTF8.GetString(buffer);                   //把字节数组解码成我们认识的字符串
/*追加着向文件中写入数据,最后一个参数是编码形式*/
File.AppendAllText(@"C:\Users\hu\Desktop\3.txt", "我是新来的", Encoding.GetEncoding("UTF-8"));

18、文件操作
Directory.CreateDirectory(@"C:\a");                     //创建文件夹a

Directory.Delete(@"C:\a",true);                         //删除文件夹

Directory.Move(@"C:\a\b", @"C:\d");                     //剪切文件夹

Console.WriteLine(Path.GetFileName(s1));                //获得文件的名称

Console.WriteLine(Path.GetFileNameWithoutExtension(s1));//获得文件的名称但是不包含扩展名

Console.WriteLine(Path.GetExtension(s1));               //获得文件的扩展名

Console.WriteLine(Path.GetDirectoryName(s1));           //获得文件所在的文件夹的路径

Console.WriteLine(Path.GetFullPath(s1));                //获得文件的绝对路径

Console.WriteLine(Path.Combine(@"C:\a\","b.txt"));      //拼接路径
Console.WriteLine(Path.ChangeExtension(@"C:\Users\SpringRain\Desktop\code.txt",".jpg"));

19、使用FileStream来读取一个文件
第一步：首先创建一个FileStream的对象
第一个参数表示要操作文件的路径
第二个参数表示对文件做一个怎样的操作
第三个参数表示对文件中的数据进行怎样的操作
FileStream fsRead = new FileStream(@"C:\Users\SpringRain\Desktop\抽象类特点.txt", FileMode.OpenOrCreate, FileAccess.Read);
使用StreamReader来读取数据
using (StreamReader sr = new StreamReader(@"C:\Users\SpringRain\Desktop\抽象类特点.txt",Encoding.Default))

//使用StreamWriter来写入数据
using (StreamWriter sw = new StreamWriter(@"C:\Users\SpringRain\Desktop\ooo.txt",true)) //文件流

20、装箱和拆箱
装箱：将值类型转换为引用类型  
拆箱：将引用类型转换为值类型
值类型:int double decimal enum struct bool char
引用类型：数组 集合 自定义类 string object  
例如：
int n = 10;
object o = n;//值类型---》引用类型  装箱

double nn = (double)o;//引用类型---》值类型 拆箱

21、多态
多态：一个对象能够表现出多种的状态
虚方法、抽象类、接口
虚方法：首先将父类的方法标记为虚方法，标记为虚方法就意味着这个方法可以被子类重写。  

抽象类：public abstract class chouxiang
{
    //抽象类不能创建对象  不能new一个对象
    
}
22、序列化和反序列化
序列化：就是将对象转换为二进制
反序列化：就是将二进制转换为对象
作用：传输数据     服务器将文件转化为二进制发送出去，客户端接收数据将二进制转化为文件
例如
BinaryFormatter bf = new BinaryFormatter();   //将对象转化为二进制，即为序列化的二进制
bf.Serialize(fsWrite, p);

BinaryFormatter bf = new BinaryFormatter();   //反序列化 将二进制转化为文件
per = (Person)bf.Deserialize(fsRead);

23、Guid GUID:表示全局唯一标识符

Console.WriteLine(Guid.NewGuid().ToString);

结果输出的是一个全世界独一无二的编号

24、接口
[public] interface 接口名称
{
    接口成员;
}

1） 接口是一种规范。也表示一种能力，继承了接口就是继承了这种能力。
2） 只要一个类继承了一个接口，这个类就必须实现这个接口中所有的成员
3） 为了多态。接口不能被实例化。也就是说，接口不能new(不能创建对象)
4） 接口中的成员不能加“访问修饰符”，接口中的成员访问修饰符为public,不能修改。
5） 一个子类只能继承一个父类，但是一个子类可以继承多个接口，接口可以继承接口
6） 接口中只能有方法、属性、索引器、事件，不能有“字段”和构造函数。
7） 接口与接口之间可以继承，并且可以多继承。
8） 接口并不能去继承一个类，而类可以继承接口 （接口只能继承于接口，而类既可以继承接口，也可以继承类）
9） 实现接口的子类必须实现该接口的全部成员。
例如：
 public class Student : Person,M4  //继承父类 和一个接口
{
    //string _name;   不能有字段，因为接口是功能，所以不能有数据等
    public void Test1()
    {
        throw new NotImplementedException();
    }

    public void Test2()
    {
        throw new NotImplementedException();
    }

    public void Test3()
    {
        throw new NotImplementedException();
    }
}

接口理解：
//接口里面封装功能代码，需要外部传进来各种参数或数据，然后实现其相应功能的过程
//接口使用：只需要把数据传进接口里，就可以实现功能

接口和类理解：
接口类似于.h文件 类是.c文件 c文件中的函数功能，把函数名放在.h文件中，
其他文件引用.h文件  使用里面的函数

25、值传递和引用传递
值传递：值类型在赋值的时候 传递的是值得本身
引用类型：引用类型在赋值的时候 传递的是引用 (地址)

26、ToSring: 所有类型的数据都能够调用ToString
类调用ToString 返回的是命名空间
 
27、 partial sraled  修饰类的关键字
1) sraled 表示密封类，一旦被此关键字修饰，将表示这个类不能被继承 但是可以继承其他类
   例如： public sraled class Person {}
2) partial:部分类
public partial class Person
{}
public partial class Person  //两个类 类名一样  加上关键字 partial 后 不会因类重名而报错。这两个类表示一个类
{}                

          /*<------------------------第三篇-------------------------->*/

              /*<------------窗体应用程序-------------->*/

1、控件的一些属性
1）
 属性1：Anchor 设置button窗口拉伸度
 属性2：Backgroundmage 导入背景图片
 属性3：Backgroundmagelayout 背景图片显示尺寸
 属性3：ContexMenuStrip 设置控件右击显示的菜单  类似桌面右击 是显示 刷新 新建等
       使用：在工具箱菜单和工具栏汇中 选择ContexMenuStrip，填写属性，回车键填写下一个
       然后点击属性栏中的ContexMenuStrip，选择ContexMenuStrip，启用右击显示菜单
 属性4：Cursor 指正移过该控件时显示的光标
 属性5：Enabled 有ture 和false 表示该控件是否启用 （变灰不可用）
 属性6：Dock：设置控件在窗口的位置
 属性7：Visble 设置该控件是隐藏还是现实（依然存在）
 属性8：PasswordChar 设置输入文本框中以什么形式显示（例如：输入密码，显示的都是***）
 属性9：WordWrap 设置文本框是否自动换行 ture false
2、操作控件属性
语法：控件的name.属性 = 属性选择；
例如：
一个button控件 name是btndog
btndog.Visble = false;  //隐藏空间btndog

string str = DateTime.Now.ToString();  //获取系统时间

3、多选，单选
CheckBox ： 多选框
RadioButton:单选框
容器：
GroupBox 组框 将单选框放在一个组框里可以实现在框里单选，框外不影响。

4、设置MDI窗体
点击窗体 IsMdiContainer 属性 ture false
工具箱里菜单和工具栏中的MenShtrip 菜单栏 就是一个文件最上面那一排菜单栏
在点击时间中建立子窗体
 Form2 fram2 = new Form2;  //创建一个子窗体对象
 fram2.MdoParent()= this;  //设定子窗体为此窗体的子窗体    
 fram2.Show();             //将子窗体显示出来

 LayoutMdi(MdiLayout.TileVertical);   //子窗体纵向排列
 LayoutMdi(MdiLayout.TileHorizontal); //横向排列

5、控件：PictureBox
属性1、image 添加图片
属性2、SizeMode 设置图片布局
控件里显示单个图片：
pictureBox1.Image = Image.FromFile(@"C:\Users\SpringRain\Desktop\1.jpg");
获取文件夹里所有文件的全路径：
string path =  DirECTORY.GetFiles(@"C:\Users\hu\Desktop\C#学习")；//数组path中存储了文件内的全部文件

6、ComboBox控件，多选择下拉框
在编辑项里添加选项
comboBox1.Items.Add("添加选项");
comboBox1.SelectedIndex = 1;  //下拉框中的第1个被选中放在框里
TextChange()属性：当文本框数据改变时要发生的事件

 

7、多线程
进程：每一个应用程序都是一个进程，而进程又是又多个线程组成
进程类
    Process.GetProcesses();     //获取计算机中所有进程，返回一个数组类型的数据
    Process.start("命令");      //启动新的进程，用命令行启动
    Thread th= new Thread(Test);//开启一个新的线程 执行teat。 teat是一个方法，这里作为一个参数传入另一个方法（即为委托）
    th.IsBackground = ture;     //设置为后台线程
    th.start();                 //表示告诉CPU线程已经准备好了，可以随时启用。 这里不是表示启动线程，而是表示可以执行了，
                                //决定权在于CPU ，如何CPU在执行其他进程，则不会执行此线程。
    th.Abort();                 //关闭线程，线程一旦被关闭后，就不能再被打开了
    Thread.Sleep(timeOut);      将线程停止一段时间 timeOut为停止时间长度，单位ms
在程序中不允许出现跨线程的访问，即为：新开一个线程，在其中不允许出现主线程中的定义的函数或变量，
如果在主线程中加上一下程序，取消对跨线程的访问，即可解决跨线程访问。
    Control.CheckForIllegalCrossThreadClalls=false;//取消对跨线程访问\检查。
    
    Thread th = new Thread(Listen); //Listen为线程中执行的方法名
    th.IsBackground = true;         //设置为后台运行
    th.Start(socketWstch);          //socketWatch为方法的参数
8、socket网络编程
Server搭建

    //创建一个服务器与客户端通信的socket
    socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream,ProtocolType.Tcp);
    //                                 设置使用IPv4              使用流式TCP
    //获取连接服务器的IP地址
     IPAddress ip = IPAddress.Parse(txtIP.Text);
    //获取连接服务器的端口号
    IPEndPoint pint = new IPEndPoint(ip,Convert.ToInt32(txtTag.Text));
    //让负责监听的Socket绑定IP地址跟端口号
    socketWatch.Bind(point);
    //设置监听队列
    socketWatch.Listen(10);
    //创建跟客户端通信的Socket
    Socket socketSend = socketWatch.Accept();
    //获取远程连接来的客户端ip和端口号
    str = socketSend.RemoteEndPoint.ToString()
    
    
    /*建立线程执行接收客户端发送来的数据*/
    Thread th = new Thread(Listen); //Listen为线程中执行的方法名，方法中为接收数据和数据转换的程序
    th.IsBackground = true;         //设置为后台运行
    th.Start(socketWstch);          //socketWatch为方法的参数  socketWatch是socket类型的数据，
                                    //在方法中转换得到的例如 ：o为原始传入的参数
                                    //Socket socketWatch= o as Socket;
线程中执行程序：接收客户端发送过来的数据。
   //服务器开始接收客户端发来的数据
    byte[] buffer = new byte[1024 * 1024 * 2];
    //服务器接收的实际有效数字节数
    int r = socketSend.Receive(buffer);
    //将字节数组转换为字符串
    string str = System.Text.Encoding.UTF8.GetString(buffer, 0, r);

以上为创建一个服务器，和设置接收客户端程序
客户端开发类似

 

              /*<-------第一篇------->*/
                                                                     行数
1、命名空间 ------------------------------------------5
2、以.cs结尾的文件称之为类--------------------10
3、快捷键---------------------------------------------17
9、占位符---------------------------------------------24
11、转义字符-----------------------------------------28
12、自动类型转换或者隐式类型转换-----------40
14、Convert类型转换-------------------------------44
15、try—catch异常捕获----------------------------48
16、int.TryParse()-----------------------------------57
18、枚举类型-----------------------------------------67
19、结构体类型--------------------------------------85
20、数组的形式--------------------------------------100
21、冒泡排序法--------------------------------------104
22、方法or函数--------------------------------------128
23、out参数------------------------------------------148
24、ref参数-------------------------------------------168
25、方法的重载--------------------------------------194
26、params可变参数数组-------------------------200
27、方法的递归--------------------------------------216
28、输出窗口设置颜色-----------------------------217
29、字段和变量区别--------------------------------218

                /*<-----第二篇----->*/
                     /*面向对象*/
1、类的语法------------------------------------------226
2、属性------------------------------------------------259
3、三种属性------------------------------------------285
4、构造函数------------------------------------------290
5、数据类型------------------------------------------307
6、静态和非静态------------------------------------315
7、在调用时，静态和非静态的区别------------325
8、垃圾回收------------------------------------------336
9、在一个项目中引用另一个项目的类---------340
10、访问修饰符-------------------------------------344
11、字符串-------------------------------------------354
12、继承----------------------------------------------416
13、里氏转换----------------------------------------531
14、file类文件---------------------------------------554
15、ArrayList数组集合----------------------------566
16、Hashtable集合--------------------------------593
17、编码和File类读取文件-----------------------625
18、文件操作----------------------------------------641
19、使用FileStream来读取一个文件----------661
20、装箱和拆箱------------------------------------674
21、多态---------------------------------------------685
22、序列化和反序列化---------------------------690
23、Guid---------------------------------------------701
24、接口---------------------------------------------708
25、值传递和引用传递---------------------------761
 /*<--------------------第三篇------------------->*/
 /*<------------窗体应用程序-------------->*/
1、控件的一些属性--------------------------------786
2、操作控件属性-----------------------------------796
3、多选、单选--------------------------------------840
4、设置MDI窗体------------------------------------810
5、控件：PictureBox------------------------------821
6、ComboBox控件，多选择下拉框------------829
7、ComboBox控件，多选择下拉框------------837
8、socket网络编程---------------------------------855