罗罗编程学习记录
本页内容 展开查看

04.6.1.1 类型系统与值引用语义

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.6 C# 与 .NET / 04.6.1 C# 语言核心

04.6.1.1-001 值类型与引用类型有什么区别?

一句话结论

值类型(struct、enum、内置数值/bool/char)直接保存数据,赋值按值复制;引用类型(class、string、数组、委托、接口)保存对象引用,赋值复制引用,多个变量别名同一对象。

概念解释

值类型实例内联存储:局部变量在栈帧,作为类字段内联在堆对象内;引用类型对象在托管堆,变量保存对象引用。两者复制语义不同,决定了别名与可变性的来源。

原理流程

  1. 声明值类型变量:直接持有数据。
  2. 赋值/传参:按位复制一份独立数据。
  3. 引用类型:堆上分配对象,变量复制引用副本,指向同一对象。

代码或图示

int a = 1; int b = a; b = 2;        // a 仍为 1(复制)
var x = new List<int> { 1 }; var y = x; y.Add(2); // x 也含 2(别名)

常见误区

  • 以为所有变量都在栈上:引用类型的引用本身在栈/字段内联,对象本体在堆;装箱的值类型也在堆。
  • 以为 struct 一定比 class 快:大 struct 复制成本高,频繁传参会抵消分配收益。

追问

  • 值类型一定不会进堆吗?答:装箱后进入堆;作为引用类型字段内联在堆对象中;闭包/迭代器捕获的局部变量也可能被搬到堆帧。
  • 如何判断类型属于哪一类?答:继承自 System.ValueType 的是值类型,其余为引用类型;string 是引用类型但继承自 object。

04.6.1.1-002 struct 与 class 怎么选择?

一句话结论

小体量、语义上是「值」、不需要多态与共享身份的场景用 struct;需要引用身份、继承层次、可变状态或对象较大时用 class。

概念解释

struct 提供值语义与默认拷贝,适合点、坐标、金额、记录等不可变小对象;class 提供引用身份、可继承、可被多态替换。把可变大 struct 当 class 用会产生大量隐式复制。

原理流程

  1. 判断模型语义:是「同一对象的不同引用」还是「相等的两份数据」。
  2. 评估大小与复制频率:小且不可变优先 struct。
  3. 需要继承/接口多态/身份比较时选 class。

代码或图示

public readonly struct Point { public int X; public int Y; }
public class Order { public int Id; public List<Item> Items; }

常见误区

  • 用 struct 表达带身份的实体:拷贝出的副本与原对象脱钩,身份判断出错。
  • 设计可变 struct:修改副本不影响原件,排查困难,应改为 readonly struct 或 class。

追问

  • struct 可以实现接口吗?答:可以实现接口,但装箱后按引用类型调用。
  • struct 能显式声明析构函数吗?答:不能,struct 没有终结器。

04.6.1.1-003 string 为什么是引用类型却表现得像值?

一句话结论

string 是引用类型,对象在堆上,但不可变(immutable):任何「修改」都生成新字符串,加上重写的相等比较,使外部行为接近值类型。

概念解释

不可变意味着创建后字符序列不能被改写,拼接/替换/子串返回新实例。多个引用指向同一字符串时无法通过一方改动另一方,别名风险被消除。

原理流程

  1. 字符串分配在堆,变量保存引用。
  2. 操作产生新字符串,原实例保持不变。
  3. ==/Equals 按字符序列比较内容而非引用地址。

代码或图示

string s = "abc"; string t = s; t = "xyz";  // s 仍为 abc
bool eq = ("abc" == "abc");                 // 内容比较,true

常见误区

  • 以为改 t 会影响 s:不可变语义下赋值产生新引用。
  • 以为字符串比较是比较地址:string 重载了相等运算符,比较字符内容。

追问

  • 字符串拼接为何推荐 StringBuilder?答:循环内 += 每次分配新字符串并复制旧内容,O(n²) 级分配;StringBuilder 维护可扩容字符缓冲。
  • 字符串驻留(intern)是什么?答:运行时把字面量/已驻留字符串放入表复用,减少重复分配;不要依赖驻留身份做判断。

04.6.1.1-004 装箱与拆箱是什么,开销在哪?

一句话结论

装箱把值类型实例复制到堆上的 object/接口包装对象;拆箱从包装对象取出值类型复制;两者都涉及堆分配、类型检查与内存复制。

概念解释

当值类型需要以 object 或接口形式参与多态/通用容器时触发装箱。旧版非泛型集合(ArrayList)每个元素都装箱,是历史性能热点;泛型集合避免了这一问题。

原理流程

  1. 装箱:堆上分配对象,复制值并记录类型句柄。
  2. 拆箱:校验类型匹配,复制值到栈/目标位置。
  3. 类型不符抛 InvalidCastException。

代码或图示

int n = 42;
object boxed = n;          // 装箱
int m = (int)boxed;        // 拆箱

常见误区

  • 以为装箱只是把引用「包装」原数据:值被复制进堆对象,与原变量独立。
  • 以为泛型也会装箱:泛型类型参数在 JIT 后按具体类型实例化,值类型不装箱(具体实现细节以运行时版本为准)。

追问

  • 哪些写法容易隐式装箱?答:值类型传给 object 参数、存非泛型集合、调用 object 上的方法、值类型转接口。
  • 如何减少装箱?答:用泛型集合与泛型接口,避免值类型与 object 混用,性能敏感路径做基准测量。

04.6.1.1-005 Nullable 与可空类型怎么工作?

一句话结论

Nullable<T> 是值类型,封装 HasValue 与 Value;int? 是 Nullable<int> 的语法糖;引用类型的可空标注由可空引用类型系统(NRT)在编译期处理。

概念解释

值类型默认不能为 null,Nullable<T> 用结构体增加「无值」状态。访问 Value 前需检查 HasValue,否则抛 InvalidOperationException。

原理流程

  1. int? x = null:HasValue 为 false。
  2. x ?? 0 提供默认值。
  3. x.Value 仅在 HasValue 为 true 时安全读取。

代码或图示

int? a = null;
int b = a ?? 10;
if (a.HasValue) { var v = a.Value; }

常见误区

  • 直接访问 x.Value:无值时抛异常,应先判断或用 GetValueOrDefault。
  • 混淆 int? 与 string 的可空:前者是运行时结构体状态,后者是编译器标注(不改变运行时类型)。

追问

  • Nullable<T> 是值类型还是引用类型?答:值类型;装箱后 null 表示空包装,HasValue=false 的实例装箱为 null。
  • 可空引用类型标注是否改变运行时行为?答:默认不改变,是编译期静态分析提示;可配合 #nullable enable 与注解强化检查。

04.6.1.1-006 enum 底层类型与 Flags 标志位?

一句话结论

enum 是命名整数常量,默认底层类型 int,可用 : byte/short/long 指定;[Flags] 标注位标志组合,用按位运算组合与判断。

概念解释

枚举提供类型化的整数语义,避免魔法数字。Flags 枚举把不同位分配给不同选项,组合值用 |,判断用 &。非 Flags 枚举不应做位组合。

原理流程

  1. 定义枚举成员并赋整数值。
  2. Flags 成员取 1、2、4、8 等 2 的幂。
  3. 组合:A | B;判断:(x & A) == A。

代码或图示

[Flags]
public enum Perm { None = 0, Read = 1, Write = 2, Delete = 4 }
var p = Perm.Read | Perm.Write;
bool canWrite = (p & Perm.Write) == Perm.Write;

常见误区

  • 枚举成员取值连续却当 Flags 用:位重叠导致组合判断错误。
  • 用 == 判断标志位:组合值不等于单个成员,应用按位与。

追问

  • 枚举与 const 区别?答:枚举是命名类型化常量,可做类型约束与位组合;const 是字面常量。
  • 如何枚举所有成员?答:Enum.GetValues/Enum.GetNames 反射获取;性能敏感路径缓存结果。

04.6.1.1-007 const 与 readonly 的区别?

一句话结论

const 是编译期常量,值在编译时内联到引用方;readonly 是运行期只读字段,可在构造函数中赋值,类型可以是引用类型。

概念解释

const 必须用字面量/其他 const 初始化,不能为引用类型(除字符串);readonly 字段在构造后不可重新赋值(引用类型内部状态仍可变)。静态只读在静态构造函数赋值。

原理流程

  1. const 求值在编译期,调用方程序集直接内嵌字面值。
  2. readonly 字段在构造时确定,运行时读取。
  3. 修改 const 需重新编译所有引用方;readonly 仅重编译本程序集。

代码或图示

public const double Pi = 3.14159;
public readonly string Path;
public Ctor() { Path = "/data"; }

常见误区

  • 以为 const 变更后引用方自动更新:引用方内嵌了旧字面值,必须重新编译。
  • 以为 readonly 使引用对象不可变:仅字段引用不可改,对象内部集合/属性仍可变。

追问

  • static readonly 用于什么?答:运行期构造的不可变单例/常量对象,避免 const 无法表达引用类型的限制。
  • 配置项为什么不宜用 const?答:const 编译期内联,配置变更无法在不重编译的情况下生效。

04.6.1.1-008 可空引用类型(NRT)做什么检查?

一句话结论

NRT 是编译期静态分析:用 ? 标注引用类型是否可能为 null,在开启上下文后对解引用、赋值、传参做可空性检查并告警,不改变运行时类型。

概念解释

string? 表示可能为 null,string 表示非 null。编译器基于赋值流、! 抑制运算符、条件判断给出警告;它不阻止 null 在运行时出现,也不强制装箱行为。

原理流程

  1. 项目/文件开启 #nullable enable。
  2. 标注参数/返回/字段可空性。
  3. 编译器在解引用与跨调用边界检查,可疑处产生警告。

代码或图示

string? MaybeName() => ...;
string n = MaybeName()!;            // 抑制(确信非 null)
if (MaybeName() is { Length: > 0 } s) { ... }

常见误区

  • 以为开启 NRT 后运行时不会出现 null:它只是静态分析,历史代码与反射仍可能传入 null。
  • 用 ! 绕过所有告警:掩盖真实空引用风险,应先做判断或保证来源非空。

追问

  • 警告 vs 异常的关系?答:NRT 给编译警告,空引用在运行时仍可能抛 NullReferenceException;运行时防护用参数校验/模式判断。
  • 渐进迁移怎么做?答:先按文件/目录开启,修复警告后再全项目启用。

04.6.1.1-009 == 与 Equals 有什么区别?

一句话结论

== 是运算符,可被重载,默认引用类型比较引用、值类型比较值;Equals 是 object 虚方法,可重写为内容比较,常配合 GetHashCode。

概念解释

相等比较有两类:引用身份(ReferenceEquals)与内容相等(重载的 ==/Equals)。值类型默认按字段比较,引用类型默认比较引用;string 与 record 重写为内容比较。

原理流程

  1. 调用 ==:按运算符重载解析,可能是引用比较或内容比较。
  2. 调用 Equals:虚分派到类型重写实现。
  3. 重写 Equals 必须同步重写 GetHashCode,保证相等对象哈希一致。

代码或图示

object a = "abc", b = new string("abc"u8);
bool sameRef = ReferenceEquals(a, b);   // false
bool content = a.Equals(b);            // true

常见误区

  • 以为 == 与 Equals 永远等价:运算符重载与虚方法实现可以不同,自定义类型需分别核对。
  • 重写 Equals 不重写 GetHashCode:放入 Dictionary/HashSet 出现哈希不一致问题。

追问

  • string.Equals 有哪些重载?答:可指定比较类型(序号/文化)与比较字符串,注意文化相关比较的排序差异。
  • 记录类型的相等怎么实现?答:record 自动按成员生成值相等实现与哈希码。

04.6.1.1-010 值类型传参与复制行为?

一句话结论

值类型默认按值传递:方法内副本修改不影响调用方;ref/out 按引用传递同一存储位置;返回 struct 仍按值复制。

概念解释

按值传递复制实例,struct 越大复制成本越高。ref 传递避免复制并允许写回;in 按引用传入但只读,用于大 struct 避免拷贝。

原理流程

  1. 默认参数:复制一份进入方法栈帧。
  2. ref:传递存储位置别名,方法内修改作用于原变量。
  3. in:只读别名,防止修改但避免复制。

代码或图示

void Add(int x) { x++; }              // 不影响外部
void AddRef(ref int x) { x++; }
long Sum(in Large s) => s.A + s.B;    // 避免大 struct 拷贝

常见误区

  • 以为 ref 只用于引用类型:值类型同样可 ref 传递,用于避免大 struct 复制或需要写回。
  • 以为返回 struct 会原地修改原对象:返回的是副本。

追问

  • out 与 ref 区别?答:out 必须在方法内赋值后使用,调用方无需初始化;ref 要求调用前已初始化,可读可写。
  • 大 struct 性能优化手段?答:in 传参、ref struct、避免嵌套复制;用基准测量确认收益。

04.6.1.1-011 引用类型别名与可变状态?

一句话结论

引用类型赋值后多个变量指向同一堆对象,任一方修改内部状态,所有别名可见;要避免别名副作用,应做深拷贝或设计不可变类型。

概念解释

别名是共享可变状态的主要来源:集合、字段、属性被多处持有后,一处添加/删除影响全部。跨层传递时明确「所有权」与是否允许修改。

原理流程

  1. 对象在堆分配,引用副本互相别名。
  2. 通过任一引用改字段/集合。
  3. 其他引用观察到同一变更。

代码或图示

var list = new List<int>();
void Log(List<int> input) { input.Add(1); } // 外部 list 被修改

常见误区

  • 以为把引用类型作为参数传入会复制对象:复制的是引用,对象本体共享。
  • 公共属性直接暴露内部集合:外部可绕过类封装修改内部状态。

追问

  • 如何安全暴露内部集合?答:返回只读包装(AsReadOnly/IReadOnlyList)或副本;明确返回类型不可变。
  • 浅拷贝与深拷贝区别?答:浅拷贝复制引用(嵌套对象仍共享),深拷贝递归复制嵌套对象;record 的 with 是浅拷贝。

04.6.1.1-012 数组在类型系统中是什么?

一句话结论

数组是引用类型,实例在堆上;数组元素类型决定存储:值类型元素内联在数组缓冲,引用类型元素保存引用;数组实现 IEnumerable/ICollection 等接口。

概念解释

数组长度固定,类型为 T[],多维数组([,])与交错数组([][])布局不同。数组协变允许某些引用类型数组转换,但写入时可能抛数组类型异常。

原理流程

  1. 数组分配在堆,长度记录在数组头。
  2. 值类型数组内联存储元素;引用类型数组存引用。
  3. 索引访问做边界检查。

代码或图示

int[] nums = { 1, 2, 3 };
int[][] jagged = new int[2][];      // 交错数组
int[,] rect = new int[2, 3];        // 多维矩形数组

常见误区

  • 把交错数组当多维数组:交错是数组的数组,每行长度可不同;矩形数组连续二维布局。
  • 依赖数组协变传参:不安全写入会在运行时报 ArrayTypeMismatchException。

追问

  • 数组与 List<T> 取舍?答:数组固定长度、无容量开销;List 自动扩容、增删方便;频繁改长度用 List,定长缓冲用数组/Span。
  • 数组协变是什么?答:string[] 可赋值给 object[],但向其写入非 string 元素抛异常;泛型集合不提供这种协变写入。

04.6.1.1-013 委托在类型系统中是什么?

一句话结论

委托是引用类型,封装一个或一组方法引用(多播),类型安全地描述方法签名;Action/Func 是泛型委托,事件基于委托封装。

概念解释

委托实例可包装静态方法、实例方法或 Lambda;多播委托维护调用链,按顺序调用。委托让方法可作为参数传递,是回调、LINQ 与事件机制的基础。

原理流程

  1. 定义委托签名(返回类型 + 参数列表)。
  2. 实例绑定兼容方法/Lambda。
  3. 调用委托触发调用链,返回值取链上最后一个方法结果。

代码或图示

Func<int, int> doubleIt = x => x * 2;
Action<string> log = Console.WriteLine;
log(doubleIt(3).ToString());

常见误区

  • 以为委托就是函数指针:委托是托管类型,支持多播与目标对象持有;函数指针是轻量不安全/无委托链机制(具体语法以当前语言版本为准)。
  • 多播委托异常传播:链中某方法抛异常会中断后续调用,需在方法内捕获。

追问

  • 委托与接口区别?答:委托是方法级契约(单个/一组回调),接口是对象级契约(一组方法)。
  • 闭包如何被委托捕获?答:Lambda 捕获的外部变量被提升到闭包类,委托持有该闭包实例。

04.6.1.1-014 readonly struct 与不可变性怎么设计?

一句话结论

readonly struct 标记所有字段只读,编译器阻止方法内修改,保障值语义下的不可变;不可变类型避免别名导致的意外修改,便于并发推理。

概念解释

普通 struct 方法默认可改字段,即使字段为只读,方法也可能通过调用其他可改成员间接变化。readonly struct 在编译期强制不可变,并允许按值安全传递。

原理流程

  1. 字段全部只读,类型标记 readonly。
  2. 方法无法修改实例状态。
  3. 复制别名不会产生可观察的内部差异。

代码或图示

public readonly struct Money {
    public decimal Amount { get; }
    public Money(decimal amount) => Amount = amount;
}

常见误区

  • 字段 readonly 但属性内部集合可变:引用类型成员仍可被外部修改,readonly struct 不保护嵌套对象。
  • 以为 readonly struct 必然线程安全:不可变本身利于共享,但若嵌套可变对象仍需同步。

追问

  • record struct 与 readonly struct 区别?答:record struct 自动生成值相等与解构,可声明为 readonly;readonly struct 强调字段不可变,不自动生成相等实现。
  • 不可变类型在并发中的价值?答:发布共享实例无需同步读写;读取方看不到中间状态。

04.6.1.1-015 ValueTuple 元组是什么语义?

一句话结论

ValueTuple<T...> 是可变值类型元组,(int, string) 为其语法糖;按值复制,元素可命名,用于轻量多返回值,避免为简单结果专门定义类型。

概念解释

元组提供临时结构组合多个值,命名元素仅编译期别名,运行时按 Item1/Item2 访问。需要语义、相等规则或封装时应定义命名类型。

原理流程

  1. 方法返回 (int Sum, int Count)。
  2. 调用方解构为变量。
  3. 元组按值复制,独立副本。

代码或图示

(int Sum, int Count) Aggregate(IEnumerable<int> xs) { ... }
var (sum, count) = Aggregate(nums);

常见误区

  • 把元组当领域模型传递:缺乏语义与封装,元素名在跨程序集边界不稳定。
  • 以为元组元素名运行时保留:命名是编译期友好语法,反射看到的是 Item1 等字段。

追问

  • 元组相等怎么比较?答:按元素值逐项比较;命名不影响相等规则。
  • 什么时候应换成命名类/record?答:超过两个元素、需要校验/行为/文档语义时。

04.6.1.1-016 类型转换:隐式、显式、强制转换与自定义转换?

一句话结论

隐式转换安全无损(如 int→long);显式转换可能丢精度需写转换运算符;as 尝试转换失败返回 null;自定义转换用 implicit/explicit 运算符定义。

概念解释

数值转换遵循可加宽/收窄规则;引用转换保留或改变引用类型;用户自定义转换是类型上的静态运算符方法。转换失败可能抛 InvalidCastException 或溢出异常。

原理流程

  1. 编译器检查隐式转换是否存在且安全。
  2. 显式转换写 (T)x,运行时校验兼容。
  3. as 仅用于引用/可空类型,失败给 null 不抛异常。

代码或图示

long l = 1;                       // 隐式
int i = (int)l;                   // 显式
var s = obj as string;            // 失败为 null

常见误区

  • 对值类型用 as:值类型不可为 null,as 只能用于引用类型/可空类型。
  • 忽略数值收窄溢出:显式转换不自动抛溢出异常,需要 checked 上下文检查。

追问

  • checked/unchecked 作用?答:控制整数溢出是否抛 OverflowException;默认上下文依编译配置。
  • 自定义转换规则?答:public static implicit operator Target(Source s),双向转换不要同时定义成隐式避免歧义。

04.6.1.1-017 类型检查:is、as、typeof 与模式?

一句话结论

is 判断兼容类型并可做模式绑定;as 转换失败给 null;typeof 获取运行时 Type 对象;泛型约束与反射据此做类型分发。

概念解释

类型检查在多态分支、反序列化、动态参数处理中常见。模式匹配把类型判断与变量绑定合一,减少强转步骤。

原理流程

  1. is T x:兼容则绑定 x。
  2. as T:返回转换结果或 null。
  3. typeof(T) 与 obj.GetType() 比较类型元数据。

代码或图示

if (obj is Order { Status: Paid } order) { order.Id; }
var list = obj as List<int>;
Type t = typeof(Order);

常见误区

  • 用 GetType() 与 typeof 比较却忽略继承:基类引用的派生类型不等于基类类型;判断兼容用 is。
  • 连续 is 后强转:应直接用 is T x 绑定,避免二次转换。

追问

  • is 与 as 性能差异?答:都是类型检查;as 一次尝试转换,is 只判断;避免检查后再强转的双重检查写法。
  • 类型比较在泛型中的替代?答:用约束表达能力,减少运行时类型分支;反射场景注意缓存与 AOT 限制。

04.6.1.1-018 内置类型与 CLR 类型对应关系?

一句话结论

C# 关键字类型是 CLR 类型的别名:int→System.Int32、long→System.Int64、bool→System.Boolean、string→System.String,编译后等价。

概念解释

别名与 BCL 类型可互换使用;数值类型有固定位宽与范围,跨语言一致。理解对应关系有助于阅读 IL 与跨语言互操作。

原理流程

  1. 编译器把关键字映射到元数据类型。
  2. 同一类型不同写法编译结果一致。
  3. 溢出/范围按 CLR 类型位宽确定。

代码或图示

int a = 1;              // System.Int32
long b = 1L;           // System.Int64
string s = "x";        // System.String

常见误区

  • 以为 C# 类型与 CLR 类型是两套实现:别名只是语法映射,运行时同一类型。
  • 跨语言互操作时混用:其他语言按 CLR 类型名引用,元数据类型一致。

追问

  • nint/nuint 是什么?答:平台相关大小的整数(指针大小),用于互操作/原生指针场景;普通业务代码用固定位宽类型。
  • 类型范围在哪里查?答:BCL 类型文档记录位宽、取值范围与默认值;版本敏感行为以目标框架文档为准。