基本语法-Hello World
using System;//引入命名空间
// 一个 namespace 里包含了一系列的类
namespace _001_开始
{
//这是Program类
class Program
{
// 这是Main方法
static void Main(string[] args)
{
Console.WriteLine("Hello,");
Console.WriteLine("World!");
Console.WriteLine("Hello\t, World\n!");
}
}
}- C# 是大小写敏感的。
- 所有的语句和表达式必须以分号（;）结尾。
- 程序的执行从 Main 方法开始。
- 与 Java 不同的是，文件名可以不同于类的名称。
using
在任何 C# 程序中的第一条语句都是：
using System;using 关键字用于在程序中包含命名空间。一个程序可以包含多个 using 语句。
注释
注释是用于解释代码。编译器会忽略注释的条目。在 C# 程序中，多行注释以 /* 开始，并以字符 */ 终止，如下所示：
/* 这个程序演示
C# 的注释
使用 */单行注释是用 // 符号表示。例如：
// 这一行是注释 标识符
标识符是用来识别类、变量、函数或任何其它用户定义的项目。在 C# 中，类的命名必须遵循如下基本规则：
- 标识符必须以字母、下划线或 @ 开头，后面可以跟一系列的字母、数字（ 0 - 9 ）、下划线（ _ ）、@。
- 标识符中的第一个字符不能是数字。
- 标识符必须不包含任何嵌入的空格或符号，比如 ? - +! # % ^ & * ( ) [ ] { } . ; : " ' / \。
- 标识符不能是 C# 关键字。除非它们有一个 @ 前缀。 例如，@if 是有效的标识符，但 if 不是，因为 if 是关键字。
- 标识符必须区分大小写。大写字母和小写字母被认为是不同的字母。
- 不能与C#的类库名称相同。
变量
C# 中提供的基本的值类型大致可以分为以下几类：
| 类型 | 举例 |
|---|---|
| 整数类型 | sbyte、byte、short、ushort、int、uint、long、ulong 和 char |
| 浮点型 | float, double |
| 十进制类型 | decimal |
| 布尔类型 | true 或 false 值，指定的值 |
| 空字符串 | string |
| 空类型 | 可为空值的数据类型 |
int i, j, k;
char c, ch;
float f, salary;
double d;可以在变量定义时进行初始化：
int i = 100;下面的实例，使用了各种类型的变量：
short a;
int b ;
double c;
a = 10;
b = 20;
c = a + b;
Console.WriteLine("a = {0}, b = {1}, c = {2}", a, b, c);
//a = 10, b = 20, c = 30变量的命名规则：
- 变量名必须以字母或下划线开头。
- 变量名区分大小写。
- 避免使用关键字作为变量名。
int a = 3, b = 8;
Console.WriteLine(a + b);// 11
Console.WriteLine("a + b");// a+b
Console.WriteLine(a + "+" + b);// 3+8
Console.WriteLine("a+b" + a + b);// a+b38
Console.WriteLine("a+b" + (a + b));// a+b11每⼀个字符在内存中存储的时候其实都是⼀个整数，遵循ASCII表
char c = 'a';
int b = a;
Console.WriteLine(a);
Console.WriteLine(b);
字符串的前面可以加 @（称作"逐字字符串"）将转义字符（\）当作普通字符对待，如果需要在字符串内使用引号，可以使用两个引号来作为一个引号
Console.WriteLine("c:\\a\\b\\c");
Console.WriteLine(@"c:\a\b\c");
Console.WriteLine(@"A:""asd"" ");类型转换
隐式类型转换：将一个较小范围的数据类型转换为较大范围的数据类型时，编译器会自动完成类型转换，这种转换不会导致数据丢失
byte b = 10;
int i = b; // 隐式转换，不需要显式转换
int intValue = 42;
long longValue = intValue; // 隐式转换，从 int 到 long显式转换（强制类型转换）：将一个较大范围的数据类型转换为较小范围的数据类型时，或者将一个对象类型转换为另一个对象类型时，需要使用强制类型转换符号进行显示转换，强制转换会造成数据丢失。
int i = 10;
byte b = (byte)i; // 显式转换，需要使用强制类型转换符号
double doubleValue = 3.14;
int intValue = (int)doubleValue; // 强制从 double 到 int，数据可能损失小数部分
int intValue = 42;
float floatValue = (float)intValue; // 强制从 int 到 float，数据可能损失精度内置的类型转换方法：
| 序号 | 方法 & 描述 |
|---|---|
| ToBoolean | 如果可能的话，把类型转换为布尔型。 |
| ToByte | 把类型转换为字节类型。 |
| ToChar | 如果可能的话，把类型转换为单个 Unicode 字符类型。 |
| ToDateTime | 把类型（整数或字符串类型）转换为 日期-时间 结构。 |
| ToDecimal | 把浮点型或整数类型转换为十进制类型。 |
| ToDouble | 把类型转换为双精度浮点型。 |
| ToInt16 | 把类型转换为 16 位整数类型。 |
| ToInt32 | 把类型转换为 32 位整数类型。 |
| ToInt64 | 把类型转换为 64 位整数类型。 |
| ToSbyte | 把类型转换为有符号字节类型。 |
| ToSingle | 把类型转换为小浮点数类型。 |
| ToString | 把类型转换为字符串类型。 |
| ToType | 把类型转换为指定类型。 |
| ToUInt16 | 把类型转换为 16 位无符号整数类型。 |
| ToUInt32 | 把类型转换为 32 位无符号整数类型。 |
| ToUInt64 | 把类型转换为 64 位无符号整数类型。 |
int i = 75;
float f = 53.005f;
double d = 2345.7652;
bool b = true;
Console.WriteLine(i.ToString());
Console.WriteLine(f.ToString());
Console.WriteLine(d.ToString());
Console.WriteLine(b.ToString());输入数据
System 命名空间中的 Console 类提供了一个函数 ReadLine()，用于接收来自用户的输入，并把它存储到一个变量中。
String str=Console.ReadLine();
Console.WriteLine(str+"-");转换为整数
String str=Console.ReadLine();
int strIn=Convert.ToInt32(str);
Console.WriteLine(str+"-");int e =Convert.ToInt32(Console.ReadLine());变量作用域
变量的作用域定义了变量的可见性和生命周期。变量的作用域通常由花括号 {} 定义的代码块来确定。
局部变量：在方法、循环、条件语句等代码块内声明的变量是局部变量，它们只在声明它们的代码块中可见。
块级作用域：在 C# 7及更高版本中，引入了块级作用域，即使用大括号 {} 创建的任何块都可以定义变量的作用域。
void MyMethod()
{
int localVar = 10; // 局部变量
// ...
}
// localVar 在这里不可见方法参数作用域：方法的参数也有其自己的作用域，它们在整个方法中都是可见的。
void MyMethod(int parameter)
{
// parameter 在整个方法中可见
// ...
}全局变量：在类的成员级别定义的变量是成员变量，它们在整个类中可见，如果在命名空间级别定义，那么它们在整个命名空间中可见。
静态变量作用域：静态变量是在类级别上声明的，但它们的作用域也受限于其定义的类。
class MyClass
{
int memberVar = 30; // 成员变量，在整个类中可见
static int staticVar = 40; // 静态变量，在整个类中可见
}循环变量作用域：在 for 循环中声明的循环变量在循环体内可见
for (int i = 0; i < 5; i++)
{
// i 在循环体内可见
}
// i 在这里不可见字符串格式化
Console.WriteLine(a + "+" + b + "=" + (a + b));
Console.WriteLine("{0} + {1} = {2}", a, b, a + b);数据类型
值类型
| 类型 | 描述 | 范围 | 默认值 |
|---|---|---|---|
| bool | 布尔值 | True 或 False | False |
| byte | 8 位无符号整数 | 0 到 255 | 0 |
| char | 16 位 Unicode 字符 | U +0000 到 U +ffff | '\0' |
| decimal | 128 位精确的十进制值，28-29 有效位数 | (-7.9 x 1028 到 7.9 x 1028) / 100 到 28 | 0.0M |
| double | 64 位双精度浮点型 | (+/-)5.0 x 10-324 到 (+/-)1.7 x 10308 | 0.0D |
| float | 32 位单精度浮点型 | -3.4 x 1038 到 + 3.4 x 1038 | 0.0F |
| int | 32 位有符号整数类型 | -2,147,483,648 到 2,147,483,647 | 0 |
| long | 64 位有符号整数类型 | -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 | 0L |
| sbyte | 8 位有符号整数类型 | -128 到 127 | 0 |
| short | 16 位有符号整数类型 | -32,768 到 32,767 | 0 |
| uint | 32 位无符号整数类型 | 0 到 4,294,967,295 | 0 |
| ulong | 64 位无符号整数类型 | 0 到 18,446,744,073,709,551,615 | 0 |
| ushort | 16 位无符号整数类型 | 0 到 65,535 | 0 |
如需得到一个类型或一个变量在特定平台上的准确尺寸，可以使用 sizeof 方法。
Console.WriteLine("Size of int: {0}", sizeof(int));引用类型
使用多个变量时，引用类型可以指向一个内存位置。
对象（Object）:可以被分配任何其他类型（值类型、引用类型、预定义类型或用户自定义类型）的值。但是，在分配值之前，需要先进行类型转换。当一个值类型转换为对象类型时，则被称为 装箱；另一方面，当一个对象类型转换为值类型时，则被称为 拆箱。
object obj;
obj = 100; // 这是装箱动态（Dynamic）：可以存储任何类型的值在动态数据类型变量中。
dynamic <variable_name> = value;dynamic d = 20;字符串（String）： 允许给变量分配任何字符串值。字符串（String）类型的值可以通过两种形式进行分配：引号和 @引号。
String str = "aabbcc";C# string 字符串的前面可以加 @（称作"逐字字符串"）将转义字符（\）当作普通字符对待，比如：
string str = @"C:\Windows";@ 字符串中可以任意换行，换行符及缩进空格都计算在字符串长度之内。
string str = @"<script type=""text/javascript"">
<!--
-->
</script>";指针类型
指针类型变量存储另一种类型的内存地址。声明指针类型的语法：
type* identifier;char* cptr;
int* iptr;常量
常量可以被当作常规的变量，只是它们的值在定义后不能被修改。
常量是使用 const 关键字来定义的 。定义一个常量的语法如下：
const <data_type> <constant_name> = value;整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，没有前缀则表示十进制。
整数常量也可以有后缀，可以是 U 和 L 的组合，其中，U 和 L 分别表示 unsigned 和 long。后缀可以是大写或者小写，多个后缀以任意顺序进行组合。
212 /* 合法 */
215u /* 合法 */
0xFeeL /* 合法 */
078 /* 非法：8 不是一个八进制数字 */
032UU /* 非法：不能重复后缀 */下是各种类型的整数常量的实例：
85 /* 十进制 */
0213 /* 八进制 */
0x4b /* 十六进制 */
30 /* int */
30u /* 无符号 int */
30l /* long */
30ul /* 无符号 long */一个浮点常量是由整数部分、小数点、小数部分和指数部分组成。可以使用小数形式或者指数形式来表示浮点常量。
3.14159 /* 合法 */
314159E-5L /* 合法 */
510E /* 非法：不完全指数 */
210f /* 非法：没有小数或指数 */
.e55 /* 非法：缺少整数或小数 */转义字符常量
| 转义序列 | 含义 |
|---|---|
| \ | \ 字符 |
| ' | ' 字符 |
| " | " 字符 |
| \? | ? 字符 |
| \a | Alert 或 bell |
| \b | 退格键（Backspace） |
| \f | 换页符（Form feed） |
| \n | 换行符（Newline） |
| \r | 回车 |
| \t | 水平制表符 tab |
| \v | 垂直制表符 tab |
| \ooo | 一到三位的八进制数 |
| \xhh . . . | 一个或多个数字的十六进制数 |
运算符
算术运算符
假设变量 A 的值为 10，变量 B 的值为 20，则：
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 把两个操作数相加 | A + B 将得到 30 |
| - | 从第一个操作数中减去第二个操作数 | A - B 将得到 -10 |
| * | 把两个操作数相乘 | A * B 将得到 200 |
| / | 分子除以分母 | B / A 将得到 2 |
| % | 取模运算符，整除后的余数 | B % A 将得到 0 |
| ++ | 自增运算符，整数值增加 1 | A++ 将得到 11 |
| -- | 自减运算符，整数值减少 1 | A-- 将得到 9 |
- c = a++: 先将 a 赋值给 c，再对 a 进行自增运算。
- c = ++a: 先将 a 进行自增运算，再将 a 赋值给 c 。
- c = a--: 先将 a 赋值给 c，再对 a 进行自减运算。
- c = --a: 先将 a 进行自减运算，再将 a 赋值给 c 。
关系运算符
假设变量 A 的值为 10，变量 B 的值为 20，则：
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 检查两个操作数的值是否相等，如果相等则条件为真。 | (A == B) 不为真。 |
| != | 检查两个操作数的值是否相等，如果不相等则条件为真。 | (A != B) 为真。 |
| > | 检查左操作数的值是否大于右操作数的值，如果是则条件为真。 | (A > B) 不为真。 |
| < | 检查左操作数的值是否小于右操作数的值，如果是则条件为真。 | (A < B) 为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 | (A >= B) 不为真。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 | (A <= B) 为真。 |
逻辑运算符
假设变量 A 为布尔值 true，变量 B 为布尔值 false，则：
| 运算符 | 描述 | 实例 |
|---|---|---|
| && | 称为逻辑与运算符。如果两个操作数都非零，则条件为真。 | (A && B) 为假。 |
| || | 称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 | (A || B) 为真。 |
| ! | 称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 | !(A && B) 为真。 |
位运算符
位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：
| p | q | p & q | p | q | p ^ q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
下表列出了 C# 支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。 | (A & B) 将得到 12，即为 0000 1100 |
| | | 如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。 | (A | B) 将得到 61，即为 0011 1101 |
| ^ | 如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。 | (A ^ B) 将得到 49，即为 0011 0001 |
| ~ | 按位取反运算符是一元运算符，具有"翻转"位效果，即0变成1，1变成0，包括符号位。 | (~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。 |
| << | 二进制左移运算符。左操作数的值向左移动右操作数指定的位数。 | A << 2 将得到 240，即为 1111 0000 |
| >> | 二进制右移运算符。左操作数的值向右移动右操作数指定的位数。 | A >> 2 将得到 15，即为 0000 1111 |
赋值运算符
下表列出了 C# 支持的赋值运算符：
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符，把右边操作数的值赋给左边操作数 | C = A + B 将把 A + B 的值赋给 C |
| += | 加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数 | C += A 相当于 C = C + A |
| -= | 减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数 | C -= A 相当于 C = C - A |
| *= | 乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数 | C *= A 相当于 C = C * A |
| /= | 除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数 | C /= A 相当于 C = C / A |
| %= | 求模且赋值运算符，求两个操作数的模赋值给左边操作数 | C %= A 相当于 C = C % A |
| <<= | 左移且赋值运算符 | C <<= 2 等同于 C = C << 2 |
| >>= | 右移且赋值运算符 | C >>= 2 等同于 C = C >> 2 |
| &= | 按位与且赋值运算符 | C &= 2 等同于 C = C & 2 |
| ^= | 按位异或且赋值运算符 | C ^= 2 等同于 C = C ^ 2 |
| |= | 按位或且赋值运算符 | C |= 2 等同于 C = C | 2 |
其他运算符
下表列出了 C# 支持的其他一些重要的运算符，包括 sizeof、typeof 和 ? :。
| 运算符 | 描述 | 实例 |
|---|---|---|
| sizeof() | 返回数据类型的大小。 | sizeof(int)，将返回 4. |
| typeof() | 返回 class 的类型。 | typeof(StreamReader); |
| & | 返回变量的地址。 | &a; 将得到变量的实际地址。 |
| * | 变量的指针。 | *a; 将指向一个变量。 |
| ? : | 条件表达式 | 如果条件为真 ? 则为 X : 否则为 Y |
| is | 判断对象是否为某一类型。 | If( Ford is Car) // 检查 Ford 是否是 Car 类的一个对象。 |
| as | 强制转换，即使转换失败也不会抛出异常。 | Object obj = new StringReader("Hello"); StringReader r = obj as StringReader; |
运算符优先级
优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。
优先级简易概括：有括号先括号，后乘除在加减，然后位移再关系，逻辑完后条件，最后一个逗号 , 。
| 类别 | 运算符 | 结合性 |
|---|---|---|
| 后缀 | () [] -> . ++ - - | 从左到右 |
| 一元 | + - ! ~ ++ - - (type)* & sizeof | 从右到左 |
| 乘除 | * / % | 从左到右 |
| 加减 | + - | 从左到右 |
| 移位 | << >> | 从左到右 |
| 关系 | < <= > >= | 从左到右 |
| 相等 | == != | 从左到右 |
| 位与 AND | & | 从左到右 |
| 位异或 XOR | ^ | 从左到右 |
| 位或 OR | | | 从左到右 |
| 逻辑与 AND | && | 从左到右 |
| 逻辑或 OR | || | 从左到右 |
| 条件 | ?: | 从右到左 |
| 赋值 | = += -= *= /= %=>>= <<= &= ^= |= | 从右到左 |
| 逗号 | , | 从左到右 |
判断
| 语句 | 描述 |
|---|---|
| if 语句 | 一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。 |
| if...else 语句 | 一个 if 语句 后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。 |
| switch 语句 | 一个 switch 语句允许测试一个变量等于多个值时的情况。 |
if语句
if(boolean_expression)
{
/* 如果布尔表达式为真将执行的语句 */
}if...else if ...else 语句
if(boolean_expression)
{
/* 如果布尔表达式为真将执行的语句 */
}
else if(boolean_expression2)
{
/* 如果布尔表达式2为真将执行的语句 */
}
else
{
/* 如果布尔表达式为假将执行的语句 */
}switch 语句
switch(expression){
case constant-expression :
statement(s);
break;
case constant-expression :
statement(s);
break;
/* 您可以有任意数量的 case 语句 */
default : /* 可选的 */
statement(s);
break;
}switch 语句必须遵循下面的规则：
- switch 语句中的 expression 必须是一个整型或枚举类型，或者是一个 class 类型，其中 class 有一个单一的转换函数将其转换为整型或枚举类型。
- 在一个 switch 中可以有任意数量的 case 语句。每个 case 后跟一个要比较的值和一个冒号。
- case 的 constant-expression 必须与 switch 中的变量具有相同的数据类型，且必须是一个常量。
- 当被测试的变量等于 case 中的常量时，case 后跟的语句将被执行，直到遇到 break 语句为止。
- 当遇到 break 语句时，switch 终止，控制流将跳转到 switch 语句后的下一行。
- 不是每一个 case 都需要包含 break。如果 case 语句为空，则可以不包含 break，控制流将会 继续 后续的 case，直到遇到 break 为止。
- C# 不允许从一个 case 部分继续执行到下一个 case 部分。如果 case 语句中有已经执行，则必须包含 break 或其他跳转语句。
- 一个 switch 语句可以有一个可选的 default 语句，在 switch 的结尾。default 语句用于在上面所有 case 都不为 true 时执行的一个任务。default 也需要包含 break 语句，这是一个良好的习惯。
- C# 不支持从一个 case 标签显式贯穿到另一个 case 标签。如果要使 C# 支持从一个 case 标签显式贯穿到另一个 case 标签，可以使用 goto 一个 switch-case 或 goto default。
char grade = 'B';
switch (grade)
{
case 'A':
Console.WriteLine("很棒！");
break;
case 'B':
case 'C':
Console.WriteLine("做得好");
break;
case 'D':
Console.WriteLine("您通过了");
break;
case 'F':
Console.WriteLine("最好再试一下");
break;
default:
Console.WriteLine("无效的成绩");
break;
}
Console.WriteLine("您的成绩是 {0}", grade);
Console.ReadLine();三元运算符
条件运算符 ? :，可以用来替代 if...else 语句。它的一般形式如下：
Exp1 ? Exp2 : Exp3;? 表达式的值是由 Exp1 决定的。如果 Exp1 为真，则计算 Exp2 的值，结果即为整个 ? 表达式的值。如果 Exp1 为假，则计算 Exp3 的值，结果即为整个 ? 表达式的值。
循环
| 循环类型 | 描述 |
|---|---|
| while 循环 | 当给定条件为真时，重复语句或语句组。它会在执行循环主体之前测试条件。 |
| for/foreach 循环 | 多次执行一个语句序列，简化管理循环变量的代码。 |
| do...while 循环 | 除了它是在循环主体结尾测试条件外，其他与 while 语句类似。 |
循环控制语句
循环控制语句更改执行的正常序列。当执行离开一个范围时，所有在该范围中创建的自动对象都会被销毁。
| 控制语句 | 描述 |
|---|---|
| break 语句 | 终止 loop 或 switch 语句，程序流将继续执行紧接着 loop 或 switch 的下一条语句。 |
| continue 语句 | 跳过本轮循环，开始下一轮循环。 |
无限循环
如果条件永远不为假，则循环将变成无限循环。for 循环在传统意义上可用于实现无限循环。由于构成循环的三个表达式中任何一个都不是必需的，您可以将某些条件表达式留空来构成一个无限循环。
for (; ; ){
Console.WriteLine("Hey! I am Trapped");
}for
for ( init; condition; increment ){
statement(s);
}- init 会首先被执行，且只会执行一次。这一步允许您声明并初始化任何循环控制变量。您也可以不在这里写任何语句，只要有一个分号出现即可。
- 接下来，会判断 condition。如果为真，则执行循环主体。如果为假，则不执行循环主体，且控制流会跳转到紧接着 for 循环的下一条语句。
- 在执行完 for 循环主体后，控制流会跳回上面的 increment 语句。该语句允许您更新循环控制变量。该语句可以留空，只要在条件后有一个分号出现即可。
- 条件再次被判断。如果为真，则执行循环，这个过程会不断重复（循环主体，然后增加步值，再然后重新判断条件）。在条件变为假时，for 循环终止。
foreach
C# 的 foreach 循环可以用来遍历集合类型，例如数组、列表、字典等。它是一个简化版的 for 循环，使得代码更加简洁易读。
foreach (var item in collection){
// 循环
}- 通过 foreach 循环输出整型数组中的元素。
- 通过 for 循环输出整型数组中的元素。
- foreach 循环设置数组元素的计算器。
while
在这里，statement(s) 可以是一个单独的语句，也可以是几个语句组成的代码块。condition 可以是任意的表达式，当为任意非零值时都为真。当条件为真时执行循环。
当条件为假时，程序流将继续执行紧接着循环的下一条语句。
while(condition){
statement(s);
}do...while
do...while 循环是在循环的尾部检查它的条件。do...while 循环与 while 循环类似，但是 do...while 循环会确保至少执行一次循环。
do{
statement(s);
}while( condition );数组
数组是一个存储相同类型元素的固定大小的顺序集合。所有的数组都是由连续的内存位置组成的。最低的地址对应第一个元素，最高的地址对应最后一个元素。
datatype[] arrayName;- datatype 用于指定被存储在数组中的元素的类型。
- [ ] 指定数组的秩（维度）。秩指定数组的大小。
- arrayName 指定数组的名称。
声明：
double[] balance;初始化：声明一个数组不会在内存中初始化数组。当初始化数组变量时，您可以赋值给数组。数组是一个引用类型，所以需要使用 new 关键字来创建数组的实例。
当创建一个数组时，C# 编译器会根据数组类型隐式初始化每个数组元素为一个默认值。例如，int 数组的所有元素都会被初始化为 0。
double[] balance = new double[10];赋值：以通过使用索引号赋值给一个单独的数组元素，比如：
double[] balance = new double[10];
balance[0] = 4500.0;声明并赋值：
double[] balance = { 2340.0, 4523.69, 3421.0};创建并初始化：
int [] marks = new int[5] { 99, 98, 92, 97, 95};可以省略数组的大小
int [] marks = new int[] { 99, 98, 92, 97, 95};赋值一个数组变量到另一个目标数组变量中。在这种情况下，目标和源会指向相同的内存位置：
int [] marks = new int[] { 99, 98, 92, 97, 95};
int[] score = marks;访问：元素是通过带索引的数组名称来访问的。这是通过把元素的索引放置在数组名称后的方括号中来实现的。例如：
double salary = balance[9];在 C# 中，数组是非常重要的，且需要了解更多的细节。下面列出了 C# 程序员必须清楚的一些与数组相关的重要概念：
| 概念 | 描述 |
|---|---|
| 多维数组 | C# 支持多维数组。多维数组最简单的形式是二维数组。 |
| 交错数组 | C# 支持交错数组，即数组的数组。 |
| 传递数组给函数 | 您可以通过指定不带索引的数组名称来给函数传递一个指向数组的指针。 |
| 参数数组 | 这通常用于传递未知数量的参数给函数。 |
| Array 类 | 在 System 命名空间中定义，是所有数组的基类，并提供了各种用于数组的属性和方法。 |
多维数组
声明一个二维数组
string [,] names;声明一个三维数组
int [ , , ] m;数组中的每个元素是使用形式为 a[ i , j ] 的元素名称来标识的，其中 a 是数组名称，i 和 j 是唯一标识 a 中每个元素的下标。
初始化二维数组：多维数组可以通过在括号内为每行指定值来进行初始化。下面是一个带有 3 行 4 列的数组。
int [,] a = new int [3,4] {
{0, 1, 2, 3} , /* 初始化索引号为 0 的行 */
{4, 5, 6, 7} , /* 初始化索引号为 1 的行 */
{8, 9, 10, 11} /* 初始化索引号为 2 的行 */
};访问二维数组元素：二维数组中的元素是通过使用下标（即数组的行索引和列索引）来访问的。例如：
int val = a[2,3];交错数组
交错数组是数组的数组。交错数组是一维数组。可以声明一个带有 int 值的交错数组 scores
int [][] scores;声明一个数组不会在内存中创建数组。创建上面的数组：
int[][] scores = new int[5][];
for (int i = 0; i < scores.Length; i++)
{
scores[i] = new int[4];
}初始化一个交错数组
int[][] scores = new int[2][]{new int[]{92,93,94},new int[]{85,66,87,88}};其中，scores 是一个由两个整型数组组成的数组 -- scores[0] 是一个带有 3 个整数的数组，scores[1] 是一个带有 4 个整数的数组。
传递数组给函数
可以传递数组作为函数的参数。您可以通过指定不带索引的数组名称来给函数传递一个指向数组的指针。
double getAverage(int[] arr, int size){}
MyArray app = new MyArray();
/* 一个带有 5 个元素的 int 数组 */
int [] balance = new int[]{1000, 2, 3, 17, 50};
double avg;
/* 传递数组的指针作为参数 */
avg = app.getAverage(balance, 5 ) ;参数数组
有时，当声明一个方法时，您不能确定要传递给函数作为参数的参数数目。C# 参数数组解决了这个问题，参数数组通常用于传递未知数量的参数给函数。
在使用数组作为形参时，C# 提供了 params 关键字，使调用数组为形参的方法时，既可以传递数组实参，也可以传递一组数组元素。params 的使用格式为：
public 返回类型 方法名称( params 类型名称[] 数组名称 )public int AddElements(params int[] arr){}
app.AddElements(512, 720, 250, 567, 889);Array 类
Array 类是 C# 中所有数组的基类，它是在 System 命名空间中定义。Array 类提供了各种用于数组的属性和方法。Array 类常用的属性：
| 属性 & 描述 |
|---|
| IsFixedSize 获取一个值，该值指示数组是否带有固定大小。 |
| IsReadOnly 获取一个值，该值指示数组是否只读。 |
| Length 获取一个 32 位整数，该值表示所有维度的数组中的元素总数。 |
| LongLength 获取一个 64 位整数，该值表示所有维度的数组中的元素总数。 |
| Rank 获取数组的秩（维度）。 |
Array 类的方法：Array 类中一些最常用的方法：
| 方法 & 描述 |
|---|
| Clear 根据元素的类型，设置数组中某个范围的元素为零、为 false 或者为 null。 |
| Copy(Array, Array, Int32) 从数组的第一个元素开始复制某个范围的元素到另一个数组的第一个元素位置。长度由一个 32 位整数指定。 |
| CopyTo(Array, Int32) 从当前的一维数组中复制所有的元素到一个指定的一维数组的指定索引位置。索引由一个 32 位整数指定。 |
| GetLength 获取一个 32 位整数，该值表示指定维度的数组中的元素总数。 |
| GetLongLength 获取一个 64 位整数，该值表示指定维度的数组中的元素总数。 |
| GetLowerBound 获取数组中指定维度的下界。 |
| GetType 获取当前实例的类型。从对象（Object）继承。 |
| GetUpperBound 获取数组中指定维度的上界。 |
| GetValue(Int32) 获取一维数组中指定位置的值。索引由一个 32 位整数指定。 |
| IndexOf(Array, Object) 搜索指定的对象，返回整个一维数组中第一次出现的索引。 |
| Reverse(Array) 逆转整个一维数组中元素的顺序。 |
| SetValue(Object, Int32) 给一维数组中指定位置的元素设置值。索引由一个 32 位整数指定。 |
| Sort(Array) 使用数组的每个元素的 IComparable 实现来排序整个一维数组中的元素。 |
| ToString 返回一个表示当前对象的字符串。从对象（Object）继承。 |
字符串
可以使用字符数组来表示字符串
//字符串，字符串连接
string fname, lname;
fname = "Rowan";
lname = "Atkinson";
string fullname = fname + lname;
Console.WriteLine("Full Name: {0}", fullname);
Console.WriteLine(fullname[3]);更常见的做法是使用 string 关键字来声明一个字符串变量。string 关键字是 System.String 类的别名。String 类有以下两个属性：
| 属性名称 & 描述 |
|---|
| Chars 在当前 String 对象中获取 Char 对象的指定位置。 |
| Length 在当前的 String 对象中获取字符数。 |
//通过使用 string 构造函数
char[] letters = { 'H', 'e', 'l', 'l','o' };
string greetings = new string(letters);
Console.WriteLine("Greetings: {0}", greetings);
//方法返回字符串
string[] sarray = { "Hello", "From", "Tutorials", "Point" };
string message = String.Join(" ", sarray);
Console.WriteLine("Message: {0}", message);
//用于转化值的格式化方法
DateTime waiting = new DateTime(2012, 10, 10, 17, 58, 1);
string chat = String.Format("Message sent at {0:t} on {0:D}",
waiting);
Console.WriteLine("Message: {0}", chat);
Console.ReadKey() ;String 类的方法
String 类有许多方法用于 string 对象的操作。下面的表格提供了一些最常用的方法：
| 方法名称 & 描述 |
|---|
| public static int Compare( string strA, string strB ) 比较两个指定的 string 对象，并返回一个表示它们在排列顺序中相对位置的整数。该方法区分大小写。 |
| public static int Compare( string strA, string strB, bool ignoreCase ) 比较两个指定的 string 对象，并返回一个表示它们在排列顺序中相对位置的整数。但是，如果布尔参数为真时，该方法不区分大小写。 |
| public static string Concat( string str0, string str1 ) 连接两个 string 对象。 |
| public static string Concat( string str0, string str1, string str2 ) 连接三个 string 对象。 |
| public static string Concat( string str0, string str1, string str2, string str3 ) 连接四个 string 对象。 |
| public bool Contains( string value ) 返回一个表示指定 string 对象是否出现在字符串中的值。 |
| public static string Copy( string str ) 创建一个与指定字符串具有相同值的新的 String 对象。 |
| public void CopyTo( int sourceIndex, char[] destination, int destinationIndex, int count ) 从 string 对象的指定位置开始复制指定数量的字符到 Unicode 字符数组中的指定位置。 |
| public bool EndsWith( string value ) 判断 string 对象的结尾是否匹配指定的字符串。 |
| public bool Equals( string value ) 判断当前的 string 对象是否与指定的 string 对象具有相同的值。 |
| public static bool Equals( string a, string b ) 判断两个指定的 string 对象是否具有相同的值。 |
| public static string Format( string format, Object arg0 ) 把指定字符串中一个或多个格式项替换为指定对象的字符串表示形式。 |
| public int IndexOf( char value ) 返回指定 Unicode 字符在当前字符串中第一次出现的索引，索引从 0 开始。 |
| public int IndexOf( string value ) 返回指定字符串在该实例中第一次出现的索引，索引从 0 开始。 |
| public int IndexOf( char value, int startIndex ) 返回指定 Unicode 字符从该字符串中指定字符位置开始搜索第一次出现的索引，索引从 0 开始。 |
| public int IndexOf( string value, int startIndex ) 返回指定字符串从该实例中指定字符位置开始搜索第一次出现的索引，索引从 0 开始。 |
| public int IndexOfAny( char[] anyOf ) 返回某一个指定的 Unicode 字符数组中任意字符在该实例中第一次出现的索引，索引从 0 开始。 |
| public int IndexOfAny( char[] anyOf, int startIndex ) 返回某一个指定的 Unicode 字符数组中任意字符从该实例中指定字符位置开始搜索第一次出现的索引，索引从 0 开始。 |
| public string Insert( int startIndex, string value ) 返回一个新的字符串，其中，指定的字符串被插入在当前 string 对象的指定索引位置。 |
| public static bool IsNullOrEmpty( string value ) 指示指定的字符串是否为 null 或者是否为一个空的字符串。 |
| public static string Join( string separator, string[] value ) 连接一个字符串数组中的所有元素，使用指定的分隔符分隔每个元素。 |
| public static string Join( string separator, string[] value, int startIndex, int count ) 连接一个字符串数组中的指定位置开始的指定元素，使用指定的分隔符分隔每个元素。 |
| public int LastIndexOf( char value ) 返回指定 Unicode 字符在当前 string 对象中最后一次出现的索引位置，索引从 0 开始。 |
| public int LastIndexOf( string value ) 返回指定字符串在当前 string 对象中最后一次出现的索引位置，索引从 0 开始。 |
| public string Remove( int startIndex ) 移除当前实例中的所有字符，从指定位置开始，一直到最后一个位置为止，并返回字符串。 |
| public string Remove( int startIndex, int count ) 从当前字符串的指定位置开始移除指定数量的字符，并返回字符串。 |
| public string Replace( char oldChar, char newChar ) 把当前 string 对象中，所有指定的 Unicode 字符替换为另一个指定的 Unicode 字符，并返回新的字符串。 |
| public string Replace( string oldValue, string newValue ) 把当前 string 对象中，所有指定的字符串替换为另一个指定的字符串，并返回新的字符串。 |
| public string[] Split( params char[] separator ) 返回一个字符串数组，包含当前的 string 对象中的子字符串，子字符串是使用指定的 Unicode 字符数组中的元素进行分隔的。 |
| public string[] Split( char[] separator, int count ) 返回一个字符串数组，包含当前的 string 对象中的子字符串，子字符串是使用指定的 Unicode 字符数组中的元素进行分隔的。int 参数指定要返回的子字符串的最大数目。 |
| public bool StartsWith( string value ) 判断字符串实例的开头是否匹配指定的字符串。 |
| public char[] ToCharArray() 返回一个带有当前 string 对象中所有字符的 Unicode 字符数组。 |
| public char[] ToCharArray( int startIndex, int length ) 返回一个带有当前 string 对象中所有字符的 Unicode 字符数组，从指定的索引开始，直到指定的长度为止。 |
| public string ToLower() 把字符串转换为小写并返回。 |
| public string ToUpper() 把字符串转换为大写并返回。 |
| public string Trim() 移除当前 String 对象中的所有前导空白字符和后置空白字符。 |
方法
一个方法是把一些相关的语句组织在一起，用来执行一个任务的语句块。每一个 C# 程序至少有一个带有 Main 方法的类。
- 定义方法
- 调用方法
当定义一个方法时，从根本上说是在声明它的结构的元素。在 C# 中，定义方法的语法如下：
<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
Method Body
}下面是方法的各个元素：
- Access Specifier：访问修饰符，这个决定了变量或方法对于另一个类的可见性。
- Return type：返回类型，一个方法可以返回一个值。返回类型是方法返回的值的数据类型。如果方法不返回任何值，则返回类型为 void。
- Method name：方法名称，是一个唯一的标识符，且是大小写敏感的。它不能与类中声明的其他标识符相同。
- Parameter list：参数列表，使用圆括号括起来，该参数是用来传递和接收方法的数据。参数列表是指方法的参数类型、顺序和数量。参数是可选的，也就是说，一个方法可能不包含参数。
- Method body：方法主体，包含了完成任务所需的指令集。
递归
一个方法可以自我调用。这就是所谓的 递归。
public int factorial(int num)
{
/* 局部变量定义 */
int result;
if (num == 1)
{
return 1;
}
else
{
result = factorial(num - 1) * num;
return result;
}
}参数传递
当调用带有参数的方法时，您需要向方法传递参数。在 C# 中，有三种向方法传递参数的方式：
| 方式 | 描述 | 关键字 |
|---|---|---|
| 值参数 | 这种方式复制参数的实际值给函数的形式参数，实参和形参使用的是两个不同内存中的值。在这种情况下，当形参的值发生改变时，不会影响实参的值，从而保证了实参数据的安全。 | |
| 引用参数 | 这种方式复制参数的内存位置的引用给形式参数。这意味着，当形参的值发生改变时，同时也改变实参的值。 | ref |
| 输出参数 | return 语句可用于只从函数中返回一个值。但是，可以使用 输出参数 来从函数中返回两个值。输出参数会把方法输出的数据赋给自己， | out |
public void swap(ref int x, ref int y){}
public void getValue(out int x ){}重载
函数名相同，参数不同，编译器根据传递参数来判定调用哪个函数
static int MaxValue(int[] intArray){
....
return;
}
static double MaxValue(double[] doubleArray){
...
return;
}枚举
枚举是一组命名整型常量。枚举类型是使用 enum 关键字声明的。C# 枚举是值类型。换句话说，枚举包含自己的值，且不能继承或传递继承。
enum <enum_name>
{
enumeration list
};- enum_name 指定枚举的类型名称。
- enumeration list 是一个用逗号分隔的标识符列表。
枚举列表中的每个符号代表一个整数值，一个比它前面的符号大的整数值。默认情况下，第一个枚举符号的值是 0.例如：
enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };using System;
public class EnumTest
{
enum Day { Sun, Mon, Tue, Wed, Thu, Fri, Sat };
static void Main()
{
int x = (int)Day.Sun;
int y = (int)Day.Fri;
Console.WriteLine("Sun = {0}", x);
Console.WriteLine("Fri = {0}", y);
}
}
结构体
在 C# 中，结构体是值类型数据结构，这样使得一个单一变量可以存储各种数据类型的相关数据。struct 关键字用于创建结构体
struct Books
{
public string title;
public string author;
public string subject;
public int book_id;
}; 结构提供了一种轻量级的数据类型，适用于表示简单的数据结构，具有较好的性能特性和值语义：
- 结构可带有方法、字段、索引、属性、运算符方法和事件，适用于表示轻量级数据的情况，如坐标、范围、日期、时间等。
- 结构可定义构造函数，但不能定义析构函数。但是，您不能为结构定义无参构造函数。无参构造函数(默认)是自动定义的，且不能被改变。
- 与类不同，结构不能继承其他的结构或类。
- 结构不能作为其他结构或类的基础结构。
- 结构可实现一个或多个接口。
- 结构成员不能指定为 abstract、virtual 或 protected。
- 当您使用 New 操作符创建一个结构对象时，会调用适当的构造函数来创建结构。与类不同，结构可以不使用 New 操作符即可被实例化。
- 如果不使用 New 操作符，只有在所有的字段都被初始化之后，字段才被赋值，对象才被使用。
- 结构变量通常分配在栈上，这使得它们的创建和销毁速度更快。但是，如果将结构用作类的字段，且这个类是引用类型，那么结构将存储在堆上。
- 结构默认情况下是可变的，这意味着你可以修改它们的字段。但是，如果结构定义为只读，那么它的字段将是不可变的。
类和结构在设计和使用时有不同的考虑因素，类适合表示复杂的对象和行为，支持继承和多态性，而结构则更适合表示轻量级数据和值类型，以提高性能并避免引用的管理开销。
类和结构有以下几个基本的不同点：
值类型 vs 引用类型：
- 结构是值类型（Value Type）： 结构是值类型，它们在栈上分配内存，而不是在堆上。当将结构实例传递给方法或赋值给另一个变量时，将复制整个结构的内容。
- 类是引用类型（Reference Type）： 类是引用类型，它们在堆上分配内存。当将类实例传递给方法或赋值给另一个变量时，实际上是传递引用（内存地址）而不是整个对象的副本。
继承和多态性：
- 结构不能继承： 结构不能继承其他结构或类，也不能作为其他结构或类的基类。
- 类支持继承： 类支持继承和多态性，可以通过派生新类来扩展现有类的功能。
默认构造函数：
- 结构不能有无参数的构造函数： 结构不能包含无参数的构造函数。每个结构都必须有至少一个有参数的构造函数。
- 类可以有无参数的构造函数： 类可以包含无参数的构造函数，如果没有提供构造函数，系统会提供默认的无参数构造函数。
赋值行为：
- 类型为类的变量在赋值时存储的是引用，因此两个变量指向同一个对象。
- 结构变量在赋值时会复制整个结构，因此每个变量都有自己的独立副本。
传递方式：
- 类型为类的对象在方法调用时通过引用传递，这意味着在方法中对对象所做的更改会影响到原始对象。
- 结构对象通常通过值传递，这意味着传递的是结构的副本，而不是原始结构对象本身。因此，在方法中对结构所做的更改不会影响到原始对象。
可空性：
- 结构体是值类型，不能直接设置为 *null*：因为 null 是引用类型的默认值，而不是值类型的默认值。如果你需要表示结构体变量的缺失或无效状态，可以使用 Nullable<T> 或称为 T? 的可空类型。
- 类默认可为null： 类的实例默认可以为
null，因为它们是引用类型。
性能和内存分配：
- 结构通常更轻量： 由于结构是值类型且在栈上分配内存，它们通常比类更轻量，适用于简单的数据表示。
- 类可能有更多开销： 由于类是引用类型，可能涉及更多的内存开销和管理。
封装
封装 被定义为"把一个或多个项目封闭在一个物理的或者逻辑的包中"。在面向对象程序设计方法论中，封装是为了防止对实现细节的访问。抽象和封装是面向对象程序设计的相关特性。抽象允许相关信息可视化，封装则使开发者实现所需级别的抽象。
C# 封装根据具体的需要，设置使用者的访问权限，并通过 访问修饰符 来实现。一个 访问修饰符 定义了一个类成员的范围和可见性。C# 支持的访问修饰符如下所示：
- public：所有对象都可以访问；
- private：对象本身在对象内部可以访问；
- protected：只有该类对象及其子类对象可以访问
- internal：同一个程序集的对象可以访问；
- protected internal：访问限于当前程序集或派生自包含类的类型。
委托
C# 中的委托（Delegate）类似于 C 或 C++ 中函数的指针。委托（Delegate） 是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。委托（Delegate）特别用于实现事件和回调方法。所有的委托（Delegate）都派生自 System.Delegate 类。
声明委托
委托声明决定了可由该委托引用的方法。委托可指向一个与其具有相同标签的方法。
public delegate int MyDelegate (string s);上面的委托可被用于引用任何一个带有一个单一的 string 参数的方法，并返回一个 int 类型变量。声明委托的语法如下：
delegate <return type> <delegate-name> <parameter list>实例化委托
一旦声明了委托类型，委托对象必须使用 new 关键字来创建，且与一个特定的方法有关。当创建委托时，传递到 new 语句的参数就像方法调用一样书写，但是不带有参数。例如：
public delegate void printString(string s);
...
printString ps1 = new printString(WriteToScreen);
printString ps2 = new printString(WriteToFile);委托的多播
委托对象可使用 "+" 运算符进行合并。一个合并委托调用它所合并的两个委托。只有相同类型的委托可被合并。"-" 运算符可用于从合并的委托中移除组件委托。
使用委托的这个有用的特点，您可以创建一个委托被调用时要调用的方法的调用列表。这被称为委托的 多播（multicasting），也叫组播。
Comments | NOTHING