C#

1 .NET框架

支持传统的window应用系统和web应用系统开发，还可以支持跨平台移动开发和云开发。

1.1 net框架结构

.net框架体系结构由一下四个主要部分组成：

1.公共语言进行时（clr）:公共语言进行时时.net框架应用程序的执行引擎。clr负责内存分配，启动和删除线程和进程，实施安全性策略，同时满足当前组件对其他组件的需要。

2.基础类库：.net框架为开发人员提供的一个统一的，面向对象的，层次化的，可扩展的类库集（API）。在.NET框架上各种语言都支持使用这个类库。

3.ADO.NET数据访问：它是一组用于和数据源交互的面向对象的类库。实现了ADO无法实现的三重需求。

4.活动服务器页面（c#）：c#提供了web应用模型，该模型由一组控件和一个基本结构组成。C#使WEB应用程序的构建变得十分容易。

1.2 .net框架的优点

统一的程序设计模式：提供了跨语言的面向对象的同意程序设计模式，这种模式可以用于读写文件，数据库访问。

跨平台应用：应用程序可以运行在任意被clr支持的系统中。

多语言集成：允许多语言进行集成。可以在一种语言中使用另一种语言的类。

自动资源管理：crl会对应用程序所使用的资源进行自动检测，释放不需要的资源。

轻松部署：轻松生成安装文件。

1.3 .net的术语

CLR：公共语言运行时，处理加载程序，运行程序的代码，以及在提供支持服务的代码。

托管代码：.net中的所有代码都是托管代码，它们都是以运行库为目的的。

IL：中间语言，编译器把预先写好的代码编译为中间语言，il可以快速地编译为内部机器代码。

.net基类:是一个扩展的类库。它包含预先写好的代码，执行windows上的各种任务。

CLS:公共语言进行时，这是确保语言在任何语言中都访问的最小标准的集合，所有用于.net的编译器都应支持CLS.

JIT：just-in-time编译，用于表达执行编译过程的最后阶段，即从中间语言转换为内部机器码。

1.4 应用类型

1.windows窗体应用

2.控制台应用程序 //DOS环境下的命令行

3.ASP.NET WEB应用程序

4.类库 //类库通用

C#基础

1 主体框架

命名空间 > 类 > 方法

// 单行注释

/* */ 多行注释

Console.WriteLine("");向控制台输出（默认换行）

Console.Write("");向控制台输出（默认不换行）

Main()过程使程序的主过程。当程序执行时会从Main()开始。

using System;   //引入包
namespace  项目名{ 				//命名空间
    class Progrram {              //类名
    	static void Main(){		  //主函数（主方法）
            Console.WriteLine("");
            Console.Write("");
        }
    }
}

2 数据类型

C#是一种强类型语言。

C#的数据类型包括两类：引用类型和值类型

值类型：整型，浮点型，小数型，布尔型，结构，枚举，字符型。

引用类型：类类型，接口类型，委托类型，数组类型。

引用类型默认值为：NULL

整型

直接包含；short / ushort (凡是s开头即为有符号，u开头即为无符号。)

​ sbyte / byte

​ int / uint

   long  /  ulong

字符型

char:一个char类型包含2个字节(c中为1个),有三种定义方式。

char类型和ushort类型可以无损失转换。

byte存储占一个字节。

char a = 'A'
char a = '\xoo64' //十六进制
char a = '\u0065' //Unicode编码

浮点型

浮点型包括：double ，float

float定义时需要在赋值后加F/f。

double a = 1.111;
float b = 1.11f // float定义时需要在赋值后加F/f。

小数型

decimal能存储的小数位数非常多，在定义初始化的时候，需要在赋值之后加m.

//在定义初始化的时候，需要在赋值之后加m
decimal i = 1.222m

转义字符

c#中有一些字符不能直接输出如：单引号和双引号，空格，反斜杠，可以采取转义字符的形式进行显示。

3 变量和常量

c#允许用变量和常量存储数据。

变量

变量时程序运行中临时来存储数据的内存空间，在声明时需要指明其名称和数据类型。

变量名必须以字母开头变量名必须只包含字母，_下划线，数字，不能和c#中的关键字同名，不能和C#中的函数库名相同。

//声明之后再初始化：
float a ;//变量类型  变量名 ；

a = 1.1f	; //变量名 = 数值；
    
//声明的同时初始化
float a= 1.1 ;

常量

在程序运行过程中不会发生改变的量称为常量，使用const关键字来定义。只要定义就必须初始化。

常量和变量最大的区别就是：变量的值可以不断该改变，常量的值一但定义就不能改变，如果给一个已经定义的常量赋值，就会发生错误。

//使用const关键字来定义只要定义就必须初始化。
//const 常量类型 常量名 = 初始化值；
const float a = 1.2f;

4 运算符

运算符是一个符号，用来操作一个或者多个表达式。

4.1 算数运算符

4.2 比较运算符

4.3 逻辑运算符

5 流程控制语句

通过使用各种流程控制语句来控制语句的执行循环。

5.1 分支语句

分支语句分为if ,swich语句

if语句

一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。

static void Main(string[] args)
        {
          if(判断语句){    
          语句；
          }
          else if(判断语句){
          语句；  
          }    
          else{
          语句；    
          }    	
        }

switch语句

一个 switch 语句允许测试一个变量等于多个值时的情况。每个值称为一个 case，且被测试的变量会对每个 switch case 进行检查。

switch (变量)
            {
                case 'A':
                    语句；
                    break;
                case 'B':
                case 'C':
                    语句；
                    break;
                case 'D':
                    语句；
                    break;
                case 'F':
                   语句；
                    break;
                default:
                    语句；
                    break;
            }

5.2 循环语句

有的时候，可能需要多次执行同一块代码。一般情况下，语句是顺序执行的：函数中的第一个语句先执行，接着是第二个语句，依此类推。

while循环

只要给定的条件为真，C# 中的 while 循环语句会重复执行一个目标语句。

while (判断语句)
      {
	语句
       }

dowhile循环

do…while 循环是在循环的尾部检查它的条件。

do…while 循环与 while 循环类似，但是 do…while 循环会确保至少执行一次循环。

  do
      {
         语句；     
       } while (a < 20);

for循环

一个 for 循环是一个允许您编写一个执行特定次数的循环的重复控制结构。

for ( init; condition; increment )
{
   语句;
}

6 数组

数组和是具有相同数据类型的数据集合。数组中的每个数据称为数组元素，可以使用元素的位置索引号来访问数组元素。

6.1 数组声明

数组是引用类型，所以在数组声明后，必须为数组分配内存，为数组初始化。

//第一种初始化方式：
int[] arrayName;
arrayName = new int[4];

//第二种初始化方式：
int[] arrayName = new int[4];

//第三种初始化方式：
int[] arrayName = new int[4] {1,1,1,1}

//第四种初始化方式；
int[] arrayName = new int[] {1,1,1,1}

//第五种初始化方式：
int[] arrayName = {1,1,1,1}

6.2 二维数组

维数为逗号数+1

[,]只能声明等长的二维数组

//数据类型[,] 数组名 = new 数据类型[,];
int[,] arrayName = new int[3,2];

int[,] arrayName = new int[3,2] {{,},{,},{,}}

[][]的形式则可以声明等长二维数组，也可以声明不等长二维数组。

int[][] arrayName = new int[3];
int[0] arrayName = new int[2];
int[1] arrayName = new int[3];

7 类

其中含有构造函数和析造函数。

析造函数不能加修饰符。

1.类中成员:

属性，方法(函数)，事件，变量(字段)，常量；

2.类的访问修饰符:

internal(缺省):当前程序集；public(公共):全部；

类成员修饰符：

public(公共):全部；

private(私有的):当前类中；

protected(受保护的):当前类及子类中；

internal(当前程序集):当前程序集；

protected internal: protected 与 internal的并集；

构建类元素顺序：

添加类 -> 添加属性 -> 添加构造函数 -> 添加方法

初始化顺序：

静态变量 -> 静态构造方法 -> 变量 -> 构造方法

子类静态变量 -> 子类静态构造方法 -> 父类静态变量 -> 父类静态构造方法 -> 父类变量 -> 父类构造方法 ->子类变量 -> 子类构造方法

static 静态类与静态变量：

1.静态类和静态成员，无需创建类的实例，也不能创造实例，无论对象怎样改变，数据和函数不会发生变化。

2.静态类中只能访问静态变量。

3.类和静态类可以有静态构造函数，不能有普通构造函数，在程序开始与实例化之间的某个时刻调用，只调用一次。

4.类的实例成员函数可以访问类的实例成员，去不能通过类的实例来引用静态成员。却可以通过类型名引用静态成员。

5.静态类是密封的，不可被继承的。

私有构造函数阻止实例化。

8 对象

c#中使用New关键字来创建一个类的对象，即对类的实例化。

声明却没有给对象名赋值，这个对象为null；

实例化方法1：
    类名 对象名 = new 构造方法 ;
实例化方法2：
    类名 对象名；
    对象名 = new 构造方法；

9 继承

通过继承，可以直接基于现有的类创建新类。现有的类被称为基类，也叫父类，超类。新创建的类被称为派生类，子类。派生类继承基类的方法属性事件。

构造函数和析构函数不能被继承。

一个子类只能有一个父类。

派生类是对基类的扩展，只能添加不能减少。如果派生类新成员的名称与父类相同，则被覆盖。可以继承多个接口。

object类为所有类的基类。

class 子类名:父类名{
    新成员；
}

this关键字

this关键字引用当前正在执行的类或者结构的特定实例，可以用来访问类的成员。

指代的是当前实现该类的对象名。

public 类名{
    public 方法名(){
        int a = 1;
        Console.WriteLine("[0]",this.a)
    }
}
public 类名2{
    类名 对象名 = new 构造方法();
    
}

base关键字

base通常用于访问被派生类重写或者隐藏的基类成员，可以访问公共成员和受保护成员，私有成员不可访问。

public 父类名{
    public 方法名(){
        xxxx
    }
}
public 子类名:父类名{
    public 方法名(){
        ssss
        base.方法名（）;     //调用父类的方法，不会使用子类的同名方法。
    }
}

10 多态

10.1 重载

重载是指同一个类中存在名称相同但是参数列表不同的多个构造方法。

class 类名{
    public 类名(形参1){
        
    }
    public 类名(形参2){
        
    }    
}

10.2 重写

重写是指在派生类中的具有与基类中名称相同的方法或者属性。要在派生类中使用与基类中名称相同但目的不同的属性或者方法。

public 父类名{
    public 方法名(){
        
    }
}
public 子类名:父类名{
    public 方法名(){
        
    }
}

virtual 关键字(虚方法)

重写的属性和方法使用关键字virtual定义，声明这个方法或者属性可以被重写。

public 父类名{
    public virtual 类型 方法名(){    //声明这个方法可以在派生类中被重写
        
    }
}
public 子类名:父类名{
    public override 方法名(){      //声明这个方法是重写自父类的方法。
        
    }
}

override 关键字

声明在方法之前，表明此方法是重写自父类的方法。

public 父类名{
    public virtual 类型 方法名(){    //声明这个方法可以在派生类中被重写
        
    }
}
public 子类名:父类名{
    public override 方法名(){      //声明这个方法是重写自父类的方法。
        
    }
}

sealed 关键字

重写的方法使用关键字sealed定义，声明这个方法或者属性是密封的，不允许被重写。

类用关键字sealed定义，声明这个类是密封的，表示此类不能被继承。

public 父类名{
    public sealed 类型 方法名(){    //声明这个方法不能在派生类中被重写
        
    }
}
public 子类名:父类名{
    public override 方法名(){      //声明这个方法是重写自父类的方法，但是会报错，sealed不允许重写。        
    }
}

10.3 abstract(静态)

abstract关键字可以修饰类和方法。

修饰类，证明此类是抽象类，抽象类中可以有抽象方法，却不一定有抽象方法，抽象类可以被继承，不允许被实例化，因为含有抽象方法。继抽象类的类必须实现全部抽象方法后才能实例化，否则必须声明为抽象类。

修饰方法，证明此方法是抽象方法，有抽象方法的类一定是抽象类，不允许被实例化，只允许有函数名，不允许有函数体。

public 父类名{
    public abstract 类型 方法名()   //声明这个方法是抽象方法，不能有函数体。

    public abstract 类型 方法名()  //声明这个方法是抽象方法，不能有函数体。

    public 类型 方法名(){    //这是一个正常的方法。
        
    }
}

10.4 interface(接口)

一个类只能继承一个父类，一个接口却可继承多个接口。

不能直接实例化接口。

接口成员的默认访问类型都是public且只能是public。

interface 接口名{
    接口内容
}

重写

}

}
public 子类名:父类名{
public override 方法名(){ //声明这个方法是重写自父类的方法，但是会报错，sealed不允许重写。
}
}

#### 10.3 abstract(静态)

> abstract关键字可以修饰类和方法。
>
> 修饰类，证明此类是抽象类，抽象类中可以有抽象方法，却不一定有抽象方法，抽象类可以被继承，不允许被实例化，因为含有抽象方法。继抽象类的类必须实现全部抽象方法后才能实例化，否则必须声明为抽象类。
>
> 修饰方法，证明此方法是抽象方法，有抽象方法的类一定是抽象类，不允许被实例化，只允许有函数名，不允许有函数体。

```c#
public 父类名{
    public abstract 类型 方法名()   //声明这个方法是抽象方法，不能有函数体。

    public abstract 类型 方法名()  //声明这个方法是抽象方法，不能有函数体。

    public 类型 方法名(){    //这是一个正常的方法。
        
    }
}

10.4 interface(接口)

一个类只能继承一个父类，一个接口却可继承多个接口。

不能直接实例化接口。

接口成员的默认访问类型都是public且只能是public。

interface 接口名{
    接口内容
}