C# 编程语法基础总结

基本数据类型

值类型的数据存储在内存的堆栈中，可以提供快速访问。
引用类型有如下特征：
1.必须在托管堆中为引用类型变量分配内存；
2.必须使用 $new$ 关键字来创建引用类型变量；
3.在托管堆中分配的每个对象都有与之相关联的附加成员，必须初始化这些成员；
4.多个引用类型变量可以引用同一对象，此时对一个变量的操作会影响其他变量；
5.引用类型变量是由垃圾回收机制来管理的；
6.引用类型被赋值前的值都是 $null$

整型：有符号数可以表示负数，无符号数仅能表示正数，$C$$\#$ 语言中默认的整型是 $int$ 类型。

类型	说明	范围	类型指定符
$sbyte$	8 位有符号整数，占用 1 个字节	$-2^7〜2^7-1$
$short$	16 位有符号整数，占用 2 个字节	$-2^{15}〜2^{15}-1$
$int$	32 位有符号整数，占用 4 个字节	$-2^{31}〜2^{31}-1$
$long$	64 位有符号整数，占用 8 个字节	$-2^{63}〜2^{63}-1$	$L$
$byte$	8 位无符号整数，占用 1 个字节	$0〜2^8-1$
$ushort$	16 位无符号整数，占用 2 个字节	$0〜2^{16}-1$
$uint$	32 位无符号整数，占用 4 个字节	$0〜2^{32}-1$	$U$
$ulong$	64 位无符号整数，占用8个字节	$0〜2^{64}-1$	$UL$

浮点数类型与十进制类型

类型	说明	范围	类型指定符
$float$	单精度浮点型，占用 4 个字节，最多保留 7 位小数	1.5 $\times$ $10^{-45}$~3.4 $\times$ $10^{38}$	$F$
$double$	双精度浮点型，占用8个字节，最多保留16位小数	5.0 $\times$ $10^{-324}$ ~ 1.7 $\times$ $10^{308}$	D
$decimal$	占 16 个字节，最多保留 29 位小数	-1.0 $\times$ $10^{-28}$ ~ 7.9 $\times$ $10^{28}$	$M$ 或 $m$

$C\#$默认浮点类型是 $double$ 类型

字符型和字符串类型
字符型采用 $Unicode$ 字符集，只能存放一个字符，它占用两个字节，能存放一个汉字，存储单元存放对应 $Unicode$ 码值；用 $char$ 关键字表示，存放到 $char$ 类型的字符需要使用单引号括起来，例如 ‘a’、‘中’ 等。
字符串类型能存放多个字符，它是一个引用类型，在字符串类型中存放的字符数可以认为是没有限制的，因为其使用的内存大小不是固定的而是可变的。
使用 $string$ 关键字来存放字符串类型的数据。字符串类型的数据必须使用双引号括起来，例如 “abc”、“123” 等。

转义字符	字符	十六进制表示
\ ${}^{\prime }$	单引号	0x0027
\ $"$	双引号	0x0022
\ \	斜杠	0x005C
\ 0	空字符	0x0000
\ a	警报( 响铃 )	0x007
\ b	退格	0x0008
\ r	回车	0x000D
\ n	换行	0x000A
\ f	换页	0x000C
\ t	水平 Tab	0x009
\ v	垂直 Tab	0x000B

布尔类型
在 $C\#$ 语言中，布尔类型使用 $bool$ 来声明，它只有两个值，即 $true$ 和 $false$，且 $true$ 值不能被其他任何非 0 值所代替。

引用类型： 有字符串、类、接口、委托 和 数组等。

算术运算符

运算符	说明
+	对两个操作数做加法运算
-	对两个操作数做减法运算
*	对两个操作数做乘法运算
/	对两个操作数做除法运算
%	对两个操作数做取余运算

逻辑运算符

运算符	含义	说明
&&	逻辑与	如果运算符两边都为 True，则整个表达式为 True,否则为 False;如果左边操作数为 False，则不对右边表达式进行计算，相当于“且”的含义
||	逻辑或	如果运算符两边有一个或两个为 True，整个表达式为 True，否则为 False;如果左边为 True,则不对右边表达式进行计算，相当于“或”的含义
!	逻辑非	表示和原来的逻辑相反的逻辑

使用逻辑运算符时需要注意逻辑运算符两边的表达式返回的结果都必须是布尔型的。

比较运算符

运算符	说 明
==	表示两边表达式运算的结果相等，注意是两个等号
!=	表示两边表达式运算的结果不相等
>	表示左边表达式的值大于右边表达式的值
<	表示左边表达式的值小于右边表达式的值
>=	表示左边表达式的值大于等于右边表达式的值
<=	表示左边表达式的值小于等于右边表达式的值

使用比较运算符运算得到的结果是布尔型的值，因此经常将使用比较运算符的表达式用到逻辑运算符的运算中

位运算符

运算符	说 明
&	按位与。两个运算数都为 1，则整个表达式为 1，否则为 0;也可以对布尔型的值进行比较，相当于“与”运算，但不是短路运算
|	按位或。两个运算数都为 0，则整个表达式为 0，否则为 1;也可以对布尔型的值进行比较，相当于“或”运算，但不是短路运算
~	按位非。当被运算的值为 1 时，运算结果为 0;当被运算的值为 0 时，运算结果为 1。该操作符不能用于布尔型。对正整数取反，则在原来的数上加 1，然后取负数；对负整数取反，则在原来的数上加 1，然后取绝对值
^	按位异或。只有运算的两位不同结果才为 1，否则为 0
<<	左移。把运算符左边的操作数向左移动运算符右边指定的位数，右边因移动空出的部分 补 0
>>	有符号右移。把运算符左边的操作数向右移动运算符右边指定的位数。如果是正值，左侧因移动空出的部分补 0;如果是负值，左侧因移动空出的部分补 1
>>>	无符号右移。和 >> 的移动方式一样，只是不管正负，因移动空出的部分都补 0

三元运算符

布尔表达式 ? 表达式 1: 表达式 2  
在三元运算符中表达式 1 和表达式 2 的结果的数据类型要兼容。
布尔表达式：判断条件，它是一个结果为布尔型值的表达式。
表达式 1:如果布尔表达式的值为 True，该三元运算符得到的结果就是表达式 1 的运算结果。
表达式 2:如果布尔表达式的值为 False，该三元运算符得到的结果就是表达式 2 的运算结果。

赋值运算符

运算符	说 明
=	$x$ = $y$，等号右边的值给等号左边的变量，即把变量 $y$ 的值赋给变量 $x$
+=	$x$ += $y$，等同于 $x$ = $x$ + $y$
-=	$x$ -= $y$，等同于 $x$ = $x$ - $y$
*=	$x$ *= $y$，等同于 $x$ = $x$*$y$
/=	$x$ /= $y$，等同于 $x$ = $x$ / $y$
%=	$x$ %= $y$，等同于 $x$ = $x$ % $y$，表示求 $x$ 除以 $y$ 的余数
++	$x$++ 或 ++$x$，等同于 $x$ = $x$+1
- -	$x$- - 或 - -$x$，等同于 $x$ = $x$ - 1

改变运算符的运算顺序必须依靠括号。运算符的优先级如下表所示，表中显示的内容是按优先级从高到低排序的。

变量

只能由数字、字母、下划线组成，首字符必须是字母或下划线。变量名不能与 C# 
中的关键字相同，除非标识符用 @ 作为前缀。例如：int 是非法标识符，@int是
合法标识符。

 定义变量的同时赋值：数据类型  变量名 = 值;
 int a = 1, b = 2;
 
 先定义变量然后再赋值：
 数据类型  变量名;
 变量名 = 值;

常量

常量就是不能改变的量，用关键字 const 修饰，例如：const PI = 3.1415926;

隐式类型局部变量

 隐式局部变量也称匿名变量，使用关键字 var 声明，负责告诉编译器，该变量需
 要根据初始化表达式来推断变量的类型，而且只能是局部变量。

var 变量名称 = 变量值;
var n = 3;  // n 作为整型数据被编译

隐式转换

源类型	目标类型
$sbyte$	$short、int、long、float、double、decimal$
$byte$	$short、ushort、int、uint、long、ulong、float、double、decimal$
$short$	$int、long、float、double、decimal$
$ushort$	$int、uint、long、ulong、float、double、decimal$
$int$	$long、float、double、decimal$
$uint$	$long、ulong、float、double、decimal$
$long$	$float、double、decimal$
$ulong$ $double$	$float、double、decimal$
$float$	$double$
$char$	$ushort、int、uint、long、ulong、float、double、decimal$

隐式枚举转换只允许将十进制数 0 转换为 枚举类型的变量。类型 C2 向类型 C1 
隐式引用转换的条件是：C2 是从 C1 派生而来的，C2 和 C1 可以是类或接口。两
个数组之间隐式转换条件：两个数组维数相同，元素都是引用类型且存在数组元素的
隐式引用转换。
var 定义的变量的数据类型由赋值的数值决定。

所有的隐式类型转换都可以用显示类型转换的形式来表示，可以使用强制转换表达式从任何数值类型转换为任何其他的数值类型。

$Convert$ 类转换 $System.Convert类就是专门进行类型转换。$

方法	目标类型	方法	目标类型
$Convert.ToByte()$	$byte$	$Convert.ToInt16()$	$short$
$Convert.ToSByte()$	$sbyte$	$Convert.ToInt32()$	$int$
$Convert.ToChar()$	$char$	$Convert.ToIn64()$	$long$
$Convert.ToString()$	$string$	$Convert.ToUInt16()$	$ushort$
$Convert.ToDecimal()$	$decimal$	$Convert.ToUInt32()$	$uint$
$Convert.ToDouble()$	$double$	$Convert.ToUInt64()$	$ulong$
$Convert.ToSingle()$	$float$	$Convert.ToBoolean()$	$bool$

拆箱是把 引用 类型转换成 值 类型；装箱是把 值 类型转换成 引用类型。$System$ 空间下的 $Object$ 类是所有类型的基类。

流程控制语句

if(布尔表达式)  // if(true) 执行括号内的语句
{
    
    
    语句块;
}
二选一
if(布尔表达式)
{
    
    
    语句块 1;
}else{
    
    
    语句块 2;
}
多选一
if(布尔表达式 1)
{
    
    
    语句块 1;
}else if(布尔表达式 2){
    
    
    语句块 2;
}
...
else{
    
    
    语句块 n;
}

switch(表达式)
{
    
    
    case 值 1:
        语句块 1;
        break;
    case 值 2:
        语句块 2;
        break;
        ...
    default:
        语句块 n;
        break;
}

for(表达式 1; 表达式 2; 表达式3)
{
    
    
    表达式 4;
}
表达式 1:为循环变量赋初值。
表达式 2:为循环设置循环条件，通常是布尔表达式。
表达式 3:用于改变循环变量的大小。
表达式 4:当满足循环条件时执行该表达式 4。

遍历集合可以用 foreach
foreach(类型 标识符 in 表达式）
{
    
    
    [语句序列];
}

当 while 中布尔表达式的结果为 True 时，执行语句块中的内容，否则不执行。通常使用 for 循环可以操作的语句都可以使用 while 循环完成。
while(布尔表达式) 
{
    
    
    语句块;
}

do while 语句执行的过程是，先执行 do{
    
    } 中语句块的内容，再判断 while() 中布尔表达式的值是否为 True,如果为 True,则继续执行语句块中的内容，否则不执行，因此 do while 语句中的语句块至少会执行一次。
do
{
    
    
    语句块；
}while(布尔表达式);

$C\#$ $break$ 语句用于中断循环，使循环不再执行。如果是多个循环语句嵌套使用，则 $break$ 语句跳出的则是最内层循环。
$C\#$ 中的 $continue$ 不是强制终止，$continue$ 会跳过当前循环中的代码，强制开始下一次循环。

C# goto 语句用于直接在一个程序中转到程序中的标签指定的位置，标签实际上由
标识符加上冒号构成。

goto Labell;
    语句块 1;
Labell
    语句块 2;
    
如果要跳转到某一个标签指定的位置，直接使用 goto 加标签名即可。在上面的语
句中使用了 goto 语句后，语句的执行顺序发生了变化，即先执行语句块 2，再执
行语句块 1。此外，需要注意的是 goto 语句不能跳转到循环语句中，也不能跳出
类的范围。由于 goto 语句不便于程序的理解，因此 goto 语句并不常用。

数组

一维数组声明：
数据类型 [] 数组名;
int [] f = new int[5]; //声明有 5 个数组元素的数组
声明过的数值类型数组中的元素默认值为 0，引用类型中的数组元素默认值为 null

二维数组的声明：
数据类型 [,] 数组名;
int [,] f = new int[2,2];  //声明一个两行两列的二维数组

$\ast \ast Array类常用方法\ast \ast$

方法名	说明
$BinarySearch$	在一维排序 $Array$ 中搜索特定元素
$Clear$	将 $Array$ 中的一系列元素设置为 0、$false$ 或 $null$，具体取决元素类型
$Copy$	复制 $Array$ 中的一系列元素，将它们粘贴到另一 $Array$ 中
$CreateInstance$	创建数组
$Find$	搜索与指定谓词所定义的条件相匹配的元素，并返回整个 $Array$ 中的第一个匹配元素。
$GetLength$	获取一个 32 位整数，该整数表示 $Array$ 的指定维中的元素数
IndexOf	搜索指定的对象，并返回 $Array$ 中匹配项的索引
$Reverse$	反转一维 $Array$ 中全部或部分元素的顺序
$Sort$	将 $Aarry$ 中的元素排序

int [] a = new int[50];
Array.Sort(a);  //对数组 a 升序排列
a.Sum(), a.Average(), a.Min(), a.Max(); 
//分别是求和、平均值、最小值、最大值

匿名数组

匿名数组就是隐藏数组，不同的类型为数组。
var f = new[]{
    
    1,2,3,4};  //定义匿名数组，元素类型是 int

结构体类型

结构体中能定义字段、属性、方法等成员。定义的语法形式如下。
访问修饰符  struct  结构体名称
{
    
    
    //结构体成员
}
1.访问修饰符通常使用 public 或者省略不写，如果省略不写，代表使用 private
 来修饰。如果结构体中的内容要被其他类中的成员访问，需要将其访问修饰符设置
 为 public。
2.结构体名称的命名规则通常和变量的命名规则相同，即从第二个单词开始每个单
词的首字母大写。
3) 结构体成员包括字段、属性、方法以及后面要介绍的事件等。在结构体中也能编
写构造器，但必须带参数，并且必须为结构体中的字段赋初值。在调用结构体的成员
时，能使用不带参数的构造器，与创建类的对象时类似。

结构体与类的区别

结构体	类
允许不使用new对其实例化	必须使用new实例化
没有默认构造方法	有默认构造方法
不能继承类	能继承类
没有析构方法	有析构方法
不允许使用abstract、protected以及sealed修饰	允许使用abstract、protected以及sealed修饰

枚举类型用 enum 定义
Enum.GetNames(typeof(a)):获取 a 中定义的所有符号的名称
string.Join(",",f): 将字符数组 f 中每个元素之间用 , 串联
Enum.GetValues(typeof(a)): 获取 a 中定义的所有符号名称对应的数组。

字符串

string 是 Unicode 字符串，每个英文字母占 2 个字节，每个汉字也占 2 个字节
计算字符串长度时，每个英文字母的长度为 1，每个汉字的长度也是 1。

字符串比较:
string.Compare(string s1, string s2)
1.s1 > s2，结果为 1
2.s1 == s2，结果为 0
3.s1 < s2，结果为 -1
比较字符串是否相等推荐 s1 == s2 或 s1.Equals(s2);//相等是true,反之false

字符串查找：
1.Contains ：查找一个字符串中是否包含指定的子字符串
s1.Contains(s2);   // s1 是否包含 s2
2.IndexOf方法：求某个字符或子串在字符中出现的位置。
s1.Indexof(s2);//返回s2在s1中首次出现的从零开始的位置，如果不存在返回-1。
s1.Indexof(s2,pos): //在s1中从pos位置开始查找s2, 查找到返回该位置，没查找到返回-1
3.LastIndexof:与 IndexOf 方法查找方向相反。

IndexOfAny:查找字符串串中是否含有某些字符。
s1.IndexOfAny(s2); //返回 s2 中任意一个字符首次出现在 s1 中的位置，全部没有返回 -1。

Substring:得到一个字符串中从某个位置开始的字符串。
s1.Substring(strat,len): //从start 位置开始截取长度为 len 的字符，len 省略就截取到字符串末尾。

s1.Insert(pos,s2); //从s1 pos处开始把 s2 插入 s1
s1.Remove(pos，len); //从 pos 处开始删除 len 个字符,len省略就删除到末尾。
s1.Replace('s','e'); //将s1 中所有的字符 s 替换成 e
S1.Replace("st","ed"); //将s1中所有的字符串 "st" 替换成 "ed"

s1.TrimStart(); //删除 s1 首部的空格
s1.TrimEnd(s2); //删除从s1尾部开始在s2中包含的字符
s1.Trim(s2); //删除 s1 中在 s2 中出现的所有字符

s1 = string.Join(",",s2); // s2中的字符串以 , 进行连接
string [] s1 = s2.Split(',',';'); //s2中的字符只要遇到 , 或 ; 就分离
s2 = s1.ToUpper(); //s1中的所有英文字符转换成大写
s2 = s1.ToLower();  //s1中的所有字符转换成小写

s1.Append(s2);  //s2连接在s1上且不换行
s1.AppendLine(s2); //s2连接在s1上换行

StringBuilder 类位于 System.Text命名空间下，使用时每次重新生成新的的字符
串不再生成新的实列，直接在原来字符串占用的内存空间上进行处理，还可以动态地
分配占用内存空间地大小，字符串连接操作多地情况用StringBuilder可以很大地提
高系统的性能。