一个同事排查了半天,最后发现只改错了一行。他把一个表示「分页参数」的结构体传进方法,方法里把页码加了一,方法返回后一看,页码还是原来的值。他以为是编译器出了毛病,其实是 C# 最基本的规则在起作用:这个结构体是按值复制的,方法里拿到的是另一份。
这类问题不会报错,也不会有警告,只会让你在日志里看到一个「怎么没变」的结果。C# 的类型系统比很多语言更强调「值」和「引用」的区别,写业务代码时感觉不到,一旦遇到结构体、字符串、可空类型和金额计算,这些区别就全冒出来了。
这篇先把地基铺好:代码在 C# 里怎么被命名空间和程序集组织起来;值类型和引用类型在内存里到底差在哪;struct 的复制会带来哪些反直觉的结果;string 为什么改不动;算钱为什么不能用 double;可空类型在判空时要注意什么。讲完这些,后面几篇的集合、LINQ、异步才有落脚点。所有示例都在本机 .NET 8 控制台项目里跑过,命令和输出照实贴出。
先看那个「改了却没生效」的结构体
把当时的场景还原成一个最小例子。定义一个坐标结构体,给它一个把 X 加一的方法,然后把它放进列表,直接对列表元素调用这个方法:
using System;
using System.Collections.Generic;
struct Counter { public int Value; public void Add() { Value++; } }
class Program
{
static void Main()
{
var list = new List<Counter> { new Counter() };
list[0].Add();
Console.WriteLine($"after Add: {list[0].Value}");
var c = list[0];
c.Add();
Console.WriteLine($"after copy Add: {list[0].Value}, copy={c.Value}");
}
}
本机运行结果:
after Add: 0
after copy Add: 0, copy=1
第一次调用 list[0].Add(),输出是 0。这不是方法没执行,而是 List<Counter> 的索引器返回的是列表内部那个结构体的副本,方法在副本上把 Value 加到了 1,副本用完就扔了,列表里原来的元素一点没变。把元素取出来赋给变量 c 之后再调用,c.Value 变成 1,但 list[0].Value 仍然是 0。
如果你试的不是调用方法,而是直接赋值 list[0].Value = 5,编译器会直接拦住,给出这样的错误:
error CS1612: 无法修改“List<Counter>.this[int]”的返回值,因为它不是变量
这条错误信息比很多文档都直白:索引器返回的不是变量,只是一个值。要改,就得先取出来、改完、再写回去,或者把列表元素类型换成类。这个细节在写小型值对象时非常容易踩,尤其是从别的语言转过来、习惯了「对象引用一改全改」的人。
命名空间和程序集:C# 代码的两层包装
在讲类型之前,先把「代码放在哪」说清楚。C# 里有两个经常被混在一起的概念:命名空间和程序集。
很多人第一次遇到「命名空间找不到」时,会去翻文件夹,其实方向错了。报错 找不到类型或命名空间名称 通常只有两种原因:要么 using 写错或者漏了,要么项目根本没有引用包含这个类型的程序集。前者改一行就能解决,后者要去检查项目引用或者包引用。
命名空间可以嵌套,写法上用点号分隔,例如 MyApp.Core.Models。它不是物理目录,你完全可以把 MyApp.Core.Models 下的类写在任意一个文件夹里,编译器不在乎。但实际项目一般会让目录结构和命名空间大致对应,否则后面找文件会非常痛苦。
值类型和引用类型,差别不在「有没有 new」
初学 C# 最容易记住的一句话是「值类型存在栈上,引用类型存在堆上」。这句话大致对,但不准确,也不足以解释你遇到的行为。更实用的说法是:值类型的变量里直接装着数据,赋值时复制这份数据;引用类型的变量里装着一个地址,赋值时复制的是地址,两个变量指向同一份数据。
看一个最小的对照:
值类型
包括整数、浮点数、bool、char、decimal、struct、枚举。赋值 b = a 之后,改 b 不会影响 a。方法传参默认也是复制,方法里怎么改都不影响调用方,除非用 ref 或 out。
引用类型
包括 class、interface、数组、委托、string。赋值 b = a 之后,两个变量指向同一个对象,通过 b 改字段,a 也看得到。方法传参复制的是地址,所以方法里能改到调用方的对象。
内存位置只是结果,不是规则本身。一个值类型如果作为类的字段,它也跟着对象住在堆上;一个引用类型里的数组,数据也在堆上。栈和堆的说法容易让人以为「值类型一定快、引用类型一定慢」,这不成立。真正要记的是复制行为和相等判断。
相等判断是另一个高频坑。C# 里 == 对值类型比较的是内容,对引用类型默认比较的是地址。string 是个例外,它重写了相等比较,所以两个内容相同的字符串用 == 会得到 true。自定义类如果没有重写 Equals 和 ==,那么两个字段完全一样的对象也会被判为不相等。
using System;
struct Point { public int X; public int Y; }
class User { public string Name = ""; }
class Program
{
static void Main()
{
var a = new Point { X = 1, Y = 2 };
var b = a;
b.X = 99;
Console.WriteLine($"a.X={a.X} b.X={b.X}");
double sum = 0;
for (int i = 0; i < 10; i++) sum += 0.1;
Console.WriteLine($"double: {sum}");
decimal dsum = 0m;
for (int i = 0; i < 10; i++) dsum += 0.1m;
Console.WriteLine($"decimal: {dsum}");
var s1 = new string('a', 3);
var s2 = "aaa";
Console.WriteLine($"string == : {s1 == s2}");
var u1 = new User { Name = "z" };
var u2 = new User { Name = "z" };
Console.WriteLine($"class == : {u1 == u2}");
int? maybe = null;
Console.WriteLine($"has value : {maybe.HasValue}, default: {maybe.GetValueOrDefault()}");
}
}
本机运行输出:
a.X=1 b.X=99
double: 0.9999999999999999
decimal: 1.0
string == : True
class == : False
has value : False, default: 0
这五段输出把这一篇的几个重点全点到了:结构体赋值是复制;double 累加十分之一会出尾差,decimal 不会;内容相同的字符串 == 为 true;内容相同的自定义类 == 为 false;可空整数没赋值时 HasValue 是 false,GetValueOrDefault() 给出 0。
struct 的复制语义会咬人的几个地方
struct 本身不是坏东西。它适合表示小而短命的数据,比如坐标、范围、金额包装、颜色值。它的价值在于没有堆分配、没有垃圾回收压力。但只要它里面字段多、或者被放进集合、或者跨方法传递,复制语义就会带来额外开销和反直觉行为。
下面这张表是真实项目里反复出现的现象,遇到时可以直接对照:
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 方法里改了结构体参数,调用方没变化 | 值传递,方法拿到的是副本 | 看方法签名是否用了 ref 或 out,或者方法是否返回了新值 |
| 对集合里的结构体调用修改方法没效果 | 索引器返回副本,方法改的是临时值 | 先把元素取到局部变量,改完再写回集合 |
两个字段相同的对象 == 为 false | 类默认按引用比较,没有重写相等逻辑 | 检查类是否重写 Equals 和 GetHashCode |
| 金额累加出现 0.999999 这样的尾差 | double 用二进制表示十进制小数,无法精确 | 把金额类型改成 decimal,并检查数据库字段类型 |
| 循环里拼接字符串后内存暴涨 | string 不可变,每次拼接都新建一个字符串 | 改用 StringBuilder,或者用 string.Join |
可空整数直接 .Value 抛异常 | 值为 null 时访问 Value 会抛 InvalidOperationException | 先判断 HasValue,或用 ?? 给默认值 |
| 结构体作为字典键,改字段后查不到 | 哈希值在放入时算好,字段变了但字典里的位置没变 | 键类型改成不可变,或者不要修改作为键的对象 |
| 反序列化后日期差了几个小时 | DateTime 的 Kind 信息在传输中丢失,被当成本地时间 | 检查序列化格式里有没有时区,统一用 UTC 存储 |
其中「结构体做字典键」值得单独说一句。字典靠哈希值定位,结构体放进字典时哈希值已经算好并存在桶里。你之后修改了这个结构体的字段,再拿它去查,计算出的哈希值和当初存进去的不一样,字典就会找不到。类作为键也一样,只要键的内容参与哈希计算,改了就查不到。正确做法是让键不可变,或者改完之后先删再插。
string 为什么「改不动」
string 是引用类型,但它的内容不可变。任何看起来在修改字符串的操作,例如 Replace、Trim、ToUpper、+,实际上都返回一个新的字符串对象,原来的那个不动。
var name = " csharp ";
var trimmed = name.Trim();
Console.WriteLine($"original=[{name}] trimmed=[{trimmed}]");
这段代码里 name 始终带着前后空格,trimmed 是新对象。如果你写了 name.Trim(); 却没接收返回值,这行代码等于什么也没做,编译器也不会警告,因为调用方法本身是合法的。类似地,name.Replace("csharp", "C#") 不接收结果也是白写。
不可变带来一个好处:字符串可以安全地被多个线程共享,也可以被缓存。字符串字面量会被驻留(interning),内容相同的字面量通常指向同一份数据。这解释了两个现象:一是内容相同的字符串 == 为 true,二是在循环里拼字符串会产生大量临时对象。假设循环十万次做 s += "x",每一次都会新建一个更长的字符串,前一个变成垃圾,总复制量是平方级的。
StringBuilder 的标准不是「拼了几次」,而是「是否在循环里、总量是否可能很大」。拼三五个固定片段直接用 + 或插值更清楚;循环里拼成千上万个片段才需要 StringBuilder。第 3 篇会用真实计时对比这两种写法。算钱别用 double:decimal 的取舍
double 和 float 是二进制浮点数,它们擅长科学计算和图形计算,不擅长表示十进制小数。0.1 在二进制里是无限循环小数,存进 double 的那一刻就已经近似了,累加十次自然得到 0.9999999999999999。上面的实测输出已经证明了这一点。
decimal 是十进制浮点数,它能精确表示常见的十进制小数,所以金额、税率、单价这类需要「人看到的数字对得上」的场景应该用它。代价是 decimal 更慢、占用更多内存,而且它也不是无限精度,仍然有位数上限。做除法时如果除不尽,还是会舍入,只是舍入规则更符合十进制直觉。
double
速度快,范围大,适合物理模拟、统计、图形。不适合金额,因为 0.1 无法精确表示,累加和比较都可能出现意外结果。
decimal
十进制精确表示,适合金额和财务。速度比 double 慢,范围小,序列化到 JSON 时要注意接收方是否支持高精度小数。
可空类型与 null:别把「没值」当成 0
引用类型可以是 null,这一点大家都知道。值类型默认不能为 null,int 的默认值是 0,bool 的默认值是 false。但业务里经常会遇到「这个字段还没填」的情况,0 和「没填」是两件事。比如库存为 0 表示卖光了,库存没录入表示还没开始卖,这两种状态不能用同一个 0 表达。
C# 用 int? 这种写法表示可空值类型,它等价于 Nullable<int>。可空类型有两个成员:HasValue 告诉你有没有值,Value 取出真正的值。直接对没有值的可空类型访问 Value,会抛 InvalidOperationException,不是返回 0,也不是返回 null。
int? stock = null;
Console.WriteLine(stock.GetValueOrDefault()); // 0
Console.WriteLine(stock ?? 10); // 10
try { Console.WriteLine(stock.Value); }
catch (Exception ex) { Console.WriteLine(ex.GetType().Name); }
实际项目里更常用的是两个运算符:?? 给默认值,?. 在对象为 null 时短路。这两个写法能省掉大量嵌套判空。要注意 ?? 只在左边为 null 时取右边,0、空字符串、false 都不会触发默认值,这一点和 JavaScript 的 || 不一样。
还有一类坑来自「可空引用类型」。C# 8 之后可以在项目里打开 nullable 检查,编译器会提示「这个变量可能为 null」。它只是编译期提示,运行时该 null 还是 null。打开这个检查能让很多空引用问题在编译时就暴露,但老项目一开可能会有成百上千条警告,得慢慢清理,不要一次性全改成 ! 抑制符,那等于把提示关掉了。
int? a = null; var b = a + 1;,b 是 null 而不是 1。这不会抛异常,但会让后面拿到 null 的代码莫名其妙。涉及金额和数量计算时,先明确 null 代表什么,再决定是给默认值还是提前返回。这套类型规则的边界与代价
把值类型和引用类型分清楚,能避免很多低级错误,但这套规则本身也有成本和适用边界,不能走极端。
- struct 不是「更快的 class」:它的优势是避免堆分配和垃圾回收,但复制成本随字段数量增长。一个包含十几个字段的结构体在方法间传来传去,可能比传一个引用更慢。字段多、需要继承、需要身份区分的数据,应该用 class。
- 不可变不是免费的:string 的不可变让共享变安全,但每次修改都产生新对象。大量字符串处理要么用
StringBuilder,要么用Span切片,后者能避免复制,但生命周期受限,不能随便存到字段里。 - decimal 有精度上限:它能精确表示常见的十进制小数,但不是无限精度,除法除不尽时仍会舍入。超大数值、科学计算、图形计算还是应该用 double。
- 可空检查只是编译期提示:打开 nullable 能减少空引用,但它不会改变运行时行为。第三方库、反射、反序列化都可能绕过检查给你一个 null。
- 命名空间不解决依赖问题:它只是名字前缀,项目之间的依赖仍然要靠程序集引用。命名空间规划得再漂亮,程序集循环依赖照样编译不过。
另一个常见误解是「值类型一定在栈上」。实际上只有局部变量和方法参数里的值类型通常在栈上,作为类字段的值类型跟着对象在堆上,作为数组元素的值类型也在堆上。讨论「栈还是堆」对写业务代码帮助不大,讨论「赋值时复制还是共享」才有直接价值。
最后说一句选型原则:先按语义选,不要先按性能选。这个数据在业务上是不是一个独立的值、需不需要身份、会不会被共享修改,这些问题的答案决定你用 struct 还是 class。性能问题等真的测出来再优化,别在写第一行代码时就开始猜。
当天能自己验证的练习
以下练习都在 .NET 8 控制台项目里做。先用命令确认环境,再新建一个项目,后面每次改 Program.cs 后重新运行即可:
dotnet --version
8.0.427
dotnet new console -o csdemo
cd csdemo
dotnet run
Hello, World!
- 把本文第一段结构体例子敲进
Program.cs,先调用list[0].Add()再打印,然后把元素取出来改完写回,对比两次输出。确认「副本」到底复制了什么。 - 把
list[0].Value = 5写进代码,记录编译器给出的完整错误信息,再改成先取出、改完、写回,确认能编译通过。 - 写一个循环累加 0.1 十次,分别用
double和decimal打印结果;再把金额换成decimal后做一次除法,观察保留几位小数。 - 定义两个字段完全相同的自定义类,用
==和Equals分别比较,记录结果;然后给类重写Equals和GetHashCode,再比较一次。 - 声明一个
int? n = null,分别用GetValueOrDefault()、??、.Value取值,把.Value那次的异常类型打印出来,确认它不是返回 0。
Program.cs,每次 dotnet run 就能看到结果。把每次输出贴到笔记里,比只看文章印象深得多。小结
三句话收一下:C# 的命名空间只管名字,程序集才是部署和依赖的单位;值类型赋值复制数据,引用类型赋值复制地址,struct 的所有反直觉行为都从这里来;string 不可变、金额用 decimal、可空类型要判空,这三条能避开入门阶段最常见的一批坑。
语法这一层弄明白之后,下一步自然会想「C# 有哪些写法能让代码短一截」。下一篇讲语言特性:LINQ 的延迟执行、模式匹配、record 和自动属性。它们看起来很甜,但延迟执行和闭包捕获会在你不注意的时候改变程序行为,尤其是同一条查询被枚举两次的时候。