C# 入门篇#

本篇覆盖从变量到循环的基础语法，学完能写简单的控制台程序。

一、变量和数据类型#

1. 值类型与引用类型#

值类型：int、float、double、bool、char、decimal、long 等，存储在栈上，赋值是复制值。
引用类型：string、object、数组、类等，存储在堆上，赋值是复制引用。
注意：string 虽然是引用类型，但用法像值类型（不可变，比较用 == 比内容）。

2. 变量声明#

1
// 语法：类型 变量名 = 值;
2
int age = 18;
3
float score = 95.5f;     // 注意 f 后缀
4
double pi = 3.14159;     // double 不用加后缀
5
bool isStudent = true;
6
char grade = 'A';        // char 用单引号
7
string name = "小明";    // string 用双引号
8
decimal money = 99.99m;  // 注意 m 后缀
9

10
Console.WriteLine($"{name} 今年 {age} 岁，成绩 {score}");
11
// 输出：小明 今年 18 岁，成绩 95.5

3. 变量命名规则#

只能由字母、数字、下划线组成。
不能以数字开头。
不能使用关键字（如 int、class、if）。
区分大小写：age 和 Age 是不同的变量。

1
int _count = 0;       // 合法
2
int age2 = 18;         // 合法
3
// int 2age = 18;     // 错误：数字开头
4
// int int = 5;       // 错误：用了关键字
5
string userName = "Tom";  // 驼峰命名推荐

4. 常量#

1
const int Max = 100;
2
// Max = 200;  // 错误：常量不能重新赋值
3
Console.WriteLine(Max);  // 输出：100

5. var 隐式推断#

1
var x = 10;        // 编译时推断为 int
2
var s = "hello";   // 推断为 string
3
var d = 3.14;      // 推断为 double
4
// var y;          // 错误：var 必须初始化才能推断类型

var 只是语法糖，编译后类型已确定，不是动态类型。

6. 基本类型及范围对比表#

类型	说明	范围 / 取值	后缀	默认值
`sbyte`	8 位有符号	-128 ~ 127	-	0
`byte`	8 位无符号	0 ~ 255	-	0
`short`	16 位有符号	-32,768 ~ 32,767	-	0
`ushort`	16 位无符号	0 ~ 65,535	-	0
`int`	32 位有符号	-2,147,483,648 ~ 2,147,483,647	-	0
`uint`	32 位无符号	0 ~ 4,294,967,295	`u`	0
`long`	64 位有符号	-9.2×10^18 ~ 9.2×10^18	`L`	0
`ulong`	64 位无符号	0 ~ 1.8×10^19	`ul`	0
`float`	单精度浮点	±1.5×10^-45 ~ ±3.4×10^38（约 7 位有效数字）	`f`	0
`double`	双精度浮点	±5.0×10^-324 ~ ±1.7×10^308（约 15 位有效数字）	-	0
`decimal`	高精度小数	±1.0×10^-28 ~ ±7.9×10^28（28 位有效数字）	`m`	0
`bool`	布尔	true / false	-	false
`char`	单个字符	U+0000 ~ U+FFFF	-	’\0’
`string`	字符串	任意长度文本	-	null

⚠️ 常见坑#

float 赋值必须加 f 后缀，否则编译器默认当 double，会报错：

1
float f = 3.14f;   // 正确
2
// float f2 = 3.14;  // 错误：默认是 double，无法隐式转 float

decimal 赋值必须加 m 后缀（money 的 m，常用于货币计算）：

1
decimal price = 9.99m;  // 正确
2
// decimal p2 = 9.99;    // 错误

double 不用加后缀，它是浮点数默认类型。

变量必须先声明再使用，且作用域仅在声明它的 {} 内：

1
if (true)
2
{
3
    int x = 5;
4
}
5
// Console.WriteLine(x);  // 错误：x 已超出作用域

二、运算符#

1. 算术运算符#

运算符	说明	示例	结果
`+`	加	`5 + 3`	8
`-`	减	`5 - 3`	2
`*`	乘	`5 * 3`	15
`/`	除	`5 / 2`	2
`%`	取余	`5 % 2`	1

1
Console.WriteLine(5 / 2);     // 输出：2（整数除法，不是 2.5）
2
Console.WriteLine(5.0 / 2);  // 输出：2.5（有浮点数参与就是浮点除法）
3
Console.WriteLine(10 % 3);   // 输出：1
4
Console.WriteLine(-7 % 3);   // 输出：-1（结果符号跟被除数）

坑：整数除以整数，结果还是整数（直接截断小数部分）。要得到小数结果，必须让至少一个操作数是浮点数。

自增自减：`++` `--`#

1
int a = 5;
2
Console.WriteLine(a++);  // 输出：5（先用再 +1，后缀）
3
Console.WriteLine(a);    // 输出：6
4

5
int b = 5;
6
Console.WriteLine(++b);  // 输出：6（先 +1 再用，前缀）
7
Console.WriteLine(b);    // 输出：6

记忆：++ 在前先加再用，++ 在后先用再加。

2. 赋值运算符#

1
int n = 10;
2
n += 5;   // 等价 n = n + 5;  → 15
3
n -= 3;   // 等价 n = n - 3;  → 12
4
n *= 2;   // 等价 n = n * 2;  → 24
5
n /= 4;   // 等价 n = n / 4;  → 6
6
n %= 4;   // 等价 n = n % 4;  → 2
7
Console.WriteLine(n);  // 输出：2

3. 关系运算符#

1
int a = 5, b = 10;
2
Console.WriteLine(a == b);  // 输出：False
3
Console.WriteLine(a != b);  // 输出：True
4
Console.WriteLine(a > b);   // 输出：False
5
Console.WriteLine(a < b);   // 输出：True
6
Console.WriteLine(a >= 5);  // 输出：True
7
Console.WriteLine(a <= 4);  // 输出：False

4. 逻辑运算符#

1
bool a = true, b = false;
2
Console.WriteLine(a && b);  // 输出：False（与：都真才真）
3
Console.WriteLine(a || b);  // 输出：True（或：有真即真）
4
Console.WriteLine(!a);      // 输出：False（非：取反）

短路特性#

&&：左边为 false 时，右边不再计算。
||：左边为 true 时，右边不再计算。

1
int x = 0;
2
// x == 0 为 true，右边 10 / x > 1 不计算，避免除零异常
3
if (x != 0 && 10 / x > 1)
4
{
5
    Console.WriteLine("不会执行");
6
}
7
Console.WriteLine("短路保护成功");  // 输出：短路保护成功

5. 位运算符#

1
int a = 5;    // 0101
2
int b = 3;    // 0011
3
Console.WriteLine(a & b);   // 输出：1  (0001，按位与)
4
Console.WriteLine(a | b);   // 输出：7  (0111，按位或)
5
Console.WriteLine(a ^ b);   // 输出：6  (0110，按位异或)
6
Console.WriteLine(~a);      // 输出：-6 (按位取反)
7
Console.WriteLine(a << 1);  // 输出：10 (左移 1 位相当于 ×2)
8
Console.WriteLine(a >> 1);   // 输出：2  (右移 1 位相当于 ÷2 取整)

6. 条件运算符（三元）#

1
int age = 20;
2
string result = age >= 18 ? "成年" : "未成年";
3
Console.WriteLine(result);  // 输出：成年

7. 运算符优先级#

口诀：括号 > 单目 > 算术 > 关系 > 逻辑 > 条件 > 赋值

优先级（高→低）	运算符
1	`()` 括号
2	`!` `~` `++` `--`（单目）
3	`*` `/` `%`
4	`+` `-`
5	`<<` `>>`
6	`<` `>` `<=` `>=`
7	`==` `!=`
8	`&`
9	`^`
10	`
11	`&&`
12	`
13	`?:`（三元）
14	`=` `+=` `-=` 等（赋值）

建议：拿不准就加括号，可读性最重要。

三、类型转换#

1. 隐式转换（小转大，安全）#

1
int i = 100;
2
long l = i;         // int → long，安全
3
float f = l;        // long → float，自动转换
4
double d = f;       // float → double，自动转换
5
Console.WriteLine(d);  // 输出：100

转换链：int → long → float → double

坑：long → float 会丢精度，因为 float 只有约 7 位有效数字。
1
long big = 123456789L;
2
float f2 = big;
3
Console.WriteLine(f2);  // 输出：1.2345679E+08（精度丢失！）

坑：运算中 byte + byte 会自动提升为 int。

1
byte b1 = 1, b2 = 2;
2
// byte b3 = b1 + b2;   // 错误：结果是 int，需强转
3
byte b3 = (byte)(b1 + b2);  // 正确
4
int b4 = b1 + b2;          // 正确

2. 显式转换（大转小，可能丢数据）#

1
double d = 3.9;
2
int i = (int)d;
3
Console.WriteLine(i);  // 输出：3（直接截断小数部分，不是四舍五入）

字符串转数字#

1
// int.Parse：转换失败抛异常
2
int n1 = int.Parse("123");
3
Console.WriteLine(n1);  // 输出：123
4
// int.Parse("abc");    // 抛 FormatException
5

6
// int.TryParse：推荐！失败返回 false，不抛异常
7
if (int.TryParse("123", out int n2))
8
{
9
    Console.WriteLine(n2);  // 输出：123
10
}
11

12
if (!int.TryParse("abc", out int n3))
13
{
14
    Console.WriteLine("转换失败");  // 输出：转换失败
15
}
16

17
// Convert.ToInt32：银行家舍入（四舍六入五取偶）
18
int n4 = Convert.ToInt32(3.9);
19
Console.WriteLine(n4);  // 输出：4
20

21
int n5 = Convert.ToInt32(2.5);
22
Console.WriteLine(n5);  // 输出：2（5 取偶，向偶数舍入）
23

24
int n6 = Convert.ToInt32(3.5);
25
Console.WriteLine(n6);  // 输出：4（5 取偶，向偶数舍入）

3. Convert vs Parse vs 强转对比表#

方式	语法	转换对象	失败行为	舍入方式	推荐场景
强转 `(int)`	`(int)3.9`	数值→数值	无（直接截断）	截断（向零取整）	浮点转整数
`Convert.ToInt32`	`Convert.ToInt32(x)`	多种类型	抛 `FormatException`	银行家舍入（四舍六入五取偶）	字符串/对象转整数
`int.Parse`	`int.Parse("123")`	仅字符串	抛 `FormatException`	-	确定字符串一定是数字
`int.TryParse`	`int.TryParse(s, out n)`	仅字符串	返回 `false`，不抛异常	-	用户输入等不可信数据

四、字符串#

1. 字符串拼接#

1
string name = "小明";
2
int age = 18;
3

4
// 方式一：+ 拼接（简单，少量时用）
5
string s1 = "姓名：" + name + "，年龄：" + age;
6
Console.WriteLine(s1);  // 输出：姓名：小明，年龄：18
7

8
// 方式二：$ 插值（推荐！最直观）
9
string s2 = $"姓名：{name}，年龄：{age}";
10
Console.WriteLine(s2);  // 输出：姓名：小明，年龄：18
11

12
// 方式三：string.Format
13
string s3 = string.Format("姓名：{0}，年龄：{1}", name, age);
14
Console.WriteLine(s3);  // 输出：姓名：小明，年龄：18
15

16
// 方式四：StringBuilder（大量拼接时用，性能好）
17
var sb = new System.Text.StringBuilder();
18
for (int i = 0; i < 3; i++)
19
{
20
    sb.Append($"第{i + 1}行\n");
21
}
22
Console.WriteLine(sb.ToString());
23
// 输出：
24
// 第1行
25
// 第2行
26
// 第3行

2. 转义字符#

转义符	含义	示例
`\n`	换行	`"a\nb"` → a/b 两行
`\t`	制表符	`"a\tb"` → a b
`\"`	双引号	`"说\"你好\""`
`\\`	反斜杠	`"C:\\Users"`
`\r`	回车	`"a\rb"`
`\0`	空字符	-

`@` 逐字字符串#

1
string path = @"C:\Users\name\file.txt";  // 不用写双反斜杠
2
Console.WriteLine(path);  // 输出：C:\Users\name\file.txt
3

4
string multi = @"第一行
5
第二行
6
第三行";  // 逐字字符串可跨行
7
Console.WriteLine(multi);
8
// 输出：
9
// 第一行
10
// 第二行
11
// 第三行

3. 常用方法#

1
string s = "Hello World";
2

3
Console.WriteLine(s.Length);           // 输出：11（长度）
4
Console.WriteLine(s.ToUpper());        // 输出：HELLO WORLD
5
Console.WriteLine(s.ToLower());        // 输出：hello world
6
Console.WriteLine(s.Substring(0, 5));  // 输出：Hello（从索引 0 取 5 个字符）
7
Console.WriteLine(s.IndexOf("World")); // 输出：6（首次出现的索引）
8
Console.WriteLine(s.IndexOf("xyz"));   // 输出：-1（未找到）
9
Console.WriteLine(s.Replace("World", "C#"));  // 输出：Hello C#
10
Console.WriteLine(s.Contains("Hello"));      // 输出：True
11
Console.WriteLine("  abc  ".Trim());          // 输出：abc（去首尾空格）
12

13
string[] parts = "a,b,c".Split(',');
14
foreach (string p in parts)
15
{
16
    Console.WriteLine(p);
17
}
18
// 输出：
19
// a
20
// b
21
// c

4. 字符串不可变性#

C# 中 string 是不可变的：每次修改都会创建一个新字符串对象，原字符串不变。

1
string s = "a";
2
s += "b";  // 不是修改 s，而是创建新字符串 "ab"，s 指向新对象
3
Console.WriteLine(s);  // 输出：ab

坑：在循环中大量用 + 拼接字符串，会产生大量临时对象，性能差。

1
// 反例：每次 += 都创建新字符串
2
string bad = "";
3
for (int i = 0; i < 1000; i++)
4
{
5
    bad += i.ToString();  // 性能差
6
}
7

8
// 正例：用 StringBuilder
9
var good = new System.Text.StringBuilder();
10
for (int i = 0; i < 1000; i++)
11
{
12
    good.Append(i);  // 性能好
13
}

五、控制流 - 条件判断#

1. if 语句#

1
int score = 85;
2

3
// if
4
if (score >= 60)
5
{
6
    Console.WriteLine("及格");  // 输出：及格
7
}
8

9
// if-else
10
if (score >= 60)
11
{
12
    Console.WriteLine("及格");
13
}
14
else
15
{
16
    Console.WriteLine("不及格");
17
}
18

19
// if-else if-else
20
if (score >= 90)
21
{
22
    Console.WriteLine("优秀");
23
}
24
else if (score >= 80)
25
{
26
    Console.WriteLine("良好");  // 输出：良好
27
}
28
else if (score >= 60)
29
{
30
    Console.WriteLine("及格");
31
}
32
else
33
{
34
    Console.WriteLine("不及格");
35
}

坑：条件必须是 bool 类型，不能写成 if (5)，这和 C/C++ 不同。
1
// if (5) { }  // 编译错误：int 不能隐式转 bool
2
if (5 > 3) { }  // 正确

坑：= 和 == 写混。if (x = 5) 在 C# 中是编译错误（因为 int 不能转 bool），这其实是 C# 的保护机制。
1
int x = 0;
2
// if (x = 5) { }  // 编译错误：无法将 int 转为 bool
3
if (x == 5) { }   // 正确

2. switch 语句#

基本语法#

1
int day = 3;
2
switch (day)
3
{
4
    case 1:
5
        Console.WriteLine("星期一");
6
        break;
7
    case 2:
8
        Console.WriteLine("星期二");
9
        break;
10
    case 3:
11
        Console.WriteLine("星期三");  // 输出：星期三
12
        break;
13
    default:
14
        Console.WriteLine("未知");
15
        break;
16
}

case 合并（空 case 共享代码）#

1
int month = 7;
2
switch (month)
3
{
4
    case 3:
5
    case 4:
6
    case 5:
7
        Console.WriteLine("春季");
8
        break;
9
    case 6:
10
    case 7:
11
    case 8:
12
        Console.WriteLine("夏季");  // 输出：夏季
13
        break;
14
    default:
15
        Console.WriteLine("其他季节");
16
        break;
17
}

支持的类型#

switch 支持 int、char、string、enum 等：

1
string cmd = "start";
2
switch (cmd)
3
{
4
    case "start":
5
        Console.WriteLine("开始");  // 输出：开始
6
        break;
7
    case "stop":
8
        Console.WriteLine("停止");
9
        break;
10
    default:
11
        Console.WriteLine("未知命令");
12
        break;
13
}

C# 7.0+ 模式匹配（简述）#

1
object obj = "hello";
2
switch (obj)
3
{
4
    case int n when n > 0:
5
        Console.WriteLine($"正整数：{n}");
6
        break;
7
    case string s:
8
        Console.WriteLine($"字符串：{s}");  // 输出：字符串：hello
9
        break;
10
    case null:
11
        Console.WriteLine("空值");
12
        break;
13
    default:
14
        Console.WriteLine("其他类型");
15
        break;
16
}

switch 表达式（C# 8.0+，简述）#

1
int day = 3;
2
string dayName = day switch
3
{
4
    1 => "星期一",
5
    2 => "星期二",
6
    3 => "星期三",  // 输出：星期三
7
    _ => "其他"
8
};
9
Console.WriteLine(dayName);

坑：C# 中 case 后必须有 break（或 return / goto / throw），不能像 C/C++ 那样穿透！

1
// int x = 1;
2
// switch (x)
3
// {
4
//     case 1:
5
//         Console.WriteLine("一");
6
//     case 2:                  // 错误：控制不能从一个 case 穿透到另一个
7
//         Console.WriteLine("二");
8
//         break;
9
// }

六、控制流 - 循环#

1. while 循环#

1
int i = 1;
2
while (i <= 3)
3
{
4
    Console.WriteLine($"第 {i} 次");
5
    i++;
6
}
7
// 输出：
8
// 第 1 次
9
// 第 2 次
10
// 第 3 次

特点：先判断再执行，条件不满足时一次都不执行。

坑：忘改条件变量导致死循环。

1
// int i = 1;
2
// while (i <= 3)
3
// {
4
//     Console.WriteLine(i);  // 死循环！i 永远是 1
5
// }

2. do-while 循环#

1
int i = 1;
2
do
3
{
4
    Console.WriteLine($"第 {i} 次");
5
    i++;
6
} while (i <= 3);
7
// 输出：
8
// 第 1 次
9
// 第 2 次
10
// 第 3 次

特点：先执行再判断，至少执行一次。

1
// 即使条件一开始就为假，也执行一次
2
int n = 10;
3
do
4
{
5
    Console.WriteLine(n);  // 输出：10
6
} while (n < 5);

坑：while(条件) 后面必须有分号！
1
// do { } while (true)   // 错误：少分号
2
do { } while (true);    // 正确

3. for 循环#

1
for (int i = 1; i <= 5; i++)
2
{
3
    Console.WriteLine(i);
4
}
5
// 输出：
6
// 1
7
// 2
8
// 3
9
// 4
10
// 5

三要素：初始化; 条件; 迭代

1
// 倒序
2
for (int i = 5; i >= 1; i--)
3
{
4
    Console.WriteLine(i);  // 输出：5 4 3 2 1
5
}
6

7
// 累加 1 到 100
8
int sum = 0;
9
for (int i = 1; i <= 100; i++)
10
{
11
    sum += i;
12
}
13
Console.WriteLine(sum);  // 输出：5050

4. foreach 循环#

1
string[] names = { "张三", "李四", "王五" };
2
foreach (string name in names)
3
{
4
    Console.WriteLine(name);
5
}
6
// 输出：
7
// 张三
8
// 李四
9
// 王五

语法：foreach (类型变量 in 集合)

坑：foreach 是只读遍历，不能修改集合元素。

1
int[] nums = { 1, 2, 3 };
2
// foreach (int n in nums)
3
// {
4
//     n = 0;  // 错误：不能给 foreach 迭代变量赋值
5
// }

5. break 和 continue#

1
// break：跳出整个循环
2
for (int i = 1; i <= 10; i++)
3
{
4
    if (i == 5) break;
5
    Console.WriteLine(i);
6
}
7
// 输出：1 2 3 4
8

9
// continue：跳过本次，继续下一次
10
for (int i = 1; i <= 5; i++)
11
{
12
    if (i == 3) continue;
13
    Console.WriteLine(i);
14
}
15
// 输出：1 2 4 5

6. 四种循环对比表#

循环类型	执行顺序	最少执行次数	适用场景
`while`	先判断后执行	0 次	不确定次数，满足条件才执行
`do-while`	先执行后判断	1 次	至少要执行一次
`for`	先判断后执行	0 次	已知循环次数
`foreach`	顺序遍历	0 次	遍历集合/数组（只读）

7. 嵌套循环 - 九九乘法表#

1
for (int i = 1; i <= 9; i++)
2
{
3
    for (int j = 1; j <= i; j++)
4
    {
5
        Console.Write($"{j}×{i}={i * j}\t");
6
    }
7
    Console.WriteLine();
8
}
9
// 输出：
10
// 1×1=1
11
// 1×2=2    2×2=4
12
// 1×3=3    2×3=6    3×3=9
13
// ...（依此类推到 9×9=81）

七、异常捕获#

1. try-catch#

1
try
2
{
3
    int n = int.Parse("abc");  // 会抛 FormatException
4
    Console.WriteLine(n);
5
}
6
catch (FormatException ex)
7
{
8
    Console.WriteLine("格式错误：" + ex.Message);  // 输出：格式错误：...
9
}

多个 catch（从具体到通用）#

1
try
2
{
3
    int[] arr = { 1, 2, 3 };
4
    Console.WriteLine(arr[5]);  // 越界
5
}
6
catch (IndexOutOfRangeException ex)
7
{
8
    Console.WriteLine("数组越界");  // 输出：数组越界
9
}
10
catch (Exception ex)  // 兜底，必须放最后
11
{
12
    Console.WriteLine("其他异常：" + ex.Message);
13
}

坑：多个 catch 块时，具体异常在前，通用异常（Exception）在最后，否则编译错误。

2. try-catch-finally#

1
try
2
{
3
    int a = 10, b = 0;
4
    int c = a / b;  // 抛 DivideByZeroException
5
    Console.WriteLine(c);
6
}
7
catch (DivideByZeroException ex)
8
{
9
    Console.WriteLine("除零错误：" + ex.Message);  // 输出：除零错误：...
10
}
11
finally
12
{
13
    Console.WriteLine("无论如何都执行");  // 输出：无论如何都执行
14
}

finally 无论是否发生异常都会执行，常用于资源释放。

3. 异常对象#

1
try
2
{
3
    string s = null;
4
    Console.WriteLine(s.Length);  // 抛 NullReferenceException
5
}
6
catch (NullReferenceException ex)
7
{
8
    Console.WriteLine("错误信息：" + ex.Message);       // 简短描述
9
    Console.WriteLine("堆栈跟踪：\n" + ex.StackTrace);  // 调用堆栈
10
}

常用属性：

ex.Message：错误简短描述。
ex.StackTrace：调用堆栈，定位异常位置。
ex.GetType().Name：异常类型名。

4. throw - 主动抛异常#

1
public static int Divide(int a, int b)
2
{
3
    if (b == 0)
4
    {
5
        throw new DivideByZeroException("除数不能为零");  // 主动抛出
6
    }
7
    return a / b;
8
}
9

10
// 调用
11
try
12
{
13
    Console.WriteLine(Divide(10, 0));
14
}
15
catch (DivideByZeroException ex)
16
{
17
    Console.WriteLine(ex.Message);  // 输出：除数不能为零
18
}

throw 还可以重新抛出当前异常（保留原始堆栈）：

1
try { /* ... */ }
2
catch (Exception ex)
3
{
4
    // 记录日志
5
    throw;  // 重新抛出，保留原始堆栈（不要写 throw ex，会重置堆栈）
6
}

5. 常见异常类型表#

异常类型	触发场景	示例
`FormatException`	字符串格式不正确	`int.Parse("abc")`
`DivideByZeroException`	整数除以零	`int x = 5 / 0;`
`IndexOutOfRangeException`	数组索引越界	`arr[arr.Length]`
`NullReferenceException`	访问 null 对象成员	`null.ToString()`
`OverflowException`	算术运算溢出（checked 中）	`checked { int x = int.MaxValue + 1; }`
`InvalidCastException`	无效的类型转换	`(int)(object)"abc"`
`ArgumentNullException`	方法参数为 null（不合法）	内部主动抛出
`ArgumentOutOfRangeException`	参数超出有效范围	`s.Substring(-1, 5)`
`StackOverflowException`	栈溢出（如无限递归）	无限递归调用
`OutOfMemoryException`	内存不足	分配超大数组

6. 最佳实践#

不要空 catch（吞掉异常会让 bug 难以排查）：

1
// 反例：吞掉异常
2
try { DoSomething(); }
3
catch { }  // 错误示范：什么都没做
4

5
// 正例：至少记录日志
6
try { DoSomething(); }
7
catch (Exception ex)
8
{
9
    Console.WriteLine($"出错：{ex.Message}");
10
}

能预判就提前判断，别用异常做流程控制：

1
// 反例：用异常判断输入
2
// try { int n = int.Parse(input); }
3
// catch { Console.WriteLine("输入非法"); }
4

5
// 正例：先判断
6
if (int.TryParse(input, out int n))
7
{
8
    Console.WriteLine(n);
9
}
10
else
11
{
12
    Console.WriteLine("输入非法");
13
}

catch 具体类型，不要一上来就 catch (Exception)。
finally 用于资源释放，确保即使异常也能关闭文件、数据库连接等。

入门篇总结#

一句话总结每个知识点#

知识点	一句话总结
变量与类型	值类型存值、引用类型存引用；`float` 加 `f`、`decimal` 加 `m`
运算符	整数除法得整数；`&&` `
类型转换	小转大自动，大转小强转；字符串转数字优先 `TryParse`
字符串	`string` 不可变；拼接用 `$`，大量拼接用 `StringBuilder`
条件判断	`if` 条件必须是 `bool`；`switch` 的 `case` 必须有 `break`
循环	`while` 先判后执，`do-while` 先执后判；`foreach` 只读
异常	`try-catch-finally`；别空 catch，别用异常做流程控制

学习建议#

多写代码：看懂不等于会写，每个语法点都自己敲一遍。
善用断点调试：F9 设断点，F10 单步执行，F11 进入方法，观察变量变化。
看报错信息：编译错误和异常信息是 Debug 的第一线索，别一报错就慌。
从简单程序开始：先写计算器、猜数字、九九乘法表等小项目，巩固基础。
官方文档是好帮手：Microsoft Learn 有最权威的教程和示例。

学完入门篇，你已经能写出简单的控制台程序了。下一篇进阶篇将带你进入方法、数组、面向对象的世界！

音乐

音乐

C#学习【入门篇】