0. 目录

1. C#基础

1.1 程序结构

创建项目

  • 解决方案=>项目=>类=>属性、方法等
  1. 添加空白解决方案
  2. 设置解决方案名称、和文件位置
  3. 创建成功后，在解决方案名称处，右键，添加新项目
  4. 添加新项目（控制台应用.NET Framework）
  5. 在新添加的项目处，右键，添加类

1.2 数据类型

数据类型

【.NET】知识覆盖_数据类型

  • 值类型
    所有的值类型均隐式派生自​​​System.ValueType​​​；值类型是直接存储一个数值，存储在线程栈中
    ​​特征​​：有固定的长度、存储在内存的栈(stack)中
  1. 值类型-枚举类型
class Class1
{   
    enum Days {Sat, Sun, Mon, Tue, Wed, Thu, Fri};  
    static void Main(string[] args)
    {   
        Days day=Days.Tue;
        int x=(int)Days.Tue; 
        Console.WriteLine("day={0},x={1}",day,x);//显示结果为:day=Tue,x=3
        Console.ReadLine();
    }
}
  1. 在此枚举类型Days中，每个元素的默认类型为int，其中Sun=0，Mon=1，Tue=2，依此类推。也可
    以直接给枚举元素赋值
    例如：
enum Days{Sat=1,Sun,Mon,Tue,Wed,Thu,Fri,Sat};
sum=2,从前一个枚举的值依次+1
  • 引用类型（Reference types)
    引用类型的基类为​​​Object​​​ 引用类型变量存储的是变量所在的内存地址，引用类型变量的实际数据存储在堆中，变量本身仅仅是一
    个指向堆中实际数据的地址，存在于栈内存中，通常是四个字节
    ​​特征​​：存储数据不定长、数据存储在堆(Heap)中，把存数据的堆的内存地址存储在栈中

    1. 类：C#语言中预定义了一些类：对象类(Object类)、数组类、字符串类等。当然，可以定义其他类
    2. 接口
    3. 委托


  • Object
    C#中的所有类型(包括数值类型)都直接或间接地以Object类为基类。对象类(Object类)是所有类的基类
    任何一个类定义，如果不指定基类，默认object为基类。继承和基类的概念见以后章节
    C#语言规定，基类的引用变量可以引用派生类的
    对象(注意，派生类的引用变量不可以引用基类的对象),因此,对一个object的变量可以赋予任何类型的
    值：
int x =25;
object obj1;
obj1=x;
object obj2= 'A';
object关键字是在命名空间System中定义的，是类System.Object的别名。
  • 类型转换
    类型转换从根本上是把数据从一种类型转换为另一种类型。有两种形式：
  1. 隐式类型转换 - 这些转换是 C# 默认的以安全方式进行的转换, 不会导致数据丢失
    例如，从小的整数类型转换为大的整数类型，从派生类转换为基类
    例如：int i=10;long l=i;
  2. 显式类型转换-显式类型转换，即强制类型转换。显式转换需要强制转换运算符，而且强制转换会造成数据丢失。
long l=5000;
int i=(int)l;  // 如果超过int取值范围，将产生异常
double d = 5673.74;
int i;
i = (int)d;   // 强制转换 double 为 int
  • C# 提供了一些内置的转换方法:
Convert.ToInt32(“333”);  int.Parse;// 转换失败将产生异常；
int.TryParse(“32s”,out int i); // 返回bool值，代表是否转换成功，转换成功i为转换后的值 不成功i为int默认值
  • 变量
    变量就是在运行过程中其值可以被改变的量，变量的类型可以是任何一种C#的数据类型.
    所有值类型的变量都是在实际存在于内存中的值，也就是说，当将一个值付给变量时执行的是值复制操作
    变量的定义格式为：
    变量数据类型 变量名(标识符) 或 变量数据类型 变量名(标识符)=变量值；
    其中，第一个定义只是声明了一个变量，并没有对变量进行赋值，此时变量使用默认值；第二个声明定义变量的同时对变量进行了初始化，变量值应该和变量数据类型一致. 下面的代码就是变量的使用。
int a=10; 　
double b,c;
int d=100,e=200;
double f=a+b+c+d+e;
  • ​​讲解​​：

  1. 第一行代码：声明了一个整数类型的变量a，并对其赋值为10。
  2. 第二行代码：定义了两个double类型的变量，当定义多个同类型的变量时，可以在一行中声明，各
  3. 变量间使用逗号分隔。
  4. 第三行代码：定义了两个整数类型的变量，并对变量进行了赋值。当定义并初始化多个同类型的变
    量时，也可以在一行中运行，使用逗号分隔
  5. 第四行代码：把前面定义的变量相加，然后赋给一个double类型的变量，在进行求和计算时，int类
  6. 型的变量会自动转换为double类型的变量。

  • 常量
    常量就是在程序的运行过程中其值不能被改变的量。常量的类型也可以是任何一种C#的数据类型常量的定义格式为
    const 常量数据类型 常量名(标识符)=常量值;
    其中，const关键字用于标识该常量。常量名要有代表意义，不能过于简洁或复杂。其命名规则如下：
  1. 标识符必须以字母或者@符号开始
  2. 标识符只能由字母、数字以及下划线组成，不能包括空格、标点符号和运算符等特殊符号
  3. 标识符不能与C#中的关键字同名。
  4. 标识符不能与C#中的库函数名相同。
    例如：
const double PI=3.1415926;
const string version="Visual Studio 2010";
  • 讲解：
    第一行：定义了一个double类型的常量
    第二行：定义了一个字符串类型的常量
    一旦用户在后面的代码中试图改变这2个常量的值，则编译会发现这个错误并使代码无法编译通过。
  • 可为空引用类型
    单问号 ? 与 双问号 ??
    单问号？用于对 int,double,bool 等无法直接赋值为 null 的数据类型进行 null 的赋值，意思是这个数据类型是 NullAble 类型的。
    int? i = 3 等同于 Nullable i = new Nullable(3);
    int i; //默认值0
    int? ii; //默认值null
    双引号??（Null 合并运算符）：
    a??0，相当于：if(a==null){a=0;}

1.3 类和对象

Class-1

类的定义格式如下：

class 类名
{
    成员变量;
    成员方法;
}

例如：

class A 
{
    int x;  //成员变量
    int f()         //成员方法
    {
        return x;
    }
}

声明对象和创建对象的语法格式分别如下：

类名 对象名;             //声明对象
对象名 = new 类名();      //创建对象
也可以在声明的同时创建对象：
类名 对象名 = new 类名();

静态类（static class a(){}）不需要初始化，可直接调用非静态类的静态方法或静态属性也可以直接调用

成员访问权限

【.NET】知识覆盖_c#_02

注意事项:

  1. 定义类时，如果不写访问修饰符，则默认为internal。
  2. 定义类成员变量、方法时，如果不写访问修饰符，则默认为private。
  3. 基类访问级别必须高于或者等于派生类访问级别。
  4. 方法的访问级别必须高于或等于方法参数、方法返回值类型访问级别。
  5. 类中属性类型或者字段类型必须高于或等于其对应的访问级别

构造函数和析构函数

  • 构造函数
  1. 是一种特殊的方法，主要用来在创建对象时初始化对象，即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中
  2. 构造函数的命名必须和类名完全相同
  3. 构造函数的功能主要用于在类的对象创建时定义初始化的状态，它没有返回值，也不能用void来修饰,这就保证了它不仅什么也不用自动返回，而且根本不能有任何选择
  4. 一个类可以有多个构造函数，可根据其参数个数不同或参数类型的不同来区分它们，即构造函数的重载
  5. 如果在默认的类中，如果没有构造方法，系统会自动添加一个没有参数的构造方法。
  6. 如果用户手工添加了构造方法，系统默认的无参的构造方法会自动删除。
    下面定义了类B1，其中并没有显式定义构造函数。
class B1
{
    int x;
    string s;
    char c;
    public void outmembers()
    {
        Console.WriteLine("x = {0}, s = x{1}x, c = x{2}x", x, s, c);
    }
}
  • 析构函数
    在对象被撤销（从内存中消除）时被执行，显然也仅仅执行一次，通用用于做对象被销毁前的“扫尾”工作
    定义格式如下：
~类名()
{
     语句序列
}
  • 析构函数名是在类名前加上符号“~”而得到
    析构函数没有参数、返回类型和修饰符
    一个类中至多有一个析构函数，如果没有定义析构函数，则系统会在撤销对象时自动调用默认析构函数
    析构函数也不能显式被调用，而是在撤销对象时由系统自动调用。

属性

属性是一种特殊的类成员，它既可以被视为一种成员变量，也可以看作是一种成员方法
属性定义的语法格式如下：

数据类型   属性名
{
    get {return 表达式1;}
    set {表达式2; //表达式2一般包含特殊变量value}
}

可简写为 数据类型 属性名｛get;set;｝
get:访问器，用于读取属性值
set:访问器，用于设置属性值

静态类

  1. 静态类是不能实例化的类，也就是说静态类不能使用new关键字来创建静态类型的变量。
    声明一个类时使用static关键字，只能通过“类名.成员名”来访问
  2. 静态类只能包含静态成员，不能有实例成员。
  3. 常用的静态类有Console、String、Math、Convert
  4. 静态类的适用场景是通用性较高的工具类

类的静态成员

  1. 类的成员分为静态成员和非静态成员
  2. 静态成员隶属于类，只有一个版本，所有对象都共享这个版本；非静态成员隶属于对象，不同的对象(同一个类实例化）有不同的非静态成员，因此有多个版本
  3. 从内存管理的角度看，静态成员是在一个共享的内存空间中定义，所有对象都可以访问这个空间中的同一个静态成员；而非静态成员在对象被
  4. 创建时形成自己的存储空间（这个空间是对象所拥有空间的一部分），这样不同的对象将形成不同的非静态成员（虽然它们的类型都一样)
  5. 从访问的方式看，静态成员不需要（也不能）实例化，只要定义类了以后就可以通过类名来访问它；而非静态成员则需要在创建对象以后通过对象名来访问
  6. 声明静态成员是由修饰符static来完成，是属于类，实例成员属于对象，在类第一次加载时，类下面的静态成员会被加载
    例如:
private static int y;                    //静态成员变量
public static void f(int x) { }       //静态成员方法

List

List是一种泛型集合：数据类型作为变量
List ListOfT = new List();T:为集合中每一项的类型，可以是简单类型也可以是自定义的类型
List集合可用的操作，常用：

  1. Add():添加项
  2. Count：获取集合的数量
  3. Clear( ) 在List内移除所有元素
  4. Contains( ) 测试一个元素是否在List内
  5. ToArray( ) 把List内的元素拷贝到一个新的数组内
  6. Remove( ) 移除与指定元素匹配的第一个元素
  7. RemoveAt( ) 移除指定索引的元素
  8. RemoveRange( ) 移除指定范围的元素

StringBuilder

StringBuilder对象为动态字符串，可以对其设置好的字符数量进行扩展。另外，还可以设置一个最大长度，这个最大长度称为该StringBuilder对象的容量（Capacity）
为StringBuilder设置容量的意义在于，当修改StringBuilder字符串时，当其实际字符长度（即字符串已有的字符数量）未达到其容量之前，StringBuilder不会重新分配空间；当达到容量时，StringBuilder会在原空间的基础之上，自动不进行设置，StringBuilder默认初始分配16个字符长度。有两种方式来设置一个StringBuilder对象的容量。

//使用构造函数
 StringBuilder Mysb1=new StringBuilder(“Hello”,100);//初始值为Hello，长度限制为100
 StringBuilder Mysb2=new StringBuilder(“Hello”);//初始值为Hello

常用方法：

  1. Append()：给当前字符串追加一个字符
  2. Insert() ：追加特定格式的字符串
  3. Remove() ：从当前字符串中删除字符
  4. Replace() ：在当前字符串中，用某个字符或者字符串全部替换另一个字符或者字符串
  5. ToString() ：把当前stringBuilder中存储的字符串，提取成一个不可变的字符串

String类和StringBuilder类的差异

StringBuilder 可以显示的设置分配内存的大小，而 String 只能根据你初始化时的字符串的大小由系统分配足够的内存。
例如，当在一个循环中将许多字符串连接在一起时，使用StringBuilder类可以提升性能。
当要对字符串进行频繁的操作的时候，应该选择 StringBuilder简单的字符串操作可以选择String

Dictionary

Dictionary提供快速的基于键值的元素查找。
结构是：Dictionary<[key] , [value] >,当你有很多元素的时候可以用它。
它包含在System.Collections.Generic名控件中。在使用前，你必须声明它的键类型和值类型。
注意：

  1. dictionary中是不允许有重复项的，这样才能按key索引到唯一一个value。
  2. 不能在foreach循环里面移除，因为会导致错误：集合已修改;可能无法执行枚举操作。可以改用for循环
    参照代码：DictionaryTest.cs

1.4 常用语法

运算符

  1. 算术运算符：+、-、*、/、%（取余数）、++（同+1）、–（同-1）
  2. 比较运算符：==、！=、>、<、>=、<=
  3. 逻辑运算符:
  4. &&：两个操作数都非零，则条件为true
  5. ||：两个操作数中有任意一个非零，则条件为true
  6. !：用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。
  7. 位移运算符： <<、>>
  8. 赋值运算符： *=、/=、%=、+=、-=、 <<=、>>=、&=、^=、|=
  9. 其他运算符：
    参考地址：https://www.runoob.com/csharp/csharp-operators.html

判断

If else
    If(a==10){b=100;}
switch
   switch(a)
   {
   case 10:b=100;break;
   case 20:b=200;break;
   default:break
   }
? :
    a==10?b=100:b=10;
??
    a??0，相当于：if(a==null){a=0;}

循环

while：先判断，true执行，false终止执行
while(true){//方法内容}

do – while：先执行，再判断,true继续循环，false终止循环。
do{
//方法内容
} while (true);

for：for(1初试状态;2循环条件;3状态改变)
 for (int i = 0; i < length; i++){}
 for (; ; )代表无限循环

 foreach：foreach(数据类型 变量 in 数组或集合){//方法内容}
foreach(int a in array){//}

代码控制跳出当前循环或整个循环

  1. break：终止并跳出循环体。
  2. continue：终止当前循环，重新开始一个新的循环。
  3. goto：跳转到指定位置（不推荐使用）。
  4. return：跳出循环及其包含的函数。

异常处理

异常是在程序执行期间出现的问题。C# 中的异常是对程序运行时出现的特殊情况的一种响应，比如尝试除以零
异常提供了一种把程序控制权从某个部分转移到另一个部分的方式。C# 异常处理时建立在四个关键词之上的：try、catch、finally 和 throw

  1. try：一个 try 块标识了一个将被激活的特定的异常的代码块。后跟一个或多个 catch 块。
  2. catch：程序通过异常处理程序捕获异常。catch 关键字表示异常的捕获。可以有多个catch语句
  3. finally：finally 块用于执行给定的语句，不管异常是否被抛出都会执行。例如，如果您打开一个文件，不管是否出现异常文件都要被关闭。
  4. throw：当问题出现时，程序抛出一个异常。使用 throw 关键字来完成

using

定义一个范围，在范围结束时处理对象
在C#和其他托管语言中，没有自动、决定性的析构方式，而是有一个垃圾收集器，它会在未来的某个时刻释放资源。它是非决定性的，因为我们不能确定这个过程在什么时候发生。比如忘记关闭数据库连接可能会导致.NET可执行程序的各种问题。我们使用using子句确保实现
IDisposable接口的对象在退出块时立即被释放
当在某个代码段中使用了类的实例，而希望无论因为什么原因，只要离开了这个代码段就自动调用这个类实例的Dispose。 要达到这样的目的，
用try…catch来捕捉异常也是可以的，但用using也很方便。

using (Class1 cls1 = new Class1(), cls2 = new Class1())
{
  // the code using cls1, cls2
} // call the Dispose on cls1 and cls2

using(Sqlconnection con = new SqlConnection()) { 
     //代码执行块 
}

using 的简单的理解:括号里定义的con只在using{}这对括号内有效,出了后就没用了

Linq

语言集成查询（Language Integrated Query），是.net框架的扩展，它允许我们用SQL查询数据库的方式来查询数据的集合，使用它，你可以从数据库、程序对象的集合以及XML文档中查询数据
使用linq需要引用：using System.Linq;