w wyl123ly 的博客
MD

CSharp-01-环境与基础语法

46 KB 2026.10.11 原文件

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 的存在换来四件事:

  1. 跨平台:IL 与 CPU 无关,同一份程序集在 x64、Arm64、Linux、Windows 上都能跑,JIT 在目标机器上生成对应机器码。
  2. 跨语言:C#、F#、VB.NET 都编译成 IL,可以互相引用——F# 写的库能被 C# 直接 using。
  3. 运行时优化:JIT 知道真实 CPU 特性(AVX2、AVX-512)和真实调用热点,可以做"运行时特化",这在编译期是拿不到的信息。
  4. 安全与自描述: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)
首发年份200220162020 起,每年 11 月一个大版本
平台支持仅 WindowsWindows / Linux / macOS同上,另含容器、WASM、移动端(经 .NET MAUI)
交付方式随 Windows 系统组件独立安装、可并排独立安装、可并排,支持自包含发布
开源部分完全开源(MIT)完全开源
项目文件复杂 MSBuild,需逐文件列出SDK 风格,隐式包含源文件SDK 风格(延续至今)
包管理packages.config / NuGetNuGet(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.shCI 环境、无管理员权限
# 一次性把 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小项目开启;库项目可关闭以免污染
TreatWarningsAsErrorsfalseCI 里设 true,让警告无法被忽略
InvariantGlobalizationfalse容器里可设 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 类型字节取值范围默认值字面量示例
sbyteSystem.SByte1 ~ 0(sbyte)-1
byteSystem.Byte1 ~ 0(byte)200
shortSystem.Int162 ~ 0(short)-5
ushortSystem.UInt162 ~ 0(ushort)60000
intSystem.Int324 ~ 042
uintSystem.UInt324 ~ 042u
longSystem.Int648 ~ 0L42L
ulongSystem.UInt648 ~ 0UL42UL
nintSystem.IntPtr平台相关32/64 位指针宽度0(nint)1
floatSystem.Single4 ~ ,7 位有效数字0f1.5f
doubleSystem.Double8 ~ ,15–17 位有效数字0d1.5
decimalSystem.Decimal16 ~ ,28–29 位有效数字0m19.99m
boolSystem.Boolean1true / falsefalsetrue
charSystem.Char2UTF-16 码元 U+0000 ~ U+FFFF'\0''A'、'\n'、'\u4E2D'
stringSystem.String引用类型不可变 Unicode 序列null"hi"、@"C:\t"
objectSystem.Object引用类型所有类型的根nullnew 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、ValueTupleclass、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 时抛 InvalidOperationExceptionT
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

对比项constreadonly(字段)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.ToXxxConvert.ToInt32("42")抛 FormatException / OverflowException已有可信数据,失败即 bug
Parseint.Parse("42")同上同上,类型化更直接
TryParseint.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 运算符与优先级

优先级(高 → 低)运算符结合性
1x.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无需手写下标,也不易越界
需要下标或反向forforeach 不暴露下标

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 游标)
}

三点关键含义:

  1. 可枚举不等于实现 IEnumerable。foreach 用的是"模式匹配":只要类型有公开的 GetEnumerator(),且返回类型有 MoveNext() 与 Current,就能 foreach。数组就是靠这个特例(SZArrayHelper)避免装箱的。
  2. 遍历中不能修改集合。List<T> 的枚举器带 _version 字段,Add/Remove 会让版本号加一,下次 MoveNext 抛 InvalidOperationException: Collection was modified。
  3. 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 式的短程序验证行为,别靠记忆猜。


六、练习题

  1. 基础题:写一个程序,把用户输入的一行以空格分隔的数字求和,忽略非法片段,最后输出总和与非法片段个数。要求用 TryParse、StringBuilder,并对空输入给出提示。
  2. 基础题:给定 int[] data = { 3, 1, 4, 1, 5, 9, 2, 6 },用 switch 表达式实现一个 Describe(int) 方法:负数返回 "负",0 返回 "零",1..9 返回 "个位",其余返回 "大数";再用 foreach 打印每个元素的描述。
  3. 进阶题:实现 bool TryAverage(int[] values, out double avg),要求:数组为 null 或长度为 0 时返回 false 且 avg = 0;否则用 long 累加避免 int 溢出,返回真实平均值(注意整数除法陷阱)。
  4. 进阶题:解释并验证下面代码的输出,然后改成正确版本:

```csharp

object o = 42;

Console.WriteLine(o == (object)42); // ?

Console.WriteLine((int)o == 42); // ?

Console.WriteLine(o.ToString() == "42");

```

提示:先想清楚哪一步发生装箱、object 的 == 比较的是什么。

  1. 思考题:为什么 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 的硬件视角

参考来源