C# 基础语法 01

C# 基础语法 01

01 C#中的注释符号

1、注释符的作用

　　1)、注销

　　2)、解释

2、c#的3种注释符

　　1)、单行注释 //

　　2)、多行注释 /要注释的内容/

　　3)、文档注释 /// 多用来解释类或者方法

02 C#中常用的快捷键

3、VS中常用的快捷键

　　Ctrl + k +d 快速对齐代码

　　Ctrl + z 撤销

　　Ctrl + s 保存

　　Ctrl + j 快速弹出智能提示

　　Shift + End、Shift + Home、Shift + 上下左右 选中单行内容

　　Ctrl + k + c 快速注释选中内容

　　Ctrl + k + u 快速取消注选中的注释内容

　　Alt + Shift +F10 添加命名空间

　　F1 转到帮助

　　F12 查看类型定义

　　#region ...#endregion 折叠代码

03 C#变量的存储以及变量的几中类型

C# 数据类型
在 C# 中，变量分为以下几种类型：

值类型（Value types）
引用类型（Reference types）
指针类型（Pointer types）
值类型（Value types）
值类型变量可以直接分配给一个值。它们是从类 System.ValueType 中派生的。

值类型直接包含数据。比如 int、char、float，它们分别存储数字、字符、浮点数。当您声明一个 int 类型时，系统分配内存来存储值。

04 C# 值类型

整数类型

int 只能存储整数，不能存储小数

C# 类型/关键字	范围	大小	.NET 类型
sbyte	-128 到 127	8 位带符号整数	System.SByte
byte	0 到 255	无符号的 8 位整数	System.Byte
short	-32,768 到 32,767	有符号 16 位整数	System.Int16
ushort	0 到 65,535	无符号 16 位整数	System.UInt16
int	-2,147,483,648 到 2,147,483,647	带符号的 32 位整数	System.Int32
uint	0 到 4,294,967,295	无符号的 32 位整数	System.UInt32
long	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807	64 位带符号整数	System.Int64
ulong	0 到 18,446,744,073,709,551,615	无符号 64 位整数	System.UInt64
nint	取决于（在运行时计算的）平台	带符号的 32 位或 64 位整数	System.IntPtr
nuint	取决于（在运行时计算的）平台	无符号的 32 位或 64 位整数	System.UIntPtr

小数类型

C# 支持以下预定义浮点类型：

C# 类型/关键字	大致范围	精度	大小	.NET 类型
float	±1.5 x 10−45 至 ±3.4 x 1038	大约 6-9 位数字	4 个字节	System.Single
double	±5.0 × 10−324 到 ±1.7 × 10308	大约 15-17 位数字	8 个字节	System.Double
decimal	±1.0 x 10-28 至 ±7.9228 x 1028	28-29 位	16 个字节	System.Decimal

真实文本
真实文本的类型由其后缀确定，如下所示：

..不带后缀的文本或带有 d 或 D 后缀的文本的类型为 double

..带有 f 或 F 后缀的文本的类型为 float

..带有 m 或 M 后缀的文本的类型为 decimal

下面的代码演示每种类型的示例：

double d = 3D;
d = 4d;
d = 3.934_001;

float f = 3_000.5F;
f = 5.4f;

decimal myMoney = 3_000.5m;
myMoney = 400.75M;

还可以使用科学记数法，即指定真实文本的指数部分

double d = 0.42e2;
Console.WriteLine(d);  // output 42

float f = 134.45E-2f;
Console.WriteLine(f);  // output: 1.3445

decimal m = 1.5E6m;
Console.WriteLine(m);  // output: 1500000

bool

bool 类型关键字是 .NET System.Boolean 结构类型的别名，它表示一个布尔值，可为 true 或 false。

若要使用 bool 类型的值执行逻辑运算，请使用布尔逻辑运算符。 bool 类型是 比较和相等运算符的结果类型。 bool 表达式可以是 if、do、while 和 for 语句中以及条件运算符 ?: 中的控制条件表达式。

bool 类型的默认值为 false。

可使用 true 和 false 文本来初始化 bool 变量或传递 bool 值：

bool check = true;
Console.WriteLine(check ? "Checked" : "Not checked");  // output: Checked
Console.WriteLine(false ? "Checked" : "Not checked");  // output: Not checked

char

char 类型关键字是 .NET System.Char 结构类型的别名，它表示 Unicode UTF-16 字符。

C# 类型/关键字	大致范围	大小	.NET 类型
char	U+0000 到 U+FFFF	16 位	System.Char

文本
可以使用以下命令指定 char 值：

字符文本。

Unicode 转义序列，它是 \u 后跟字符代码的十六进制表示形式（四个符号）。

十六进制转义序列，它是 \x 后跟字符代码的十六进制表示形式。

var chars = new[]
{
    'j',
    '\u006A',
    '\x006A',
    (char)106,
};
Console.WriteLine(string.Join(" ", chars));  // output: j j j j

枚举类型

枚举类型 是由基础整型数值类型的一组命名常量定义的值类型。 若要定义枚举类型，请使用 enum 关键字并指定枚举成员 的名称：

enum Season
{
    Spring,
    Summer,
    Autumn,
    Winter
}

结构类型

结构类型（“structure type”或“struct type”）是一种可封装数据和相关功能的值类型 。 使用 struct 关键字定义结构类型：

public struct Coords
{
    public Coords(double x, double y)
    {
        X = x;
        Y = y;
    }

    public double X { get; }
    public double Y { get; }

    public override string ToString() => $"({X}, {Y})";
}

元组类型

C# 支持元组，后者提供了简洁的语法来将多个数据元素分组成一个轻型数据结构。 下面的示例演示了如何声明元组变量、对它进行初始化并访问其数据成员：

(double, int) t1 = (4.5, 3);
Console.WriteLine($"Tuple with elements {t1.Item1} and {t1.Item2}.");
// Output:
// Tuple with elements 4.5 and 3.

(double Sum, int Count) t2 = (4.5, 3);
Console.WriteLine($"Sum of {t2.Count} elements is {t2.Sum}.");
// Output:
// Sum of 3 elements is 4.5.

05 C# 引用类型

字符串类型

string 类型表示零个或多个 Unicode 字符的序列。 string 是 System.String 在 .NET 中的别名。

string a = "hello";
string b = "h";
// Append to contents of 'b'
b += "ello";
Console.WriteLine(a == b);
Console.WriteLine(object.ReferenceEquals(a, b));

[]运算符可用于只读访问字符串的个别字符。 有效索引于 0 开始，且必须小于字符串的长度：

string str = "test";
char x = str[2];  // x = 's';

06 C#变量的命名规范

(1)变量的名以字母、下划线或@开头，后面可以跟字母、数字、下划线，而不能包含空格、标点符号、运算符等其它符号。

（2）变量名不能与C#中的关键字名称相同。这些关键字我们在附录A中给出。

（3）变量名不能与C#中的库函数名称相同

（4）对大小写敏感

（5）同一变量名不允许重复定义
命名法：

（1）pascal命名法

命名规则：

当变量名和函式名称是由二个或二个以上单词连结在一起，而构成的唯一识别字时，用以增加变量和函式的可读性。

单词之间不以空格断开或连接号（-）、底线（_）连结，第一个单字首字母采用大写字母；后续单字的首字母亦用大写字母，例如：FirstName、LastName。每一个单词的首字母都采用大写字母的命名格式，被称为“Pascal命名法”
多用于给变量命名

（2）骆驼式命名法

骆驼式命名法就是当变量名或函式名是由一个或多个单字连结在一起，而构成的唯一识别字时，第一个单词以小写字母开始；第二个单词的首字母大写或每一个单词的首字母都采用大写字母，例如：myFirstName、myLastName，这样的变量名看上去就像骆驼峰一样此起彼伏，故得名。

多用于类或方法命名

（3）匈牙利命名法

匈牙利命名法是一种编程时的命名规范。基本原则是：变量名=属性+类型+对象描述，其中每一对象的名称都要求有明确含义，可以取对象名字全称或名字的一部分。命名要基于容易记忆容易理解的原则。保证名字的连贯性是非常重要的

多用于 ？ 命名

07 C#变量的运算符

运算符和表达式

C# 提供了许多运算符。 其中许多都受到内置类型的支持，可用于对这些类型的值执行基本操作。 这些运算符包括以下组：

• 算术运算符，将对数值操作数执行算术运算
• 比较运算符，将比较数值操作数
• 布尔逻辑运算符，将对 bool 操作数执行逻辑运算
• 位运算符和移位运算符，将对整数类型的操作数执行位运算或移位运算
• 相等运算符，将检查其操作数是否相等

• 内插字符串表达式，提供创建格式化字符串的便利语法：

var r = 2.3;
var message = $"The area of a circle with radius {r} is {Math.PI * r * r:F3}.";
Console.WriteLine(message);
// Output:
// The area of a circle with radius 2.3 is 16.619.

• Lambda 表达式，可用于创建匿名函数：

int[] numbers = { 2, 3, 4, 5 };
var maximumSquare = numbers.Max(x => x * x);
Console.WriteLine(maximumSquare);
// Output:
// 25

• 查询表达式，可用于直接以 C# 使用查询功能：

var scores = new[] { 90, 97, 78, 68, 85 };
IEnumerable<int> highScoresQuery =
    from score in scores
    where score > 80
    orderby score descending
    select score;
Console.WriteLine(string.Join(" ", highScoresQuery));
// Output:
// 97 90 85

赋值运算符 =

赋值运算符 = 将其右操作数的值赋给变量、属性或由其左操作数给出的索引器元素。 赋值表达式的结果是分配给左操作数的值。 右操作数类型必须与左操作数类型相同，或可隐式转换为左操作数的类型。

赋值运算符 = 为右联运算符，即形式的表达式

赋值的左侧操作数接收右侧操作数 的值 。 当操作数是 值类型时，赋值将复制右侧操作数的内容。 当操作数属于 引用类型时，赋值会将引用复制到对象。

算术运算符

以下运算符对数值类型的操作数执行算术运算：

• 一元 ++（增量）、--（减量）、+（加）和 -（减）运算符
• 二元 *（乘法）、/（除法）、%（余数）、+（加法）和 -（减法）运算符

所有整型和浮点数值类型都支持这些运算符。

增量运算符 ++

一元增量运算符 ++ 按 1 递增其操作数。 操作数必须是变量、属性访问或索引器访问。

增量运算符以两种形式进行支持：后缀增量运算符 x++ 和前缀增量运算符 ++x。

后缀递增运算符
x++ 的结果是此操作前的 x的值，如以下示例所示：

int i = 3;
Console.WriteLine(i);   // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i);   // output: 4

前缀增量运算符
++x 的结果是此操作后的 x的值，如以下示例所示：

double a = 1.5;
Console.WriteLine(a);   // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a);   // output: 2.5

布尔逻辑运算符（C# 参考）

以下运算符使用 bool 操作数执行逻辑运算：

• 一元 !（逻辑非）运算符。
• 二元 &（逻辑与）、|（逻辑或）和 ^（逻辑异或）运算符。 这些运算符始终计算两个操作数。
• 二元 &&（条件逻辑与）和 ||（条件逻辑或）运算符。 这些运算符仅在必要时才计算右侧操作数。

位运算符和移位运算符

以下运算符使用整数类型或 char 类型的操作数执行位运算或移位运算：

• 一元 ~（按位求补）运算符
• 二进制 <<（左移）、>>（右移）和 >>>（无符号右移）运算符
• 二进制 &（逻辑 AND）、|（逻辑 OR）和 ^（逻辑异或）运算符

左移运算会放弃超出结果类型范围的高阶位，并将低阶空位位置设置为零
右移位运算符 运算符将其左侧操作数向右移动右侧操作数定义的位数

• 如果左侧操作数的类型是 int 或 long，则右移运算符将执行 算术移位：左侧操作数的最高有效位（符号位）的值将传播到高顺序空位位置。 也就是说，如果左侧操作数为非负，高顺序空位位置设置为零，如果为负，则将该位置设置为 1。
• 如果左侧操作数的类型是 uint 或 ulong，则右移运算符执行逻辑移位：高顺序空位位置始终设置为零。

相等运算符

==（相等） 和 !=（不等） 运算符检查其操作数是否相等。

比较运算符

<（小于）、>（大于）、<=（小于或等于）和 >=（大于或等于）比较（也称为关系）运算符比较其操作数。 所有整型和浮点数值类型都支持这些运算符。

Lambda 表达式

Lambda 表达式 - C# 引用 | Microsoft Learn

08 C# 语句

以下语句重复执行语句或语句块：

• for 语句：在指定的布尔表达式的计算结果为 true 时会执行其主体。
• foreach 语句：枚举集合元素并对集合中的每个元素执行其主体。
• do 语句：有条件地执行其主体一次或多次。
• while 语句：有条件地执行其主体零次或多次。

for 语句

在指定的布尔表达式的计算结果为 true 时，for 语句会执行一条语句或一个语句块。 以下示例显示了 for 语句，该语句在整数计数器小于 3 时执行其主体：

for (int i = 0; i < 3; i++)
{
    Console.Write(i);
}
// Output:
// 012

foreach 语句

foreach 语句为类型实例中实现 System.Collections.IEnumerable 或 System.Collections.Generic.IEnumerable 接口的每个元素执行语句或语句块，如以下示例所示：

for (int i = 0; i < 3; i++)
{
    Console.Write(i);
}
// Output:
// 012

do 语句

在指定的布尔表达式的计算结果为 true 时，do 语句会执行一条语句或一个语句块。 由于在每次执行循环之后都会计算此表达式，所以 do 循环会执行一次或多次。 这不同于 while 循环（该循环执行零次或多次）。

下面的示例演示 do 语句的用法：

int n = 0;
do
{
    Console.Write(n);
    n++;
} while (n < 5);
// Output:
// 01234

while 语句

在指定的布尔表达式的计算结果为 true 时，while 语句会执行一条语句或一个语句块。 由于在每次执行循环之前都会计算此表达式，所以 while 循环会执行零次或多次。 这不同于 do 循环，该循环执行一次或多次。

下面的示例演示 while 语句的用法：

int n = 0;
while (n < 5)
{
    Console.Write(n);
    n++;
}
// Output:
// 01234

if 语句

if 语句可采用以下两种形式中的任一种：

包含 else 部分的 if 语句根据布尔表达式的值选择两个语句中的一个来执行，如以下示例所示：

DisplayWeatherReport(15.0);  // Output: Cold.
DisplayWeatherReport(24.0);  // Output: Perfect!

void DisplayWeatherReport(double tempInCelsius)
{
    if (tempInCelsius < 20.0)
    {
        Console.WriteLine("Cold.");
    }
    else
    {
        Console.WriteLine("Perfect!");
    }
}

switch 语句

switch 语句根据与匹配表达式匹配的模式来选择要执行的语句列表，如以下示例所示：

DisplayMeasurement(-4);  // Output: Measured value is -4; too low.
DisplayMeasurement(5);  // Output: Measured value is 5.
DisplayMeasurement(30);  // Output: Measured value is 30; too high.
DisplayMeasurement(double.NaN);  // Output: Failed measurement.

void DisplayMeasurement(double measurement)
{
    switch (measurement)
    {
        case < 0.0:
            Console.WriteLine($"Measured value is {measurement}; too low.");
            break;

        case > 15.0:
            Console.WriteLine($"Measured value is {measurement}; too high.");
            break;

        case double.NaN:
            Console.WriteLine("Failed measurement.");
            break;

        default:
            Console.WriteLine($"Measured value is {measurement}.");
            break;
    }
}

跳转语句（C# 参考）

以下语句无条件转移控制：

break 语句：将终止最接近的封闭迭代语句或 switch 语句。

continue 语句：启动最接近的封闭迭代语句的新迭代。

return 语句：可终止它所在的函数的执行，并将控制权返回给调用方。 语句 ref 上的 return 修饰符指示返回的表达式 由引用而不是 值返回。

goto 语句：将控制权转交给带有标签的语句。

lock 语句

lock 语句获取给定对象的互斥 lock，执行语句块，然后释放 lock。 持有 lock 时，持有 lock 的线程可以再次获取并释放 lock。 阻止任何其他线程获取 lock 并等待释放 lock。