CSharp-01-环境与基础语法
这篇讲什么
C# 不是一个"单独的语言",它长在 .NET 平台上:语言负责语法,运行时负责执行,基础类库(Base Class Library, BCL)负责提供现成的类型。本篇先讲清这三者的边界与协作方式(为什么理解它会让你少踩一半的坑),再逐条过一遍基础语法:变量与
var、内置类型与取值范围、值类型与引用类型、装箱、可空值类型、类型转换的安全写法、字符串与StringBuilder、运算符与控制流、数组与foreach的实现原理。阅读前提:机器上已安装 .NET SDK(本笔记以 .NET SDK 10.0.401、C# 13 语法为基准;语言与框架版本更新较快,细节以官方最新文档为准)。
一、是什么:.NET 平台的组成
初学者最容易被几个词绕晕:.NET、.NET Framework、.NET Core、CLR、SDK、BCL、C# 语言规范。它们不是同义词,而是不同层次的组件。
| 名称 | 层次 | 职责 | 类比 |
|---|---|---|---|
| C# 语言规范(C# Language Specification) | 语言 | 定义语法与语义:什么写得出来、写出来是什么意思 | 交通法规 |
编译器(Roslyn / csc) | 工具 | 把 C# 源码翻译成中间语言(Intermediate Language, IL) | 翻译官 |
| CLR(Common Language Runtime) | 运行时 | 加载 IL、JIT 编译成本机码、管理内存与异常、GC | 发动机 |
| BCL / 运行时库 | 库 | System.* 命名空间下的现成类型:List<T>、string、File | 标准零件库 |
| SDK | 工具集 | 编译器 + 运行时 + 模板 + dotnet CLI + MSBuild | 整车工具套装 |
| 运行时(Runtime) | 安装包 | 只包含执行程序所需的东西,不含编译器 | 只有发动机 |
一句话抓住边界
语言 ≠ 运行时 ≠ 库。
C# 13是新语法,.NET 10是运行时与库的版本,两者独立演进:同一份 C# 代码可以编译到不同的目标框架(Target Framework),同一个运行时也能跑用不同 C# 版本写的程序。这就是为什么你能在
.NET 10上把LangVersion设为12,用的却是.NET 10的 BCL。
1.1 编译执行流程:C# → IL → 本机码
源码 A.cs
│ csc / Roslyn 编译
▼
IL + 元数据(metadata) ← 存在 .dll / .exe 里,与平台无关
│ 运行时加载(dotnet run / dotnet MyApp.dll)
▼
┌──────────────┬─────────────────────────────┐
│ JIT 即时编译 │ AOT 提前编译 │
│ 方法首次调用时 │ 发布时整体编译成机器码 │
│ 编译成机器码 │(NativeAOT,启动快、体积小) │
└──────────────┴─────────────────────────────┘
▼
本机码在 CPU 上执行
为什么要有 IL 这一层? 直接编译成机器码(像 C 那样)不是更简单吗?IL 的存在换来四件事:
- 跨平台:IL 与 CPU 无关,同一份程序集在 x64、Arm64、Linux、Windows 上都能跑,JIT 在目标机器上生成对应机器码。
- 跨语言:C#、F#、VB.NET 都编译成 IL,可以互相引用——
F#写的库能被 C# 直接using。 - 运行时优化:JIT 知道真实 CPU 特性(AVX2、AVX-512)和真实调用热点,可以做"运行时特化",这在编译期是拿不到的信息。
- 安全与自描述:IL 带完整元数据(类型、成员、签名),运行时能在加载时做类型安全检查、反射、GC 精确标记对象引用。
代价是什么
IL + JIT 换来灵活性,代价是启动时的编译开销和首次调用的延迟。对启动时间敏感的场景(CLI 工具、Serverless)用 NativeAOT 把 IL 提前编译成机器码;对启动延迟敏感但不想放弃动态特性时,可以用 ReadyToRun(R2R) 预编译。三种模式的取舍见 CSharp-07-dotnet项目与工具链。
1.2 .NET Framework / .NET Core / .NET 5+ 的历史关系
这段历史必须搞清,否则你会看不懂一堆过时教程里的 System.Web、packages.config、web.config。
| 对比项 | .NET Framework | .NET Core 1.x–3.1 | .NET 5 及以后(含 .NET 8/9/10) |
|---|---|---|---|
| 首发年份 | 2002 | 2016 | 2020 起,每年 11 月一个大版本 |
| 平台支持 | 仅 Windows | Windows / Linux / macOS | 同上,另含容器、WASM、移动端(经 .NET MAUI) |
| 交付方式 | 随 Windows 系统组件 | 独立安装、可并排 | 独立安装、可并排,支持自包含发布 |
| 开源 | 部分 | 完全开源(MIT) | 完全开源 |
| 项目文件 | 复杂 MSBuild,需逐文件列出 | SDK 风格,隐式包含源文件 | SDK 风格(延续至今) |
| 包管理 | packages.config / NuGet | NuGet(PackageReference) | NuGet(PackageReference) |
| 状态(2026) | 仅 4.8.x 维护,不再加新功能 | 已全部停止支持 | 主线,持续演进 |
历史脉络一句话:.NET Framework → .NET Core(重写、跨平台)→ .NET 5+(去掉 "Core" 字样,成为唯一主线)。.NET Core 4.x 这个版本号被跳过,就是为了避免和 .NET Framework 4.x 混淆——从 4.8 直接跳到 5.0。
别再学的过时东西
-
web.config/app.config的system.web配置段 → 现代用appsettings.json+Microsoft.Extensions.Configuration-
packages.config→ 现代用<PackageReference>-
ASP.NET Web Forms/WCF(服务端) → 现代用 后端-03-ASPNET-Core、gRPC-
.NET Framework里的System.Configuration.ConfigurationManager→ 现代用选项模式(Options Pattern)
1.3 安装 SDK 与验证
三种安装方式,选一种即可:
| 方式 | 命令/入口 | 适用场景 |
|---|---|---|
| 官方安装包 | dotnet.microsoft.com/download | 个人开发机,最省事 |
| Windows 包管理器 | winget install Microsoft.DotNet.SDK.10 | 自动化装机 |
| 脚本 | dotnet-install.ps1 / dotnet-install.sh | CI 环境、无管理员权限 |
# 一次性把 SDK 和运行时信息全部打印出来:排查环境问题第一命令
dotnet --info
# 只列出已安装的 SDK(一台机器可以并排装多个版本)
dotnet --list-sdks
# 只列出已安装的运行时(SDK 自带运行时,但可能装了额外的运行时)
dotnet --list-runtimes
典型输出(dotnet --list-sdks):
10.0.401 [C:\Program Files\dotnet\sdk]
版本策略:装哪个?
- LTS(长期支持,如 .NET 8、.NET 10)支持 3 年,生产环境首选。.NET SDK 10.0.401 对应的 .NET 10 是 LTS,支持到 2028-11。
- STS(标准期限支持,如 .NET 9)支持 18 个月,适合追新特性。
- 官方支持策略:.NET Support Policy(以官方最新页面为准)。
1.4 dotnet CLI 常用命令
| 命令 | 作用 | 常用参数 |
|---|---|---|
dotnet new <模板> | 从模板创建项目 | console、classlib、webapi、sln;-n 名称、-o 目录、-f net10.0 |
dotnet new list | 列出本机所有模板 | dotnet new list console 可过滤 |
dotnet build | 编译(默认 Debug) | -c Release、--no-restore |
dotnet run | 编译并运行 | --project 路径、-- 传给程序的参数 |
dotnet test | 运行测试项目 | --filter、--collect:"XPlat Code Coverage" |
dotnet add package <名> | 添加 NuGet 包引用 | --version 1.2.3、--prerelease |
dotnet add reference <项目> | 添加项目引用 | 无 |
dotnet publish | 产出可部署产物 | -c Release -o out、-r win-x64 --self-contained、-p:PublishAot=true |
dotnet restore | 还原 NuGet 依赖 | --locked-mode(CI 用) |
dotnet format | 按规则格式化代码 | --verify-no-changes(CI 用) |
dotnet tool install -g <名> | 安装全局工具 | dotnet-ef、dotnet-format |
dotnet clean | 删除编译产物 | -c Release |
--的意义
dotnet run -- --name Alice里,第一个--之后的参数才是传给程序的,前面的属于dotnet run自己。少了这个--,--name会被 CLI 当成自己的选项而报错。
1.5 项目文件 .csproj 与 SDK 风格项目
老式项目文件要把每个 .cs 文件写进 <Compile Include="...">;SDK 风格项目靠约定自动包含:**/*.cs、.resx、wwwroot 等,只需声明"例外"。
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<!-- 目标框架:决定能用到哪些 BCL API。net10.0 表示 .NET 10 -->
<OutputType>Exe</OutputType>
<TargetFramework>net10.0</TargetFramework>
<!-- 让编译器按最新语言版本解析语法糖;不写则按目标框架的默认版本 -->
<LangVersion>latest</LangVersion>
<!-- 开启可空引用类型静态分析:把"可能为 null"变成编译期警告 -->
<Nullable>enable</Nullable>
<!-- 隐式 using:自动引入 System、System.Linq 等常用命名空间 -->
<ImplicitUsings>enable</ImplicitUsings>
<RootNamespace>Demo.App</RootNamespace>
<AssemblyName>Demo.App</AssemblyName>
</PropertyGroup>
<ItemGroup>
<!-- 例外声明:测试或工具模板文件不参与编译 -->
<Compile Remove="Scripts/**/*.cs" />
</ItemGroup>
<ItemGroup>
<!-- PackageReference 取代了旧的 packages.config,依赖写进项目文件本身 -->
<PackageReference Include="Serilog" Version="4.2.0" />
</ItemGroup>
</Project>
| 属性 | 默认值 | 建议 |
|---|---|---|
TargetFramework | 模板决定 | 生产用 LTS(net10.0);类库可多目标 net8.0;net10.0 |
Nullable | 新模板为 enable | 新项目一律 enable |
ImplicitUsings | 新模板为 enable | 小项目开启;库项目可关闭以免污染 |
TreatWarningsAsErrors | false | CI 里设 true,让警告无法被忽略 |
InvariantGlobalization | false | 容器里可设 true 减小体积,但会丢失区域性行为 |
二、为什么这样设计
2.1 为什么 C# 是静态类型、编译型语言
| 维度 | C#(静态 + 编译) | Python(动态 + 解释) |
|---|---|---|
| 类型检查时机 | 编译期 | 运行期 |
| 错误暴露 | 写错属性名 → 编译不过 | 运行到那一行才 AttributeError |
| 性能 | 类型信息已知,JIT 可去虚化、内联、栈分配 | 每次属性访问都要查字典 |
| 重构 | IDE 可靠改名 | 靠文本搜索,易漏 |
| 灵活性 | 需要泛型/委托/反射补齐 | 天生灵活 |
| 开发速度 | 前期慢、后期稳 | 前期快、大型项目易失控 |
C# 的取舍是"用编译期的约束换运行期的确定"。类型系统还顺带解决了重构安全和工具支持(自动补全、跳转定义、找引用)——这是大型项目里最贵的东西。
2.2 为什么有 var 却仍推荐显式类型
var 是编译期类型推断,不是动态类型:var x = 1; 里 x 依然是 int,之后 x = "abc"; 编译不过。它的设计目的是消除重复的类型名,而不是逃避类型:
// 类型在右侧已经写得清清楚楚,左侧再写一遍是噪音 → 用 var
var users = new Dictionary<string, List<int>>();
var sw = System.Diagnostics.Stopwatch.StartNew();
// 右侧看不出类型(工厂方法、LINQ、字面量)→ 显式写出来,读者不用猜
List<Order> pending = repo.GetPendingOrders();
IEnumerable<int> evens = numbers.Where(n => n % 2 == 0); // 元素类型重要,别写 var
decimal total = 0m; // 0 是 int、0m 是 decimal、0.0 是 double,这里必须显式
var的三条硬规则1. 必须同时初始化:
var x;编译不过。2. 初始化表达式不能是
null,也不能是方法组/匿名方法:var f = SomeMethod;编译不过。3. 推断出的类型是静态的:
var i = 1; i = "s";编译不过。它不是 JavaScript 的let。
三、核心内容
3.1 命名空间与 using
命名空间(Namespace)是类型的全名前缀,用来避免重名冲突、组织代码;using 指令只是简化书写,不影响运行时行为(编译后类型名仍是全名)。
namespace Demo.App.Core; // 文件范围命名空间(C# 10+),整个文件都属于它
using System.Text; // 引入命名空间
using SysList = System.Collections.Generic.List<int>; // 别名,解决重名
using static System.Math; // 静态引入:可直接写 Sqrt(2) 而不是 Math.Sqrt(2)
public class Widget
{
public void Show()
{
var sb = new StringBuilder(); // 来自 using System.Text
Console.WriteLine(Sqrt(16)); // 来自 using static System.Math
}
}
| 写法 | 作用 | 注意 |
|---|---|---|
using System.Text; | 引入命名空间下所有类型 | 不引入子命名空间的类型 |
using static System.Math; | 引入类型的静态成员 | 过度使用会降低可读性 |
using Alias = X.Y.Z; | 起别名 | 也可给泛型起别名 |
global using System; | 全局 using,整个项目可见 | 通常放在 GlobalUsings.cs |
<ImplicitUsings>enable</ImplicitUsings> | 由 SDK 自动生成一组全局 using | 生成的列表随 SDK 版本变化 |
using的两个身份
using指令(引入命名空间)和using语句(using var f = File.OpenRead(...),见 CSharp-02-面向对象)是完全不同的东西,只是关键字撞名。看到using先看后面跟的是命名空间还是表达式。
3.2 顶级语句(Top-level statements)
C# 9 起,Program.cs 可以不写 class Program 和 static void Main:编译器会自动生成它们。
// Program.cs —— 整个文件就是 Main 的方法体,编译器自动包裹
Console.WriteLine("Hello, .NET 10");
// args 是自动提供的命令行参数数组(隐含名为 args)
if (args.Length > 0)
{
Console.WriteLine($"收到参数:{args[0]}");
}
// 若需要返回值,直接 return;返回值成为进程退出码
return 0;
等价的传统写法(编译器实际生成的结构):
internal static class Program
{
private static int Main(string[] args) // 顶级语句的 return 值对应这里
{
Console.WriteLine("Hello, .NET 10");
return 0;
}
}
顶级语句的约束
- 一个项目里只有一个文件能有顶级语句。
- 隐式生成的
Main是private static,所以其他类型调用不到它。- 顶级语句里可以声明局部函数,也可以在其后声明类型,但类型必须写在所有语句之后。
- 若同一项目里已有显式
Main,再写顶级语句会报错(两个入口点)。
3.3 内置类型:取值范围与默认值
| C# 关键字 | .NET 类型 | 字节 | 取值范围 | 默认值 | 字面量示例 |
|---|---|---|---|---|---|
sbyte | System.SByte | 1 | ~ | 0 | (sbyte)-1 |
byte | System.Byte | 1 | ~ | 0 | (byte)200 |
short | System.Int16 | 2 | ~ | 0 | (short)-5 |
ushort | System.UInt16 | 2 | ~ | 0 | (ushort)60000 |
int | System.Int32 | 4 | ~ | 0 | 42 |
uint | System.UInt32 | 4 | ~ | 0 | 42u |
long | System.Int64 | 8 | ~ | 0L | 42L |
ulong | System.UInt64 | 8 | ~ | 0UL | 42UL |
nint | System.IntPtr | 平台相关 | 32/64 位指针宽度 | 0 | (nint)1 |
float | System.Single | 4 | ~ ,7 位有效数字 | 0f | 1.5f |
double | System.Double | 8 | ~ ,15–17 位有效数字 | 0d | 1.5 |
decimal | System.Decimal | 16 | ~ ,28–29 位有效数字 | 0m | 19.99m |
bool | System.Boolean | 1 | true / false | false | true |
char | System.Char | 2 | UTF-16 码元 U+0000 ~ U+FFFF | '\0' | 'A'、'\n'、'\u4E2D' |
string | System.String | 引用类型 | 不可变 Unicode 序列 | null | "hi"、@"C:\t" |
object | System.Object | 引用类型 | 所有类型的根 | null | new object() |
float/double不能表示精确小数
0.1 + 0.2 != 0.3(二进制浮点无法精确表示 0.1)。涉及金额、税率、单价一律用decimal。反过来说,科学计算、图形、机器学习用double,因为decimal慢得多(软件实现)且范围小。
整数类型的大小换算关系(n 位有符号整数):
3.4 值类型与引用类型
这是 C# 类型系统的分水岭。
| 维度 | 值类型(Value Type) | 引用类型(Reference Type) |
|---|---|---|
| 包括 | struct、enum、所有内置数值/bool/char、record struct、ValueTuple | class、interface、delegate、string、object、数组、record(默认)、dynamic |
| 变量存什么 | 数据本身 | 指向对象的引用(地址) |
| 赋值语义 | 复制整个值(副本独立) | 复制引用(两个变量指向同一对象) |
可为 null | 默认不可以(int? 可以) | 可以 |
| 存放位置 | 通常是栈,或包含它的对象字段里 | 托管堆 |
| 继承 | 隐式继承 System.ValueType,不能自定义继承 | 支持继承 |
| 相等性默认 | 逐字段比较(ValueType.Equals) | 引用相等(Object.ReferenceEquals) |
| 典型用途 | 小数据、数学值、性能敏感 | 有身份、有生命周期的大对象 |
"栈和堆"到底指什么? 精确的说法是:
- 栈(Stack):每个线程一个,存局部变量和调用帧。方法返回时帧被弹出,所以栈上的数据不需要 GC。栈很小(默认 1 MB 左右),放不下大对象。
- 托管堆(Managed Heap):所有线程共享,存引用类型对象,由垃圾回收(Garbage Collection, GC)负责回收。
- 关键细节:值类型不一定在栈上。如果它是某个类的字段、或是数组的元素、或是被装箱、或是 lambda 的闭包捕获,它就活在堆上。所以严格的说法是"值类型内联存储在它所属的位置",而不是"值类型在栈上"。
// 值语义:赋值即复制,两份数据互不影响
struct Point { public int X; public int Y; }
Point a = new Point { X = 1, Y = 2 };
Point b = a; // 复制了 8 个字节
b.X = 99;
Console.WriteLine(a.X); // 1 —— a 没被改动
// 引用语义:赋值即复制引用,指向同一个对象
class Box { public int X; public int Y; }
Box c = new Box { X = 1, Y = 2 };
Box d = c; // 只复制了引用(地址)
d.X = 99;
Console.WriteLine(c.X); // 99 —— c 和 d 是同一个对象
为什么这么设计? 值类型给"纯数据"(坐标、金额、复数)提供低开销的复制语义;引用类型给"有身份的对象"(用户、连接、窗口)提供共享语义。选错了会出现两类 bug:用 struct 表示可变的大对象 → 改了半天改的是副本;用 class 表示数学值 → 两个"相等的点"却不 ==。
装箱与拆箱(Boxing / Unboxing)
把值类型转成 object(或它实现的接口)叫装箱:在堆上分配一个包装对象,把值复制进去。反向叫拆箱:检查类型后把值复制出来。
int n = 42;
object boxed = n; // 装箱:堆分配 + 复制(有 GC 压力)
int back = (int)boxed; // 拆箱:类型检查 + 复制
// 更隐蔽的装箱:ArrayList 只接受 object
var legacy = new System.Collections.ArrayList();
legacy.Add(1); // 装箱
legacy.Add(2); // 装箱
int sum = 0;
foreach (int x in legacy) // 每次迭代都拆箱
sum += x;
// 现代写法:List<int> 是泛型,元素就是 int 本身,全程无装箱
var modern = new List<int> { 1, 2 };
| 场景 | 是否装箱 |
|---|---|
int → object / interface | 是 |
List<int> 存取元素 | 否(泛型在运行时有专属代码) |
string.Format("{0}", 1) | 是(参数是 object) |
$"{1}" 插值(int) | 通常否,C# 10+ 用 DefaultInterpolatedStringHandler 直接写字符 |
enum 用作 Dictionary<TKey,...> 的键 | 否(泛型);用非泛型 Hashtable 则是 |
避免装箱的三种手段
1. 用泛型集合替代
ArrayList/Hashtable:List<int>、Dictionary<MyEnum, string>。2. 接口约束也要泛型:
void Foo<T>(T x) where T : IComparable<T>不装箱;写成void Foo(IComparable x)传int就装箱。3. 比较时用泛型接口:
EqualityComparer<T>.Default而不是object.Equals(a, b)。装箱本身是 ,但每次分配都增加 GC 压力;在每秒百万次的热路径上,它是可测量的性能问题。
3.5 可空值类型 int?
值类型默认不能为 null(因为它没有"空引用"的概念)。int? 是 System.Nullable<T> 的语法糖,给值类型加一个 HasValue 标志位。
int? maybeAge = null; // 等价于 Nullable<int> maybeAge = null
if (maybeAge.HasValue) // 显式检查
Console.WriteLine(maybeAge.Value);
// 或者用模式匹配一次完成"判空 + 取值"
if (maybeAge is int age)
Console.WriteLine($"年龄 {age}");
// 空合并运算符:左边为 null 时取右边
int display = maybeAge ?? 0;
// 空合并赋值:仅在为 null 时赋值
maybeAge ??= 18;
// 对可空类型做算术:结果仍是可空;null 会向上传播
int? a = 5, b = null;
Console.WriteLine(a + b); // 输出空行——表达式的值是 null
Console.WriteLine(a + b ?? -1); // -1
| 表达式 | 语义 | 结果 |
|---|---|---|
x.HasValue | 是否有值 | bool |
x.Value | 取值;null 时抛 InvalidOperationException | T |
x ?? d | 为 null 时用默认值 | T |
x ??= d | 为 null 时赋值 | — |
x?.Member | 有值才访问成员,否则 null | 可空 |
x.GetValueOrDefault() | 取值或 default(T),不抛异常 | T |
可空值类型 ≠ 可空引用类型
int?是运行时概念(真的多一个标志位)。string?(C# 8 起的可空引用类型)只是编译期静态分析的注解,运行时里string和string?完全一样。详见 CSharp-06-现代CSharp特性。
3.6 const 与 readonly
| 对比项 | const | readonly(字段) | static readonly |
|---|---|---|---|
| 求值时机 | 编译期 | 运行期(构造时) | 运行期(类型初始化时) |
| 允许的类型 | 只能是编译期常量(基元类型、string、enum、null) | 任意类型 | 任意类型 |
能否用 new 初始化 | 不能 | 能 | 能 |
| 存储位置 | 调用处内联替换(literal) | 字段本身 | 静态字段 |
| 跨程序集版本问题 | 有(见下) | 无 | 无 |
| 可变对象的成员 | 不适用 | 引用不可变,内容仍可变 | 同左 |
public class Limits
{
// 编译期常量:所有引用它的代码里会被替换成字面量 100
public const int MaxRetries = 100;
// 运行期常量:可以在构造时计算,可以 new
public static readonly DateTime Epoch = new(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
public static readonly string MachineName = Environment.MachineName;
// readonly 只锁住"引用",不锁住对象内容
public readonly List<int> Buffer = new();
public void Add(int v) => Buffer.Add(v); // 合法:没有重新赋值
// public void Reset() => Buffer = new(); // 编译错误:不能给 readonly 字段赋值
}
const的跨程序集陷阱
public const int MaxRetries = 100;被编译进调用方的程序集。如果 A 程序集引用 B 的MaxRetries,之后把 B 里的值改成200并只重新编译 B,A 仍然用着100——必须重编译 A 才生效。公共 API 里优先用
static readonly;const只用于永远不变的真常量(如Math.PI那类、或private const)。
3.7 类型转换:四种手段的安全等级
| 手段 | 语法 | 失败行为 | 适用场景 |
|---|---|---|---|
| 隐式转换 | long x = 5; | 不存在失败 | 无精度损失的加宽转换 |
| 显式转换(强制) | int y = (int)3.9; | 编译通过,可能溢出/截断(unchecked 下静默) | 确定安全时的窄化 |
Convert.ToXxx | Convert.ToInt32("42") | 抛 FormatException / OverflowException | 已有可信数据,失败即 bug |
Parse | int.Parse("42") | 同上 | 同上,类型化更直接 |
TryParse | int.TryParse(s, out var v) | 返回 false,不抛异常 | 用户输入、外部数据 —— 首选 |
as + 判空 | var s = o as string; | 失败返回 null | 引用类型、可空值类型 |
using System.Globalization;
// 1) 用户输入 → 永远用 TryParse,别用异常做流程控制
string input = "12abc";
if (int.TryParse(input, NumberStyles.Integer, CultureInfo.InvariantCulture, out int parsed))
Console.WriteLine(parsed);
else
Console.WriteLine("不是合法整数"); // 走这里,且没有异常开销
// 2) 浮点数解析要指定区域性:某些区域用逗号做小数点
bool ok = double.TryParse("3.14", NumberStyles.Float,
CultureInfo.InvariantCulture, out double pi);
// 3) 引用类型向下转型:as 失败给 null,强制转换失败抛 InvalidCastException
object o = "hello";
string? s1 = o as string; // "hello"
string s2 = (string)o; // 也可以
// int bad = (int)o; // 运行期抛 InvalidCastException
// 4) 溢出检查:checked 让静默溢出变成 OverflowException
int big = int.MaxValue;
unchecked { Console.WriteLine(big + 1); } // -2147483648(回绕)
try { checked { Console.WriteLine(big + 1); } }
catch (OverflowException) { Console.WriteLine("溢出被捕获"); }
// 5) 现代模式匹配转换,比 as + 判空更简洁
if (o is string text && text.Length > 0)
Console.WriteLine(text.ToUpperInvariant());
数值转换的三种"静默错误"
1.
(int)3.99得到3(向零截断),不是四舍五入。要四舍五入用Math.Round(并注意它的银行家舍入:Math.Round(2.5)是2;要"四舍五入"用MidpointRounding.AwayFromZero)。2.
(int)double.NaN在unchecked下得到0或int.MinValue(平台相关),务必先判double.IsNaN。3.
int.Parse("")抛FormatException;Convert.ToInt32(null)返回0而不是抛异常——空值与null的处理策略不同。
3.8 字符串:不可变性的后果
string 是不可变(immutable)的引用类型:任何"修改"操作都返回新字符串。
string a = "hello";
string b = a.ToUpperInvariant(); // 新对象,a 本身不变
Console.WriteLine($"{a} / {b}"); // hello / HELLO
// 每次 += 都新建一个字符串:n 次拼接产生 O(n^2) 的字节复制量
string slow = "";
for (int i = 0; i < 10_000; i++)
slow += i.ToString(); // 每次都重新分配 + 复制前缀
// StringBuilder 内部是可扩容的字符缓冲区,追加是均摊 O(1)
var sb = new System.Text.StringBuilder(capacity: 10_000); // 预设容量可避免扩容
for (int i = 0; i < 10_000; i++)
sb.Append(i);
string fast = sb.ToString();
拼接 个片段的代价对比(设每次总长近似为 ):
| 场景 | 推荐做法 |
|---|---|
| 固定几个片段 | + 或 $""(编译器常合并为一次 String.Concat) |
| 循环内累积(次数未知或很多) | StringBuilder |
| 拼接集合元素 | string.Join(separator, items) |
| 只判断/查找/替换少量内容 | Contains / IndexOf / Replace(注意 Replace 也返回新串) |
| 高性能解析、避免分配 | ReadOnlySpan<char> + string.Create(见 [[CSharp-06-现代CSharp特性]]) |
插值字符串、逐字字符串、原始字符串
string name = "阿伟";
int score = 95;
// 插值字符串:可读性最好,且不像 string.Format 那样装箱
Console.WriteLine($"{name} 得分 {score},等级 {(score >= 90 ? "A" : "B")}");
// 插值里对齐与格式:,10 表示右对齐宽度 10,:F2 表示两位小数
Console.WriteLine($"[{score,10:F2}]");
// 逐字字符串(verbatim,@ 前缀):不处理转义,可跨行;内部双引号写成 ""
string path = @"C:\logs\app";
string multi = @"第一行
第二行";
// 原始字符串字面量(Raw string literal,C# 11+):多行、无需转义、缩进自动剥离
string json = """
{
"name": "阿伟",
"tags": ["csharp", "dotnet"]
}
""";
Console.WriteLine(json);
// 内容里需要出现三个连续引号时,用四个引号来界定(开闭定界符必须一样长)
string quotes = """" 他说 """你好""" 内容结束 """";
什么时候一定要用原始字符串
写 JSON、正则表达式、SQL、Windows 路径时。对比一下可读性:
"C:\\logs\\" + "\\d{2}"→@"C:\logs\" + @"\d{2}"→"""C:\logs\\d{2}"""(原始字符串里反斜杠就是反斜杠)。注意:$"""..."""
,此时用{{ }}` 表示插值,方便在 JSON 里写花括号。
3.9 运算符与优先级
| 优先级(高 → 低) | 运算符 | 结合性 | ||
|---|---|---|---|---|
| 1 | x.y、f(x)、a[i]、x++/x--(后缀)、new、typeof、nameof、?.、!(null 包容) | 左 | ||
| 2 | +x、-x、!x、~x、++x/--x(前缀)、(T)x | 右 | ||
| 3 | *、/、% | 左 | ||
| 4 | +、- | 左 | ||
| 5 | <<、>>、>>> | 左 | ||
| 6 | <、>、<=、>=、is、as | 左 | ||
| 7 | ==、!= | 左 | ||
| 8 | &(按位与 / 逻辑与,bool 上不短路) | 左 | ||
| 9 | ^ | 左 | ||
| 10 | `\ | ` | 左 | |
| 11 | && | 左 | ||
| 12 | `\ | \ | ` | 左 |
| 13 | ?? | 右 | ||
| 14 | ?:(三元) | 右 | ||
| 15 | =、+=、??= 等赋值 | 右 |
// 位运算:判断奇偶比 % 更快,但可读性优先,除非在热路径
bool isOdd = (n & 1) == 1;
// 逻辑运算符的短路特性常常就是正确性的一部分
if (list != null && list.Count > 0) { /* 安全:前半为假就不会访问 Count */ }
// 位标志组合(配合 [Flags] 枚举,见 CSharp-02)
var options = FileOptions.A | FileOptions.B;
bool hasA = (options & FileOptions.A) != 0;
// 三元与 ?? 的优先级陷阱:?? 比 ?: 高,但混合时务必加括号
int v = (maybe ?? 0) > 0 ? 1 : -1;
最容易出错的三个优先级问题
1.
a & b与a && b:对bool而言前者不短路,x != null & x.Length > 0会抛NullReferenceException。2.
1 + 2 * 3是7不是9——这不是 C# 的坑,但配合??、?:、is混用时极易读错。3.
&&和||的优先级:a || b && c等价于a || (b && c)。拿不准就加括号,括号不要钱。
3.10 流程控制
int score = 87;
// if / else if / else:分支少时最直观
if (score >= 90) Console.WriteLine("A");
else if (score >= 80) Console.WriteLine("B");
else Console.WriteLine("C");
// switch 语句:分支多、判断同一个表达式时更清晰;必须有 break/return/goto 结尾
switch (score / 10)
{
case 10:
case 9:
Console.WriteLine("A"); // 多个标签共用一个分支
break;
case 8:
Console.WriteLine("B");
break;
default:
Console.WriteLine("C");
break;
}
// switch 表达式(C# 8+):返回值、无贯穿、可配合模式
string grade = score switch
{
>= 90 => "A",
>= 80 => "B",
>= 70 => "C",
_ => "D" // _ 是弃元:兜底分支
};
Console.WriteLine(grade);
// 循环三兄弟
for (int i = 0; i < 3; i++) Console.Write(i); // 计数循环,索引可控
int j = 0;
while (j < 3) { Console.Write(j); j++; } // 条件循环,次数未知
int k = 0;
do { Console.Write(k); k++; } while (k < 3); // 至少执行一次
// break 结束整个循环;continue 跳过本次迭代
foreach (int v in new[] { 1, 2, 3, 4, 5 })
{
if (v == 2) continue; // 跳过 2
if (v == 4) break; // 到 4 就整体结束
Console.Write(v); // 输出 1 3
}
| 场景 | 推荐 | 理由 |
|---|---|---|
| 2–3 个分支 | if / 三元 | 最短最直白 |
| 同值多分支、需要副作用 | switch 语句 | 编译器会做跳转表优化 |
| 同值多分支、需要结果 | switch 表达式 | 强制穷尽、无贯穿、可表达式化 |
| 模式判断(类型、属性、范围) | switch 表达式 + 模式 | 见 [[CSharp-06-现代CSharp特性]] |
| 遍历集合 | foreach | 无需手写下标,也不易越界 |
| 需要下标或反向 | for | foreach 不暴露下标 |
3.11 数组与 foreach 的实现原理
// 一维数组:长度固定,索引 O(1),元素连续存储(缓存友好)
int[] numbers = new int[5]; // 全部元素为 0
int[] literal = { 1, 2, 3 }; // 隐式长度
int[] init = new int[] { 1, 2, 3 };
int[] modern = [1, 2, 3]; // 集合表达式(C# 12+)
// 二维数组(矩形数组):每行长度相同
int[,] grid = new int[2, 3];
grid[1, 2] = 7;
Console.WriteLine(grid.GetLength(0)); // 2 —— 用 GetLength 而不是 Length
// 交错数组(jagged):数组的数组,每行长度可不同
int[][] jagged = [new[] { 1 }, new[] { 2, 3 }];
Console.WriteLine(jagged[1][1]); // 3
// 常用成员
Console.WriteLine(numbers.Length); // 5
Array.Sort(literal); // 原地排序,O(n log n)
Array.Reverse(literal);
int idx = Array.IndexOf(literal, 2); // 找不到返回 -1
Array.Clear(numbers); // 清零
foreach 不是语法糖到"下标循环",而是糖到枚举器模式。编译器把下面的 foreach:
foreach (int v in numbers)
Console.WriteLine(v);
改写成(概念上的等价形式):
// 编译器生成的等价代码(示意)
var e = numbers.GetEnumerator(); // 1) 取枚举器
try
{
while (e.MoveNext()) // 2) 逐个前进
{
int v = e.Current; // 3) 取当前元素
Console.WriteLine(v);
}
}
finally
{
(e as IDisposable)?.Dispose(); // 4) 若枚举器可释放则释放(如文件、DB 游标)
}
三点关键含义:
- 可枚举不等于实现
IEnumerable。foreach用的是"模式匹配":只要类型有公开的GetEnumerator(),且返回类型有MoveNext()与Current,就能foreach。数组就是靠这个特例(SZArrayHelper)避免装箱的。 - 遍历中不能修改集合。
List<T>的枚举器带_version字段,Add/Remove会让版本号加一,下次MoveNext抛InvalidOperationException: Collection was modified。 foreach的迭代变量是只读的(in语义,C# 8+ 起对struct还能加ref readonly),不能v = 10;。想在遍历中改数组内容,用for。
var list = new List<int> { 1, 2, 3 };
try
{
foreach (int v in list)
list.Add(v); // 抛 InvalidOperationException
}
catch (InvalidOperationException ex)
{
Console.WriteLine(ex.Message);
}
// 正确做法一:先收集要改的内容,遍历结束后统一应用
var toAdd = new List<int>();
foreach (int v in list) toAdd.Add(v * 10);
list.AddRange(toAdd);
// 正确做法二:需要边遍历边删就倒着用 for
for (int i = list.Count - 1; i >= 0; i--)
if (list[i] % 2 == 0) list.RemoveAt(i);
四、怎么用:一个可运行的完整示例
下面这个程序把本篇的核心点串起来:顶级语句、可空类型、TryParse 安全解析、switch 表达式、StringBuilder、数组与 foreach。
// 文件名:Program.cs;项目:dotnet new console -n GradeBook
using System.Globalization;
using System.Text;
// 一组原始分数,其中混入了非法输入——真实数据总是脏的
string[] rawScores = ["95", "87", "abc", "72", "100", ""];
var valid = new List<int>(); // 泛型集合:不会装箱
var invalid = new List<string>();
foreach (string raw in rawScores)
{
// TryParse 而不是 Parse:非法输入是可预期的业务分支,不该用异常表达
if (int.TryParse(raw, NumberStyles.Integer, CultureInfo.InvariantCulture, out int s)
&& s is >= 0 and <= 100) // 模式匹配同时完成两次范围判断
{
valid.Add(s);
}
else
{
invalid.Add(string.IsNullOrWhiteSpace(raw) ? "(空)" : raw);
}
}
// switch 表达式把"分数 → 等级"的映射写成一个值,天然无贯穿
static string ToGrade(int score) => score switch
{
>= 90 => "A",
>= 80 => "B",
>= 70 => "C",
>= 60 => "D",
_ => "F",
};
// StringBuilder:循环内累积文本,避免 O(n^2) 的字符串复制
var report = new StringBuilder();
foreach (int s in valid)
report.AppendLine($"{s,4} → {ToGrade(s)}");
double avg = valid.Count > 0 ? valid.Sum() / (double)valid.Count : 0.0;
Console.WriteLine(report.ToString());
Console.WriteLine($"有效 {valid.Count} 条,无效 {invalid.Count} 条:{string.Join(", ", invalid)}");
Console.WriteLine($"平均分 {avg:F2},最高 {valid.Max()}");
关键行解释:
int.TryParse(...)放在if里:解析成功才继续,失败走else,不用 try/catch 做流程控制(异常在 .NET 里很贵,且会掩盖真正的 bug)。s is >= 0 and <= 100:关系模式(relational pattern),比s >= 0 && s <= 100更紧凑,且不会写错成0 <= s <= 100(那在 C# 里是编译错误,但在 C 里是经典 bug)。valid.Sum() / (double)valid.Count:注意(double)强制转换放在除法前,否则会做整数除法丢掉小数。report.AppendLine(...)用StringBuilder而不是+=:循环体内的字符串拼接是性能杀手。
运行:
dotnet new console -n GradeBook
# 用上面的内容替换 Program.cs
cd GradeBook
dotnet run
预期输出(节选):
95 → A
87 → B
72 → C
100 → A
有效 4 条,无效 2 条:abc, (空)
平均分 88.50,最高 100
五、注意事项与常见坑
新手最高频的十个坑
1. 用
double算钱:0.1 + 0.2 != 0.3。金额一律decimal,并且字面量要带m。2. 整数除法丢精度:
5 / 2 == 2。要么先转double/decimal,要么用Math.DivRem。3.
int.Parse处理用户输入:非法输入直接抛异常。外部数据一律TryParse。4.
string +=放在循环里:。累积用StringBuilder或string.Join。5. 遍历中修改集合:抛
InvalidOperationException。倒序for或先收集再改。6.
const用作公共 API:调用方内联了值,改库不重编译调用方不生效。公共 API 用static readonly。7. 以为值类型都在栈上:类字段里的
struct、数组元素、闭包捕获的struct都在堆上。8.
(int)强转掩盖溢出:默认unchecked会静默回绕。关键计算用checked或改宽类型。9. 用
==比较字符串却忽略区域性:默认==是序数(ordinal)比较,这通常是你要的;但ToLower() == "abc"这种写法在土耳其语区域会出 bug,用string.Equals(a, b, StringComparison.OrdinalIgnoreCase)。10.
switch语句忘写break:C# 不允许隐式贯穿,编译会报错——这是好事,但迁移自 C/C++ 的人会不适应。
工程实践建议
- 新项目一律
<Nullable>enable</Nullable>+<TreatWarningsAsErrors>true</TreatWarningsAsErrors>,把"可能为 null"变成编译期问题。- 用
dotnet format和.editorconfig统一风格,CI 里用dotnet format --verify-no-changes卡住。- 数值输入边界一律显式校验范围,别指望类型转换替你做业务校验。
- 学习期多用
dotnet script式的短程序验证行为,别靠记忆猜。
六、练习题
- 基础题:写一个程序,把用户输入的一行以空格分隔的数字求和,忽略非法片段,最后输出总和与非法片段个数。要求用
TryParse、StringBuilder,并对空输入给出提示。 - 基础题:给定
int[] data = { 3, 1, 4, 1, 5, 9, 2, 6 },用switch表达式实现一个Describe(int)方法:负数返回"负",0返回"零",1..9返回"个位",其余返回"大数";再用foreach打印每个元素的描述。 - 进阶题:实现
bool TryAverage(int[] values, out double avg),要求:数组为null或长度为 0 时返回false且avg = 0;否则用long累加避免int溢出,返回真实平均值(注意整数除法陷阱)。 - 进阶题:解释并验证下面代码的输出,然后改成正确版本:
```csharp
object o = 42;
Console.WriteLine(o == (object)42); // ?
Console.WriteLine((int)o == 42); // ?
Console.WriteLine(o.ToString() == "42");
```
提示:先想清楚哪一步发生装箱、object 的 == 比较的是什么。
- 思考题:为什么
string要设计成不可变?请从线程安全、哈希表键的稳定性、字符串驻留(interning)、安全(作为路径/连接串传入时不被篡改) 四个角度各写一句话。再举一个不可变性带来成本的场景。
七、常见问题(FAQ)
Q1:.NET 10 和 C# 13 是什么关系?我需要分别安装吗?
A:不需要分别安装。C# 版本由编译器决定,编译器随 SDK 一起发布;.NET 10 指运行时与 BCL 的版本。装一个 .NET SDK 10.0.401,就同时得到了对应版本的 C# 编译器和 net10.0 的 BCL。你也可以通过 <LangVersion> 用旧语法编译,或在旧 SDK 上(受限于该 SDK 支持的 C# 版本)用新语法。语言与框架版本对照表见 C# 语言版本(以官方最新文档为准)。
Q2:var 是不是"弱类型"?会不会影响性能?
A:都不是。var 只是让编译器替你写类型名,编译后的 IL 与显式写类型完全一致,没有额外开销。它也不是动态类型:var x = 1; 之后 x 就是 int,赋 string 会编译报错。真正的动态类型是 dynamic(运行期解析,有反射开销)。
Q3:int? 和 Nullable<int> 有什么区别?为什么 int? 不能直接和 int 相加?
A:完全等价,int? 是 System.Nullable<int> 的语法糖。int? 与 int 混用时会先做"提升"(lifting):运算符被提升到可空版本,null + 1 的结果是 null 而不是异常。所以 int? a = null; int b = a + 1; 会编译报错(不能把 int? 隐式赋给 int),而 int? c = a + 1; 合法且 c 为 null。
Q4:为什么我的 foreach 遍历 List<T> 时 Remove 会抛异常,但遍历数组时改元素却没问题?
A:两者的枚举器实现不同。List<T> 的枚举器为了保护一致性维护了版本号(_version),结构变化(Add/Remove/Clear)会让 MoveNext 抛 InvalidOperationException。数组没有枚举器对象(编译器走索引特例),修改元素值不改变长度,因此不会触发检查;但 foreach 的迭代变量本身是只读的,要改元素得用 for。
相关笔记
- CSharp-02-面向对象:类型系统之上的类、struct、record、接口与多态
- CSharp-03-集合与LINQ:泛型集合、迭代器与查询,
foreach的进阶用法 - CSharp-07-dotnet项目与工具链:
.csproj、NuGet、构建与发布、AOT/JIT 的选择 - 编程语言对比:C# 与 Python、JavaScript 在类型与运行方式上的差异
- 计算机组成原理:栈、堆、CPU 缓存与 IL/JIT 的硬件视角
参考来源
- Common Language Runtime (CLR) overview
- .NET architectural components
- dotnet command
- C# built-in types
- Top-level statements
- Boxing and unboxing
- Nullable value types
- Raw string literals
- string and reference types
- Parsing numeric strings
- Download .NET
- .NET Support Policy
- 说明:语言版本、SDK 版本号、支持周期等信息易过时,以官方最新文档为准。