总目录
文章目录
- 总目录
- 前言
- 一、C#简述
- 1 C#是什么？
- 2 .Net平台
- 3. C# 和.Net的关系
- 4. 集成开发环境（IDE）
- 二、控制台应用程序
- 1. 常用代码
- 2.注意事项
- 三、基础语法
- 1.编写C#代码注意事项
- 2.C#注释
- 2. 变量&标识符&关键字
- 4. 变量，字段和属性的区别
- 5.数据类型
- 1、值类型
- 2、引用类型
- 3、指针类型
- 6. 类型转换
- 1、隐式转换
- 2、显式转换
- 3、装箱与拆箱
- 7. 常量
- 8. 运算符
- 1、算数运算符
- 2、关系运算符
- 3、逻辑运算符
- 4、位运算符
- 5、赋值运算符
- 6、其他运算符
- 7、运算符优先级
- 9. 流程控制语句
- 1、选择结构
- 2、循环(loop)结构
- 10. 数组&字符串&结构体&枚举
- 11. C#关键字之修饰符
- 1、访问修饰符
- 2、其他修饰符
- 11. 方法
- 12. 类
- 1、类的基本内容
- 2、构造函数
- 3、析构函数（终结器）
- 4、内部类
- 13. 接口
- 14. 接口和抽象类
- 结语
前言
本文主要供自身复习使用，主要内容就是将C#基础知识进行大纲式针对性的梳理。
一、C#简述
1 C#是什么？
C# 是由微软（Microsoft）开发的一个简单的、现代的、通用的、面向对象的编程语言。
2 .Net平台
- 1 .Net框架（.Net Framework）
说到C#，那就必须说说.Net， C# 是 .Net 框架的一部分，且用于编写 .Net 应用程序。
.Net Framework是一个平台，主要可以开发Windows 桌面程序和Web应用。.Net 框架由一个巨大的代码库组成，用于 C# 等客户端语言。
我们常见的.Net 框架的组件：
- 公共语言运行库（Common Language Runtime - CLR）
- .Net 框架类库（.Net Framework Class Library）
- 公共语言规范（Common Language Specification）
- 通用类型系统（Common Type System）
- 元数据（Metadata）和组件（Assemblies）
- Windows 窗体（Windows Forms）
- ASP.Net 和 ASP.Net AJAX
- ADO.Net
- Windows 工作流基础（Windows Workflow Foundation - WF）
- Windows 显示基础（Windows Presentation Foundation）
- Windows 通信基础（Windows Communication Foundation - WCF）
- LINQ
-
2 .Net Core
.Net Core是微软继.Net Framework之后推出的可以跨平台的平台，可以用来创建运行在mac、Linux上的应用程序 -
3 .Net
完成了对.Net Framework和.Net Core的整合，是一个全新的强大的跨平台的平台
3. C# 和.Net的关系
.net就像是大舞台，C#就是其中的一个演员，演员可以使用平台提供的话筒（wpf）,用来唱歌（创建应用程序）；也可以使用平台提供的舞池（web）跳舞（创建web应用），C#只可以在这个大舞台上展示，但是这个舞台除了可以提供C#这个演员展示，还可以提供C++、Visual Basic、Jscript、COBOL 等演员展示
4. 集成开发环境（IDE）
目前主要使用的是Visual Studio 2022 (VS)
二、控制台应用程序
1. 常用代码
控制台应用程序是入门级的应用程序，一般常用的代码如下：
//输出
Console.Write();
//换行输出
Console.WriteLine();
//以上代码主要用于在控制台输出信息
//读取输入
Console.Read();
//读取当前行输入
Console.ReadLine();
//读取字符
Console.ReadKey();
//以上代码主要用于在控制读取输入的信息
//接受用户输入的字符串，以换行结束
string s=Console.ReadLine();
2.注意事项
- 控制台应用程序代码需要以Console.ReadLine()或Console.ReadKey()等结束，否则代码走完，控制台的窗体就会关闭
三、基础语法
1.编写C#代码注意事项
- C#代码是区分大小写的
- 所有的语句和表达式必须以分号（;）结尾。
2.C#注释
- //表示单行注释
- /* */ 表示多行注释
- 区域性注释
#region 区域注释名称
Console.WriteLine("区域性的注释");
#endregion
2. 变量&标识符&关键字
先看如下示例代码：
class Rectangle
{
// 成员变量
double length;
double width;
public double GetArea()
{
length = 3;
width = 2;
return length * width;
}
public void Display()
{
Console.WriteLine($"Length: {length}");
Console.WriteLine($"Width: {width}");
Console.WriteLine($"Area: {GetArea()}");
}
}
- 变量：变量是类的属性或数据成员，用于存储数据。如上面案例代码中， length 和 width 就是成员变量
- 标识符：标识符是用来识别类、变量、函数或任何其它用户定义的对象
标识符命名规则：
- 标识符必须以字母、下划线或 @ 开头，后面可以跟一系列的字母、数字（ 0 - 9 ）、下划线（ _ ）、@。
- 标识符中的第一个字符不能是数字。
- 标识符必须不包含任何嵌入的空格或符号，比如 ? - +! # % ^ & * ( ) [ ] { } . ; : " ’ / \。
- 标识符不能是 C# 关键字。除非它们有一个 @ 前缀。 例如，@if 是有效的标识符，但 if 不是，因为 if 是关键字。
- 标识符必须区分大小写。大写字母和小写字母被认为是不同的字母。
- 不能与C#的类库名称相同。
如上面的length、width、GetArea、Display 等变量或函数的名称都是标识符
- 关键字：关键字是 C# 编译器预定义的保留字。这些关键字不能用作标识符，但是，如果您想使用这些关键字作为标识符，可以在关键字前面加上 @ 字符作为前缀。‘
4. 变量，字段和属性的区别
首先我们写一个示例代码：
class UserInfo
{
private string _id;
private string _name;
public string Id
{
get { return _id; }
set { _id = value; }
}
public string Name
{
get { return _name; }
set { _name = value; }
}
}
上面的代码中：_id，_name 是字段，Id，Name 是属性，而_id，_name，Id，Name都是成员变量。
- 字段和属性都是变量，只不过是为了区分和数据安全做出了区分。
- 字段和属性是相对于类而言的，都是在类中定义的；而变量不局限在类中，可以定义在任何需要的地方
- 字段一般使用在类的内部，只可在当前类内部访问，属性一般供外部类访问；
- 字段一般来讲都是private，而属性则是对字段使用get和set 进行了封装，一般为public
- 字段值可以用作ref、out参数，而属性不能
5.数据类型
在C#中，有以下几种类型：
- 值类型
- 引用类型
- 指针类型（不常用）
1、值类型
值类型变量可以直接分配给一个值。它们是从类 System.ValueType 中派生的。值类型直接包含数据。
值类型又可分为：
| 分类 | 详情 | 备注 |
|---|---|---|
| 整型 | byte short ushort int uint long ulong | |
| 浮点型 | float double decimal | decimal多用于金钱计算上 |
| 字符型 | char | 每个字符背后都对应着一个ascii码，“A”为65；“a”为97；“0”为 48 |
| 布尔型 | bool | true/false |
| 可以为空的值类型 | 如 int? | 值为 null 的其他所有值类型的扩展 |
| 结构体 | struct | |
| 枚举 | enum | |
| 元组值类型 | 形如 （double,int）t1=(1.1,2); | 详见C#元组的使用 |
2、引用类型
引用类型不包含存储在变量中的实际数据，但它们包含对变量的引用。换句话说，它们指的是一个内存位置。使用多个变量时，引用类型可以指向一个内存位置。如果内存位置的数据是由一个变量改变的，其他变量会自动反映这种值的变化。内置的 引用类型有：object、dynamic 和 string。
| 分类 | 详情 | 备注 |
|---|---|---|
| 对象类型Object | 对象（Object）类型 是 C# 通用类型系统（Common Type System - CTS）中所有数据类型的终极基类 | 数组，集合，用户定义的类、接口、委托，object， |
| 动态类型Dynamic | 您可以存储任何类型的值在动态数据类型变量中。这些变量的类型检查是在运行时发生的。 | 动态类型与对象类型相似，但是对象类型变量的类型检查是在编译时发生的，而动态类型变量的类型检查是在运行时发生的。 |
| 字符串类型String | 字符串（String）类型 允许您给变量分配任何字符串值 | 这里需要注意的就是转义符的使用 |
- string相关的还有如下一个问题：“\”的使用与扩展
| 运用 | 详情 | 备注 |
|---|---|---|
| \ | 输出特殊字符 | 使用在字符串中，使用\则可以输出“”和\ 等字符 |
| \n | 换行 | 使用在字符串中，输出的时候会自动换行 |
| \t | 制表符 | 使用在字符串中，输出的时候会自动对齐，隔开 |
| \b | 去掉上一个字符串 | 如果需要输出\b则需进行转义 |
- @和\的使用
string path1 = "E:\\MyCode\\my-study";
string path2 = @"E:\MyCode\my-study";
Console.WriteLine($"path1:{path1}-------path2:{path2}");
由上可知，当前我们使用@进行字符串转义的话，我们可以避免使用“\”逐个的进行转移。
3、指针类型
指针类型变量存储另一种类型的内存地址。C# 中的指针与 C 或 C++ 中的指针有相同的功能。
声明指针类型的语法：type* identifier; 如：char* cptr; int* iptr;
6. 类型转换
类型转换就是将数据从一种类型转换为另一种类型，类型转换有两种形式：
1、隐式转换
这些转换是 C# 默认的以安全方式进行的转换, 不会导致数据丢失。将类型较小的数据存放到较大的变量中
2、显式转换
显式转换需要强制转换运算符，而且强制转换会造成数据丢失。将类型较大的数据存放在较小的变量中
案例代码如下：
static void Main(string[] args)
{
int num1 = 1;
long num2 = num1;//隐式类型转换
//强制类型转换：(数据类型)数据
double num3 = 3.56;
int num4 = (int)num3;
int num5 = Convert.ToInt32(num3);
//Convert 对象转换
Console.WriteLine($"3.56强制转换后的结果：{num4}\n3.56使用Convert对象转换的结果：{num5}");
Console.ReadLine();
}
由上面的代码案例可以清晰的了解数据的转换，另外还可从上面的案例可知，显式转换存在两种形式，一种是强制类型转换，这种方式对于浮点型不会进行四舍五入，直接将小数点后面的数据舍弃；另一种是使用Convert对象进行转换，这种方式则会对浮点型数据进行四舍五入的计算，然后进行转换。
3、装箱与拆箱
- 装箱是将值类型转换为引用类型； 拆箱就是将引用类型转换为值类型
示例代码如下：
static void Main(string[] args)
{
//装箱：值类型转换为引用类型
int num = 111;
object obj = num;
Console.WriteLine($"obj = {obj}"); //obj = 111
//拆箱：引用类型转换为值类型
int nnum = 222;
object oobj=nnum;
int result = (int)oobj;
Console.WriteLine($"result = {result}");//result = 222
//【注意】：被装过箱的对象才能被拆箱
}
我们知道平常写代码的时候要尽量的避免装箱和拆箱，但是为什么要这样呢？要搞清白这些啊，那就必须知道，什么是堆和栈以及装箱和拆箱的过程
- 堆和栈
堆栈简单来说，就是计算机存储数据的一个数据模型。
模型分为堆和栈两部分，栈中主要存放一些简单结构的数据和复杂数据的索引，堆中存储复杂数据结构的数据内容。简单的数据结构就是值类型，复杂数据结构就是引用类型
- 装箱和拆箱的过程
装箱过程：
①先在堆上为新生成的引用对象分配内存，
②然后将值类型的数据copy到刚分配的内存中，
③最后返回内存的地址（引用对象在栈中会存储这个内存的地址，相当于数据的索引）。
在装箱的过程中分配内存和数据复制都是消耗效能的操作
拆箱过程：
①先检查当前的引用类型数据是否可以转换为目标值类型数据
（例如，string str="123"可以转换为Int ,而str="asd"不可以）
②复制堆中的数据的值并将复制的值放到目标数据所在的存储位置
拆箱过程有类型检查和复制数据两个操作，其中复制数据耗费性能
由此我们可知，装箱和拆箱比较影响程序运行的性能，所以我们需要尽量的避免此类操作！
7. 常量
常量是固定值，程序执行期间不会改变。常量可以是任何基本数据类型，比如整数常量、浮点常量、字符常量或者字符串常量，还有枚举常量。
常量可以被当作常规的变量，只是它们的值在定义后不能被修改。
详情可见：C#常量，这里重点说一下定义常量，常量是使用const关键字来定义的，示例如下：
public const string URL = "www.xxxx.com";
public const int num = 999;
常量扩展：
静态常量（编译时常量）const 和动态常量（运行时常量）readonly
静态常量在编译时就确定了值，必须在声明时就进行初始化且之后不能进行更改，可在类和方法中定义。定义方法如下：
const double a=3.14；// 正确声明常量的方法
const int b; // 错误，没有初始化
动态常量在运行时确定值，只能在声明时或构造函数中初始化，只能在类中定义。定义方法如下：
class Program
{
readonly int a=1; // 声明时初始化
readonly int b; // 构造函数中初始化
Program()
{
b=2;
}
static void Main()
{
}
}
8. 运算符
运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C# 有丰富的内置运算符，分类如下：
- 算术运算符
- 关系运算符
- 逻辑运算符
- 位运算符
- 赋值运算符
- 其他运算符
1、算数运算符
| 运算符 | 描述 | 备注 |
|---|---|---|
| + | 将两个操作数相加 | 当字符串和数值类使用 + 则是拼接字符串 |
| - | 将两个操作数相减 | |
| * | 将两个操作数相乘 | |
| / | 将两个操作数相除 | 当两个操作数均为整数的时候，结果取商； 当两边有一个为浮点型的时候，做精确运算 |
| % | 模运算符，整除后取余数 | 如 21%10=1 |
| ++ | 自增运算符，整数值增加1 | 注意：当自增运算符在前，则先自增，然后再使用自增后的赋值； 当自增运算符在后，则先赋值，然后再自增 |
| - - | 自减运算符，整数值减去1 | 同上 |
注意：在char类型参与到算数运算时，会自动转化为ascii码10进制的值参与运算
class Program
{
static void Main(string[] args)
{
int a = 1;
int b;
// a++ 先赋值再进行自增运算
b = a++;
Console.WriteLine("a = {0}", a);
Console.WriteLine("b = {0}", b);
Console.ReadLine();//结果a=2,b=1
// ++a 先进行自增运算再赋值
a = 1; // 重新初始化 a
b = ++a;
Console.WriteLine("a = {0}", a);
Console.WriteLine("b = {0}", b);
Console.ReadLine();//结果a=2,b=2
// a-- 先赋值再进行自减运算
a = 1; // 重新初始化 a
b= a--;
Console.WriteLine("a = {0}", a);
Console.WriteLine("b = {0}", b);
Console.ReadLine();//结果a=0,b=1
// --a 先进行自减运算再赋值
a = 1; // 重新初始化 a
b= --a;
Console.WriteLine("a = {0}", a);
Console.WriteLine("b = {0}", b);
Console.ReadLine();//结果a=0,b=0
}
}
2、关系运算符
| 运算符 | 描述 |
|---|---|
| == | 检查两个操作数的值是否相等，如果相等则条件为真 |
| != | 检查两个操作数的值是否相等，如果不相等则条件为真。 |
| > | 检查左操作数的值是否大于右操作数的值，如果是则条件为真 |
| < | 检查左操作数的值是否小于右操作数的值，如果是则条件为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 |
注：关系运算符的运算结果均是bool ，常运用于判断语句中
3、逻辑运算符
| 运算符 | 描述 |
|---|---|
| || | 或 运算符，当两个操作数均为false ,则结果为false,其余均为true |
| && | 与 运算符, 当两个操作数均为true,则结果为true,其余均为false |
| ! | 非 运算符，取反 |
注：
① 逻辑运算符的短路效果，当运算符的左边的结果对整个表达式结果起了决定性的作用的时候，运算符右边的表达式就不会运行。
如：当&&运算符左边为false的时候，此时无论运算符右边是什么，结果都为false,那么右边表达式就不会运行。
② 当单独使用| 和& 就不会产生短路的效果，即使左边已经起了决定性作用，右边仍会运行。
4、位运算符
| 运算符 | 描述 |
|---|---|
| & | 与 位运算符，当两个操作数均为1 ,则结果为1,其余均为0 |
| | | 或 位运算符, 当两个操作数均为0,则结果为0,其余均为1 |
| ^ | 异或 运算符，当两个操作均为0或1，则结果为0，其余结果为1 |
| ~ | 按位取反 运算符，具有翻转位的效果，可将0变1，1变0 |
| << | 二进制左移运算符。左操作数的值向左移动右操作数的位数 |
| >> | 二进制右移运算符。左操作数的值向右移动右操作数指定的位数。 |
辅助理解的案例代码如下：
static void Main(string[] args)
{
//60 和13 转换位二进制分别是111100 和 1101 ，不足8位【前面】使用0补足
int a = 60; /* 60 = 0011 1100 */
int b = 13; /* 13 = 0000 1101 */
int c = 0;
c = a & b;
// a 0011 1100
// b 0000 1101
//----------------- 根据&运算符规则：只有均为1的时候，结果才为1，否则均为0
// c 0000 1100===>转换为十进制 则是12
Console.WriteLine("Line 1 - c 的值是 {0}", c);
c = a | b;
// a 0011 1100
// b 0000 1101
//----------------- 根据|运算符规则：只有均为0的时候，结果才为0，否则均为1
// c 0011 1101===>转换为十进制 则是61
Console.WriteLine("Line 2 - c 的值是 {0}", c);
c = a ^ b;
// a 0011 1100
// b 0000 1101
//----------------- 根据^运算符规则：只有均为0或1的时候，结果才为0，否则均为1
// c 0011 0001===>转换为十进制 则是49
Console.WriteLine("Line 3 - c 的值是 {0}", c);
c = ~a; /*-61 = 1100 0011 */
// a 0011 1100
//取反----------------- 根据~运算符规则：将0变1 ，1变0
// c 1100 0011===>转换为十进制 则是-61
Console.WriteLine("Line 4 - c 的值是 {0}", c);
c = a << 2;
// a 0011 1100
//左移----------------- 0011 1100 向左移动两位则将前面两位00 移掉了，然后后面补足两位00
// c 1111 0000===>转换为十进制 则是240
Console.WriteLine("Line 5 - c 的值是 {0}", c);
c = a >> 2;
// a 0011 1100
//右移----------------- 0011 1100 向右移动两位则将后面两位00 移掉了，然后前面补足两位00
// c 0000 1111===>转换为十进制 则是15
Console.WriteLine("Line 6 - c 的值是 {0}", c);
Console.ReadLine();
}
5、赋值运算符
6、其他运算符
这里包括有 is,as ,?: 等运算符，会在后续专题博客中详细介绍，这里暂时不做展开~
7、运算符优先级
- 优先级大体上是：算数运算符> 关系运算符>逻辑运算符>赋值运算符
- 算数运算中：当有括号时，先计算括号内的，然后前运算符，再乘除模，再加减，最后后运算符
- 逻辑运算符中：当同时出现或运算符和与运算符，先计算与 运算符，然后计算或运算符
辅助理解的案例代码如下：
//算术运算符和赋值运算符的优先级：
int a = 10, b = 5, c = 2;
a += b * c; // 先计算乘法，再执行加法赋值
Console.WriteLine(a); // 输出20
//逻辑运算符的优先级：
bool a = true, b = false, c = true;
bool result = a || b && c; // 先计算与运算，再计算或运算
Console.WriteLine(result); // 输出true
//条件运算符的优先级：
int a = 10, b = 5;
string result = a > b ? "a大于b" : "a不大于b"; // 先判断大小关系，再执行条件语句
Console.WriteLine(result); // 输出"a大于b"
9. 流程控制语句
1、选择结构
- if else
//第一种：只有if,没有else
if (num>15)
{
//...
}
//第二种：有if else
if (num > 15)
{
//...
}
else
{
//...
}
//第三种：多种判断if else if ...else
if (num>15)
{
//...
}
else if (num>0)
{
//...
}
else
{
//...
}
- switch
一个 switch 语句允许测试一个变量等于多个值时的情况，算是if else 在某一层面上的进阶版。
switch 语句中的表达式 必须是一个整型或枚举类型，或者是一个 class 类型，其中 class 有一个单一的转换函数将其转换为整型或枚举类型
运用switch的典型案例：输入年月，得出该月的天数
static void Main(string[] args)
{
Console.WriteLine("请输入年份：");
int year = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("请输入月份：");
int month = Convert.ToInt32(Console.ReadLine());
int day = 0;//定义天数
switch (month)
{
//大月
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12: day = 31; break;
//小月
case 4:
case 6:
case 9:
case 11: day = 30; break;
case 2:
//主要是需要对二月进行判断，是否是闰月
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
{
//满足条件，则为闰年中的闰月，输出29天
day = 29;
break;
}
else
{
day = 28;
break;
}
default:
Console.WriteLine("请输入正确的月份数字！");
break;
}
Console.WriteLine($"{year}年{month}月有{day}天");
Console.ReadLine();
}
- 三元运算符?:
x?y:z 表示如果表达式 x 为 true，则返回 y；如果 x 为 false，则返回 z，是 if{}else{} 的简单形式。
static void Main(string[] args)
{
int a=11;
int b=22;
int c = a > b ? a : b;
Console.WriteLine($"c={c}");
Console.ReadLine();//结果: c=22
}
2、循环(loop)结构
循环语句允许我们多次执行一个语句或语句组。
- for
简单使用案例：
for (int i = 0; i < 10; i++)
{
Console.WriteLine($"i={i}");
}
Console.ReadLine();
当我们需要无限循环的时候，只需要如下使用：
//将各项条件均省略，程序会默认为true,一直运行
for (; ;)
{
Console.WriteLine("我是无限循环");
}
常见题目：百钱百鸡，兔子生小兔子（斐波拉且数列）,猜价格（价格截半法）
static void Main(string[] args)
{
//某人有100元钱，要买100只鸡。
//公鸡5元钱一只，母鸡3元钱一只，小鸡一元钱3只。
//编程计算可买到公鸡，母鸡，小鸡各为多少只？
//首先从循环次数上将，从公鸡开始循环次数最少
//首先100元最多买20只公鸡,
for (int i = 0; i < 20; i++)//i为公鸡数
{
//j为母鸡数
for (int j = 0; j < 33; j++)
{
if ((100-i-j)%3==0&&i*5+j*3+(100-i-j)/3==100)
{
Console.WriteLine($"公鸡={i},母鸡={j},小鸡={100-i-j}");
}
}
}
Console.ReadLine();
}
static void Main(string[] args)
{
//程序循环猜商品价格
//首先定义价格范围
int max = 1000;
int min = 1;
//定义随机数
Random rnd = new Random();
//定义一个标记，一会使用goto重新从标记位执行代码，方便测试使用
Flag:
//随机一个正确价格
int correctPrice = rnd.Next(min,max+1);
Console.WriteLine($"正确价格是：{correctPrice}");
//开始猜价格
for (int i = 1;; i++)
{
int price = (min + max) / 2;
if (correctPrice > price)
{
Console.WriteLine($"第{i}次猜测的价格：{price}，低了");
min = price + 1;
}
else if (correctPrice < price)
{
Console.WriteLine($"第{i}次猜测的价格：{price}，高了");
max = price - 1;
}
else
{
Console.WriteLine($"恭喜你，第{i}次猜测的价格：{price}，正确");
break;
}
}
if (Console.ReadKey().KeyChar=='A')
{
min = 1;
max = 1000;
goto Flag;
}
Console.ReadLine();
}
注意：理解案例中的for循环的运用以及价格截半的精髓（二分查找），另外案例中有个goto关键字的运行和使用
- foreach
使用foreach可以迭代数组或者一个集合对象。
static void Main(string[] args)
{
string[] arrStr = new string[] { "ab", "cd", "ef" };
foreach (var item in arrStr)
{
Console.WriteLine($"遍历数组-当前项{item}");
}
Console.ReadLine();
}
foreach 迭代遍历只能是正向的，不可逆的，逐个的遍历数组中的每一个元素；迭代遍历时，被迭代的数组的元素不能更改；迭代遍历的速度远快于for循环。
- while 和do…while
简单使用案例：
static void Main(string[] args)
{
/* 局部变量定义 */
int a = 10;
/* while 循环执行 */
while (a < 20)//只要条件为true,也可无限循环下去
{
Console.WriteLine("a 的值： {0}", a);
a++;
}
Console.ReadLine();
}
static void Main(string[] args)
{
/* 局部变量定义 */
int a = 10;
/* do 循环执行 */
do
{
Console.WriteLine("a 的值： {0}", a);
a++;
} while (a < 20);
Console.ReadLine();
}
先执行do，然后判断while的条件，当条件为true的时候才进入循环；相较于while循环，do…while无论是否满足循环条件，都会先执行一次业务代码。
- 循环控制语句
循环控制语句更改执行的正常序列。当执行离开一个范围时，所有在该范围中创建的自动对象都会被销毁
| 控制语句 | 描述 |
|---|---|
| break | 终止 loop 或 switch 语句，程序流将继续执行紧接着 loop 或 switch 的下一条语句。 简单说：在loop中使用break将跳出整个循环 |
| continue | 跳出本轮循环,开始下一轮循环 |
10. 数组&字符串&结构体&枚举
1、数组
数组是一个存储相同类型元素的固定大小的顺序集合。数组是用来存储数据的集合，通常认为数组是一个同一类型变量的集合。
数组中重要的三个组成部分就是：元素（数组中的每一项都是一个元素），长度（数组的长度），索引（从0开始）
使用案例：
//声明数组
int[] nums;
//初始化数组
double[] scores=new double[10];
//赋值给数组--逐个元素赋值
double[] doubles=new double[10];
doubles[0] = 10.1;
doubles[1] = 10.2;
//初始化并赋值给数组,可省略数组长度
double[] doubles1 = new double[]{10.1,10.2 };
//简化赋值过程
double[] doubles2 = { 10.1, 10.2, 10.3 };
//访问数据元素,通过索引
double num = doubles2[0];
//不过大多时候，都是使用for 和foreach 来操作数据
for (int i = 0; i < doubles2.Length; i++)
{
Console.WriteLine($"元素doules[{i}]={doubles2[i]}");
}
Console.ReadLine();
数组扩展内容见：C#数组详解
2、字符串
在 C# 中，您可以使用字符数组来表示字符串，但是，更常见的做法是使用 string 关键字来声明一个字符串变量。string 关键字是 System.String 类的别名。
关于字符串的详细内容可见：C#字符串使用详解
3、结构体
在 C# 中，结构体是值类型数据结构。它使得一个单一变量可以存储各种数据类型的相关数据。struct 关键字用于创建结构体。
结构体特点如下：
- 结构可带有方法、字段、索引、属性、运算符方法和事件。
- 结构可定义构造函数，但不能定义析构函数。但是，您不能为结构定义无参构造函数。无参构造函数(默认)是自动定义的，且不能被改变。
- 与类不同，结构不能继承其他的结构或类。
- 结构不能作为其他结构或类的基础结构。
- 结构可实现一个或多个接口。
- 结构成员不能指定为 abstract、virtual 或 protected。
- 当您使用 New 操作符创建一个结构对象时，会调用适当的构造函数来创建结构。与类不同，结构可以不使用 New 操作符即可被实例化。
- 如果不使用 New 操作符，只有在所有的字段都被初始化之后，字段才被赋值，对象才被使用。
另外结构体与类的区别
- 类是引用类型，结构是值类型。
- 结构不支持继承。
- 结构不能声明默认的构造函数。
- 结构体中声明的字段无法赋予初值，类可以:
- 结构体的构造函数中，必须为结构体所有字段赋值，类的构造函数无此限制:
代码如下：
using System;
using System.Text;
struct Books
{
private string title;//结构体中声明的字段无法赋予初值，类可以:
private string author;
private string subject;
private int book_id;
public void setValues(string t, string a, string s, int id)
{
title = t;
author = a;
subject = s;
book_id =id;
}
public void display()
{
Console.WriteLine("Title : {0}", title);
Console.WriteLine("Author : {0}", author);
Console.WriteLine("Subject : {0}", subject);
Console.WriteLine("Book_id :{0}", book_id);
}
};
public class testStructure
{
public static void Main(string[] args)
{
Books Book1 = new Books(); /* 声明 Book1，类型为 Books */
Books Book2 = new Books(); /* 声明 Book2，类型为 Books */
/* book 1 详述 */
Book1.setValues("C Programming",
"Nuha Ali", "C Programming Tutorial",6495407);
/* book 2 详述 */
Book2.setValues("Telecom Billing",
"Zara Ali", "Telecom Billing Tutorial", 6495700);
/* 打印 Book1 信息 */
Book1.display();
/* 打印 Book2 信息 */
Book2.display();
Console.ReadKey();
}
}
4、枚举
枚举是一组命名整型常量。枚举类型是使用 enum 关键字声明的。
C# 枚举是值类型。换句话说，枚举包含自己的值，且不能继承或传递继承。
- 枚举是值类型的数据，只能定义值类型的内容，枚举是将值进行包装
- enum 默认自带public static ,无需实例化
- enum和int的值是相互参照的，enum中的值与int转换的时候，默认按照0，1，2的顺序排序，也可以自行定义enum中每一项枚举的值
使用案例如下：
//声明enum变量,不定义各项的值，默认
enum Days { Sun, Mon, Tue, Wed, Thu, Fri, Sat };
//声明enum变量,自定义各项的值
enum Day
{
Sun = 10,Mon = 20, Tue = 30, Wed = 40, Thu = 50, Fri = 60, Sat = 70,
}
//混合情况,第 n 个符号值与第 n-1 个有关，如：此时Mon为 11
enum WeekDay
{
Sun = 10, Mon, Tue, Wed = 40, Thu, Fri, Sat,
}
class Program
{
static void Main(string[] args)
{
//默认情况下，枚举中的值与int相互转换，从0开始依次增加
int x = (int)Days.Sun;
int y = (int)Days.Fri;
Console.WriteLine("Sun = {0}", x);//Sun = 0
Console.WriteLine("Fri = {0}", y);//Sun = 5
Day day = (Day)20;//将int值转化为枚举
Console.WriteLine(day.ToString());//将枚举转换成字符串，结果：Mon
//将字符串转化为枚举
Day day1 = (Day)Enum.Parse(typeof(Day), "Mon");//如果Mon在不在枚举内，这种情况下会报错
//混合情况,第 n 个符号值与第 n-1 个有关。
int dy = (int)WeekDay.Mon;
int dx= (int)WeekDay.Tue;
int dz= (int)WeekDay.Sat;
Console.WriteLine("WeekDay\tMon = {0}", dy);//WeekDay Mon = 11
Console.WriteLine("WeekDay\tTue = {0}", dx);//WeekDay Tue = 12
Console.WriteLine("WeekDay\tSat = {0}", dz);//WeekDay Sat = 43
Console.ReadLine();
}
}
关于枚举的进阶用法，详情可见：C#枚举进阶用法
11. C#关键字之修饰符
C#中的修饰符都是关键字
1、访问修饰符
C# 封装根据具体的需要，设置使用者的访问权限，并通过 访问修饰符 来实现。
一个 访问修饰符 定义了一个类成员的范围和可见性。
- protected internal 是 protected 和 internal 的并集，满足任何一个即可
- 可访问性排序：public > internal > protected > private
2、其他修饰符
常用修饰符还有：
static、abstract、virtual、override、sealed、readonly、extern、event、const、async、in、new、out
不常用的修饰符有：unsafe、volatile
这里会对部分修饰符的使用进行整理汇总，其余部分如果在后续深入的过程中涉及到也会逐步整理出来
- static 静态的
- 使用 static 修饰符可声明属于类型本身而不是属于特定对象的静态成员。 static 修饰符可用于声明 static 类。 在类、接口和结构中，可以将 static 修饰符添加到字段、方法、属性、运算符、事件和构造函数。 static 修饰符不能用于索引器或终结器。
- 如果 static 关键字应用于类，则类的所有成员都必须为 static。
- 程序默认就创建实例，因此static对象无需实例化，直接使用；
- 类中静态变量，它只是定义在当前类中，但是本身不属于类，它早已经实例化，因此调用的时候直接使用类名 + 点（.）运算符进行调用
- 使用过多的静态对象，会比较消耗内存，因为它默认就实例化了，已经占好了内存
使用案例如下：
class UserInfo
{
private string _id;
//静态变量
public static string Info;
//普通变量
public string Id
{
get { return _id; }
set { _id = value; }
}
}
class Program
{
static void Main(string[] args)
{
//使用静态变量，无需实例化，直接通过类名.
string info = UserInfo.Info;
//使用普通变量,需要先实例化才可以
string id = new UserInfo().Id;
Console.ReadLine();
}
}
- abstract 抽象的
abstract 修饰符可用于类、方法、属性、索引和事件
抽象方法
- 抽象方法是隐式的虚拟方法，abstract方法默认自带virtual属性
- 只有抽象类中才允许抽象方法声明。
- 由于抽象方法声明不提供实际的实现，因此没有方法主体；方法声明仅以分号结尾，且签名后没有大括号 ({ })。
- 在抽象方法声明中使用 static 或 virtual 修饰符是错误的。
抽象方法如下：
public abstract void GetInfo();
//实现由方法 override 提供，它是非抽象类的成员。
抽象类
- 抽象类不能实例化。
- 必须有子类继承
- 派生自抽象类的非抽象类，必须包含全部已继承的抽象方法和访问器的实际实现。
（简单说：子类必须实现抽象父类的所有抽象方法）
- 在抽象方法声明中使用 static 或 virtual 修饰符是错误的。
- sealed 封闭的
通常用于实现第三方类库时不想被客户端继承，或用于没有必要再继承的类以防止滥用继承造成层次结构体系混乱。恰当的使用sealed修饰符也可以在一定程度上提高运行效率，因为不用考虑继承类会重写该成员。
sealed的作用
- 在类声明中使用sealed可防止其它类继承此类；
- 在方法声明中使用sealed修饰符可防止子类重写此方法。
- sealed修饰符主要用于防止非有意的派生，但是它还能促使某些运行时优化
- 密封类中永远不可能有任何派生类。如果密封类实例中存在虚拟成员函数，该成员函数可以转化为非虚的，函数修饰符virtual 不再生效。
11. 方法
首先在C#中对于函数和方法并没有明确的定义区分，本质上是一样的，只是叫法不同；某些情况下，如我们会更习惯叫构造函数，而不叫构造方法。
熟悉方法无非两点：定义方法和调用方法。
定义方法：
<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
Method Body
}
访问修饰符 方法修饰符 返回类型 函数名( 参数列表 )
{
函数体;
}
//实例如下：
public void GetInfo(string id)
{
//....
}
调用方法：
调用：通过方法名调用方法，如
Rectangle rectangle = new Rectangle();
//Display即是矩形对象中的方法，通过方法名调用即可
rectangle.Display();
12. 类
1、类的基本内容
- 当你定义一个类时，你定义了一个数据类型的蓝图。
- 构成类的方法和变量称为类的成员。
- 访问标识符 指定了对类及其成员的访问规则。如果没有指定，则使用默认的访问标识符。类的默认访问标识符是 internal，成员的默认访问标识符是 private。
- 如果要访问类的成员，你要使用点（.）运算符。点运算符链接了对象的名称和成员的名称。
2、构造函数
- 类的 构造函数 是类的一个特殊的成员函数，当创建类的新对象时执行。
- 构造函数提供了一种对象的多种创建方式。
- 构造函数的名称与类的名称完全相同，它没有任何返回类型。
认识一下构造函数，代码如下：
class Student
{
public string Name { get; set; }
public double Score { get; set; }
//构造函数，没有任何返回类型
public Student()
{
}
}
构造函数分为：默认/隐式构造函数 和参数化构造函数
- 默认构造函数，没有参数列表，没有代码，默认隐藏不显示，有且仅有一个
- 参数化构造函数，手工定义，只要参数列表不同，可以有N个
- 如果类中定义了一个参数化的构造函数，默认会把隐式的构造函数替换掉
- 如果需要支持或者用到 无参数的构造函数，就需要定义起来
class Student
{
public string Name { get; set; }
public double Score { get; set; }
//默认构造函数，没有任何返回类型
public Student()
{
}
//参数化构造函数
public Student(string name)
{
}
//参数化构造函数
public Student(string name, double score)
{
}
}
3、析构函数（终结器）
终结器（以前称为析构函数）用于在垃圾回收器收集类实例时执行任何必要的最终清理操作。 在大多数情况下，通过使用 System.Runtime.InteropServices.SafeHandle 或派生类包装任何非托管句柄，可以免去编写终结器的过程。
- 无法在结构中定义终结器。 它们仅用于类。
- 一个类只能有一个终结器。
- 不能继承或重载终结器。
- 不能手动调用终结器。 可以自动调用它们。
- 终结器不使用修饰符或参数。
class Car
{
~Car() // finalizer
{
// cleanup statements...
}
}
public class Destroyer
{
public override string ToString() => GetType().Name;
~Destroyer() => Console.WriteLine($"The {ToString()} finalizer is executing.");
}
不应使用空终结器。 如果类包含终结器，会在 Finalize 队列中创建一个条目。 此队列由垃圾回收器处理。 当 GC 处理队列时，它会调用每个终结器。 不必要的终结器（包括空的终结器、仅调用基类终结器的终结器，或者仅调用条件性发出的方法的终结器）会导致不必要的性能损失。
程序员无法控制何时调用终结器，因为这由垃圾回收器决定。 垃圾回收器检查应用程序不再使用的对象。 如果它认为某个对象符合终止条件，则调用终结器（如果有），并回收用来存储此对象的内存。 可以通过调用 Collect 强制进行垃圾回收，但多数情况下应避免此调用，因为它可能会造成性能问题。
4、内部类
顾名思义就是类中定义的类。
内部类的目的 是为了隐藏一个类中的类 ，保护内部的类
13. 接口
接口本身并不实现任何功能，它只是和声明实现该接口的对象订立一个必须实现哪些行为的契约。接口更像是抽象方法的一个集合
interface IDataLink
{
void Contect();
void DisContect();
}
- 1 抽象类是类，可以定义变量，有构造函数，使用abstract 是禁止实例
- 2 接口不是类，里面可以定义变量，但是必须赋值，因为他只是抽象方法集合，所以必须自己赋初始值 实例化
- 3 接口中方法默认都是public abstract
14. 接口和抽象类
相同点：
- 1、 都不能实例化
- 2、 实现类 都必须实现所有抽象方法
不同点：
- 1 接口是多重继承，抽象类是单一继承
- 2 一个类只能继承一个父类，但是可以实现n个接口
- 3 抽象类是类，接口不是类（抽象方法的集合）
其余涉及到面向对象编程的内容，如：封装，继承，多态等将在下一篇博客中进行展开~
结语
以上就是本文的内容，希望以上内容可以帮助到您，如文中有不对之处，还请批评指正。
参考资料：
C# 语言介绍
C#教程
装箱与拆箱
![Mysql问题：[Err] 1055 - Expression #1 of ORDER BY clause is not in GROUP BY clause](https://img-blog.csdnimg.cn/1066a58e1b5d4b119df843e604651406.png)
