c#学习笔记

ctrl+空格 开关中文输入法
运行F5
空null
备注Ctrl+k Ctrl+c
取消备注Ctrl+k Ctrl+u
&取地址符
想复制选中代码可以直接Ctrl+d
快速切到这一行最前面和最后面分别是home，end
连续选择单独选择分别是shift，ctrl
多行备注/*内容*/
特殊字符\+一个字符
转义字符（例：\）
双引号前加@，则双引号内部字符串内的\就是个符合，没有转义功能
前面加@的双引号的字符串可以占多行
特殊，要输出\使自己看到需要打\\，因为只有一个\那么会把后面的字符转义，用\转义\出来的是\，所以要输出\要打出\\
要输出"要\"
字符串换行\n
制表符（大多时候是四个空格长）\t
命名空间，类，方法
程序入口方法Main，一个项目只能有一个入
口

readline一次读一行，read一个一个的读

因为每个字符都是以数字存储的所以是int
想输出字符得char 变量名=（char）变量名
字符串转换成数字（例字符12变数字12，注意只能转换整数不然会出错
int 变量名=convert.toint32(变量名)；

变量类型有int（整数）
double(小数）char（字符）
string（字符串）
变量类型+空格+变量名，就创建了一个存储数据的容器
装入变量（例：变量名=XXX）也叫赋值
＝是赋值操作，把右边给左边（赋值会覆盖）
变量强塞
（例：int a;double b;int a=(int)b

先声明后构造

字符串用双引号引住，字符用单引号引住
"字符串"+"字符串"输出出来就是字符串间的拼接
变量名不能数字开头，变量名可以有字母数字下划线

运算符
A=A+B（A+=B）+可换-×÷
自增A=A+1（A++）+换减就是自减符
++在A前时先加一再输出，在后时就先输出后加一

布尔 bool
true是 false不是
不等于号！=
是否等于= =
串联判断&&（和，有错则错
并联判断||（或，有对则对
结果反转！（非，结果反过来
例：bool a=3小于4&&9大于10
输出结果是false
整型÷后直接舍去小数点没有四舍五入

条件语句（if语句）
if(条件）｛满足条件时执行的
｝
else{不满足条件时执行的，可以不用else只有if！
}
注意if语句可以套娃！
if(){if(){.....}}else也能。

switch语句
switch(需要判断的变量)
｛
case 变量的值：满足变量的值执行的代码;break;
case 另一个变量的值：执行的代码break;
.....（省略多个case等
default:执行的代码；break；
｝

default是上面case的情况都不是的其余情况
可以不用default结尾，
用case xxx:xxx;break;
default可以没有，每个case后面一般都有break

switch可以的if都可以
switch中case后面跟的变量的值只能为常量
switch是单变量多情况范围小
if是可以多变量多情况范围大

循环语句while
while（条件）｛执行的代码；｝
执行完后会再返回条件判断，满足继续执行，直到不满足后开始执行下一行
条件为ture时会一直满足
为falsw时会一直不满足
do.while语句
do{执行的代码；}while(条件);
dowhile与while区别是dowhile至少会执行一次

循环语句for
for(初始化；条件；增量）
｛循环代码；｝
初始化只执行一次，条件满足就执行增量和循环不满足就停止循环执行下一代码
条件为空时默认一直循环
例
for（int i=0；i小于10；i++)
{Console.WriteLine("i");}

跳出离他最近的循环break；
(循环是可以嵌套的）

条件表达式也是布尔表达式

作用域
每个｛｝都是一个作用域，被｛｝括的｛｝的是子作用域，括住｛｝的是父作用域，父作用域的变量子作用域可以用，子作用域的父作用域不能用。同一作用域内变量不能重名。

continue终止当前循环，直接进行条件判断进行下一次循环。
writeline()括号里是空的时默认输出换行

随机数生成random
random 变量名字=new random();
console.writeline(变量名字.(a，b));
(随机输出a～b-1)
int 变量名字= 变量名字.next(a，b);

数组需要创建和赋值
创建，例：int[] 数组名字；
赋值，例：数组名字 =new int[元素数量减一]{元素，元素，.....}
（元素数量减一在有元素的时候可以不填，元素数量减一在没元素的时候必须填）元素数量减一也是数组的容量大小

创建并赋值数组：
例：int[]数组名字=｛元素，元素，.....｝

数组长度：数组名字.length

遍历一个数组
foreach(临时变量类型 临时变量名字 in 数组名字)
{
console.write(临时变量名字)；
}

排序
array.sort(要排序的数组)；

字符串方法
全变小写字母tolower()   
全变大写字母toupper()
去除最前面和最后面的所有空格trim()
去除最前面的所有空格trimstart()
去除最后面的所有空格trimend()
分割字符串成字符串数组split("a")
a是依据a来分割这个字符串
方法使用
名字.方法

数组间转换
a=array.convertall(b，c.parse);
a是数组名字
b是要转换成a的数组的名字
c是b要转换成数组的类型（a的数组类型）（c例:int string double)

一个字符串能当字符数组来访问

函数的定义（方法名字大写开头）
void返回值（不需要返回值时用void)
需要返回值可以为bool，int等
需要看到方法运算结果的就需要返回值
参数可以为空可以为多个参数，参数需要有类型有名字（例：string a)
static 返回值 方法名字（形式参数）｛方法体｝
定返回值return true(或者false);放方法体中
static不是固定的别的是固定的。

其他函数只有main方法调用的时候才会执行
main是主函数

使用方法
方法名字（实际参数）；
使用的时候会先将括号内赋值给该方法的参数然后再执行该方法的方法体

不同方法中名字可以重名
参数需要有类型有名字

参数数组
Paramus 数组类型[]数组名字
自动将发送过来的所有参数整理成一个数组
参数数组必须放在形式参数内最后一位

变量转常量（常量名字全大写）
const 类型 名字=定值；

枚举类型
enum 枚举类型名字
｛
       变量，变量，....，变量；
｝

枚举类型的使用
枚举类型名字 变量名字=枚举类型名字.变量；

结构体（多个变量的整合）
struct 结构体名字
｛
          访问权限    类型一 类型一名字；
          访问权限    类型二 类型二名字；
.......
｝

结构体的使用（现在访问权限就用public就可以，意思是公开的)
结构体名字 变量名字；
变量名字.类型一名字=....;
变量名字.类型二名字=....;
或
结构体名字[]数组名字=new 结构体名字[长度]；
数组名字[0].类型名字=...；

结构体创建的对象是值类型，将其他对象赋值进来，两者是没有直接关联的，修改赋值对象的参数，被赋值的对象所对应的参数也不会改变

结构体是值类型，对象是引用类型
对象是传地址，结构体是传值

委托
delegate 返回值 委托名字（形式参数）；

返回值和形式参数与委托一致的函数（方法）可以直接委托接取。

委托名字 接取口名字=接取的函数（方法）名字；

接取后接取口名字等同于函数名字使用方法和函数一样。

开平方根math.sqrt()；
开任何根math.pow()；

try{要检测的语句}
catch（可能出现的异常){出现时的处理}
catch(){}... ..... ....
finally{无论是否出现异常都执行的语句}

finally{}可以不用
try.catch语句不能用在递归里

面向对象oop编程（分类整理的过程）

定义类  类里有数据成员和函数成员
右键，类， 类名字
class 类名字｛｝
数据成员
类里面定义数据  访问权限 类型 名字；
例public int a;
函数成员
例public void a(){}

用类创建变量 对象（对象也是变量）
类名字 对象名字=new 类名字（）；
声明对象
类名字 对象名字；
实例化对象
对象名字=new 类名字（）；

使用对象
对象的使用和结构体相同，结构体名字换成对象名字，类型名字换类里面的函数名字或者数据名字

对象方法
输出对象内所有数据
对象名字.print();

构造函数
每个类里都必须有构造函数，自己没设置时会自动设出一个构造函数
访问权限 构造函数名字（形参）｛方法体｝
构造函数名字要和该类名字一致，构造函数可以重载，重载时运行构造函数中的形参与设置对象的实参相同的那一个构造函数
构造函数会在设置该类对象时自动运行，即初始化。

同一类重名时
this.名字，意思是当前类中设置的数据名字
名字，意思是离这个地方最近一的个这名字

访问权限 私有的 仅能在当前类内访问，类外其他类访问需要访问公开的函数里再访问私有的（间接访问）

私有的private

属性
访问权限 变量类型 变量名字｛get{}set{}｝
例
public int a
{
   get{return a;}
   set{a=value;}
}
属性是定义在类里面然后在另一类设置完对象后
使用属性（对其输入和输出）
例
类名字 对象名字=new 类名字（）；
对象名字.a=赋予新值；
console.writeline(对象名字.a);

get和set前面可以加访问权限，不加默认public
可以只有get或者只有set
get读取set写入

匿名类型
var 变量名字；
第一次给这个变量赋值的时候这个值是什么类型这个变量以后就是什么类型
例var a;a=1;所以a以后的类型都是整型（int等）

程序内存区域
栈，空间小 读取快 数据后进先出
（箱子里放书，数据存进去叠起来，拿出来要从顶上开始拿书）
堆，空间大 读取慢 数据任意顺序进出
（书散开摆无限大的地板上，任意摆任意拿）
静态存储区，存常量

值类型，字符串变量地址存在栈中，这个变量里存的字符串存在静态存储区中

引用类型，数组变量地址存在栈中，这个变量中的变量们存在堆中
其余类型都直接以值直接存在栈中

定义的变量才是创建新内存区域的（例new)
已经定义过的赋值是索引的改变，并不创建新的内存区域
!!!

null空引用
引用类型string和class还有接口
其余为值类型

继承
定义父类还有子类
父类是子类们的共有属性
子类继承父类
子类可以重新定义父类
父类仍然可以单独设置对象调用

继承例：
子类名字：父类名字

访问权限
可以被子类访问和自己类内部访问

this.可以访问父类里的数据和自己类里的数据
base.访问父类里面的数据

设定虚方法，重写父类函数
虚方法
访问权限 virtual 返回值类型 方法名字（形式参数）｛方法体；｝
重写
访问权限 override 返回值类型 方法名字（形式参数）｛方法体；｝

隐藏方法
直接重写
访问权限 new 返回值类型 方法名字（形式参数）｛方法体；｝

父类声明子类定义对象输出函数输出的是父类的，子类声明子类定义对象输出的函数是子类的

抽象类 abstract class 类名字｛｝
抽象方法 访问权限 abstract 返回值类型 方法名字（）；

抽象类和抽象方法不能成实例对象，用来做模板给别人照着做
抽象类函数（方法）不能有方法体，定义完就结束
抽象的类里可以有普通函数
抽象的函数才不能有方法体
继承抽象类（当抽象类的子类）需要把抽象类内的抽象方法进行重写。
抽象类不能构造对象但可以当父类
访问权限 override 返回值类型 方法名字（形式参数）｛方法体；｝

密封类 sealed class 类名字｛｝
密封方法 访问权限 sealed override 返回值类型 方法名字（形式参数）｛方法体；｝
密封方法必须要密封继承过的方法（只能密封重写的子类方法）
密封类和密封方法不能被继承（不能当父类）可以用来让使用不让二次修改

父类
不指定调用哪个构造函数时默认调用无参的构造函数
指定时调用指定的构造函数

子类
不指定调用哪个构造函数时默认调用无参的构造函数
指定时调用指定的构造函数
注意，一定是先自动调用完父类的构造函数才会调用自己的构造函数

子类构造函数指定父类构造函数
访问权限 子类函数名字 （形式参数）：base(形式参数)｛ 方法体；｝
此时会根据base后括号内形参来匹配父类内部与其形参匹配的构造函数，然后调用子类的这个构造函数

子类构造函数后面不加base去指定使用父类哪个构造函数就默认使用父类的无参构造函数
———————————————————

访问权限
public同一程序集中均可访问
private同一类或结构可以访问
protected自己类和自己的子类可以访问
internal同一个程序集的可以访问
（所在项目生成的dll文件和这个项目就是程序集）
protected internal在自己程序集作为internal，在别的程序集作为protected

添加别的项目的引用：找到别的项目
引入命名空间：才能使用其中的类
把类设置为public:使用的类访问权限必须为public

new(隐藏继承的成员
隐藏看声明

abstract(被修饰的类是抽象类，只能是其他类的基类，不能与sealed和static一起使用

sealed(被修饰的类是密封类，无法被继承，不能与abstract和static一起使用。用于方法或属性时需要和override一起使用

static(静态类，所以成员都是静态的，不能与abstract和sealed一起使用，不能实例化，静态成员不能通过对象访问，只能通过类名字访问，静态函数只能使用静态数据，一般公共的数据只需要一份的数据用静态类

const(默认是static的，不能与static一起用，用来声明常量或局部常量，声明常量时必须赋初值，只能初始化时赋值

readonly(类似const但是可以在构造函数里和初始化时赋值

virtual(虚方法，可以重写，不能与static，abstract，private或，override一起用
虚类看构造
虚函数重写前就是个普通函数

override(实现虚方法，重写，重写对象必须是virtual或abstract或override的

接口类
接口里的方法体都是抽象类且不用写上abstract，接口成员都是public的，接口名字前加个大写字母I，接口成员不能有数据成员（例 int a;)
定义接口
访问权限 interface I接口名字｛方法体；｝
方法体例void 方法名字（形式参数）；
实现接口
访问权限 class 类名字：I接口名字｛方法体；｝

接口间可以继承
类可以接上多个接口
类名字：接口一名字，接口二名字，......
类继承类和接口时接口放类后面

多态
接口名字 对象名字；
对象名字=new 类名字（）；
使用该类的方法等
对象名字=new 另一类名字（）；
使用另一类的方法等
.....

对象=后面的类都是有接上“接口名字”这个接口的类

索引器
索引值index
定义索引器
访问权限 索引器类型（int等） this[索引类型(int等) index]{get{return 数组名字[index];}
set{数组名字[index]=value;}}

运算符重载
访问权限 static 运算符类型 operator重载的运算符（对象一，对象二）｛方法体；｝

例
public static bool operator==(类名字 对象名字，类名字 另一对象名字)
｛
if(对象名字.数据成员==另一对象名字.数据成员）｛return ture;｝
return false;
｝

列表list
创建列表
list<列表类型> 列表名字=new list<列表名字>（列表初始容量）；
初始容量可以不填，此时容量为零
添加数据容量会变四，容量再不够容量会变二倍

给列表添加对应数据
列表名字.add(添加的数据)；
以插入的方式添加对应数据
列表名字.insert(插入的索引位置，插入的数据）；
插入索引值位置的原数据机以及后面的数据集体后移

移出列表数据
列表名字.remove(要移出的数据例：32)；
将移出列表内索引值最小的那个32，其他的不动
removeat(要移出数据的索引值)
移出数据后，在这个后面的所有数据前移
所以用循环遍历的时候如果有用移出记得int i的i-2来重复检查一下上一索引，减二是防止移出的是最后一个数导致错误是特殊情况，其他时候移出减一就可以减二的话如果在索引零的位置也会超出索引范围，

查找列表数据的索引值
indexof(要查找的列表数据例：32)
有多个则输出索引值最小的那个
查不到会返回-1
倒着查找
lastindexof(要查找的列表数据)
有多个则输出索引值最大的那个

访问列表数据
列表名字[数据索引]；

列表数据排序
sort()
排序完是从小到大

列表数据已存量
列表名字.count;

列表容量
列表名字.capacity;

列表遍历
foreach (列表类型 temp in 列表名字）
｛循环体；｝
或for(列表类型 变量名字=0；变量名字<列表名字.count;变量名字++）｛循环体；｝

泛类型（泛类），可以定义个不确定的类，设置对象的时候再指定这个对象是int还是什么double，该类型的不同对象指定的类型可以不同（例对象一是int对象二是double

定义泛类型
class 类名字<T>｛方法体，数据｝
里面数据的类型方法的类型int等都用T代替
多个泛类型则要写T1，T2.....

定义泛类型的对象
泛类型名字<指定的类型例int> 对象名字=new 泛类型名字<指定的类型例int>；

泛方法
访问权限 T 方法名字<T>(){}

重写override 重载overload
类的tostring()方法
在定义一个类且没有给他继承的时候他会自动继承系统给的基类，那里的tostring方法
类名字 对象名字=new 类名字；
console.write(对象名字）；（此时意思是调用系统中基类的tostring给对象然后输出打印）
此时是输出这个对象所在路径:命名空间.类名字
想要使用tostring来输出对象内的数据则要重写tostring
public override string tostring(){方法体}

系统基类方法equals判断两个是否相等
使用方法
被比较的.equals(比较的）；
例int a=1;int b=2;
a.equals(b);此时返回值为false因为a，b不相等
equals方法比较的是地址
想比较的是内容是否相等则要重写equals方法
public override bool equals(object obj){}