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

04.6.1.2 泛型约束与协变逆变

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

04.6.1.2-001 泛型解决什么问题?

一句话结论

泛型用类型参数编写可复用代码,同时保留编译期类型安全,避免非泛型集合的装箱开销与强制转换错误。

概念解释

没有泛型时,通用容器只能存 object,取值需强转且每次装箱;泛型把元素类型作为参数,JIT 后按具体类型实例化,编译期检查类型不匹配。

原理流程

  1. 定义带类型参数 T 的类/方法。
  2. 使用时指定具体类型(或由编译器推断)。
  3. 编译期检查赋值与返回类型,运行时按类型实例化。

代码或图示

public class Box<T> { public T Value; }
var box = new Box<int> { Value = 1 };

常见误区

  • 以为泛型只是模板复制:CLR 对引用类型共享一份实例化代码,值类型各自生成;具体共享规则以运行时实现为准。
  • 以为泛型消除了所有类型检查:编译期检查替代了运行时强转检查。

追问

  • 泛型相比继承 object 的收益?答:类型安全、无装箱、取值无需强转、编译期发现类型错误。
  • 泛型的代价?答:不同值类型实例化增加代码量;约束不足时可用操作受限。

04.6.1.2-002 泛型可以用在哪些位置?

一句话结论

类型参数可用于类、结构体、接口、委托、方法;方法级泛型可独立于类型声明,由参数推断类型。

概念解释

泛型类描述「对某类型的容器/包装」;泛型方法描述「对任意类型参数的算法」;泛型接口定义可被多类型实现的契约;泛型委托是类型化回调签名。

原理流程

  1. 类/接口级别参数作用于整个类型。
  2. 方法级别参数随方法签名声明。
  3. 委托参数描述回调的输入输出类型。

代码或图示

public interface IRepo<T> { T Get(int id); }
public static T First<T>(IEnumerable<T> src) => src.First();
public delegate TResult Func<out TResult>();

常见误区

  • 把方法泛型写在类级别才能用:方法可以独立声明类型参数,与类参数并存。
  • 委托泛型与接口泛型混用:委托是方法签名契约,接口是对象契约。

追问

  • 泛型类的类型参数何时确定?答:实例化时指定;开放类型(未绑定参数)只能用于反射/约束场景。
  • 泛型方法类型推断依据?答:由实参类型推断,推断不出时显式指定 <T>。

04.6.1.2-003 where 约束有哪些种类?

一句话结论

约束限定类型参数必须满足:where T : class 引用类型、struct 非空值类型、new() 有无参构造、基类/接口约束、notnull 非空、unmanaged 非托管类型。

概念解释

约束是泛型可用能力的边界:有基类约束才能调用基类方法;接口约束才能调用接口成员;new() 才能 new T()。约束越多,可实例化类型越窄,代码能力越强。

原理流程

  1. 在类型参数后写 where T : ...。
  2. 编译器检查实参满足全部约束。
  3. 方法体内按约束调用成员。

代码或图示

public T Create<T>() where T : new() => new T();
public void Print<T>(T x) where T : IFormattable => x.ToString(null, null);

常见误区

  • 以为不加约束就能调用 T 上的方法:无约束只能访问 object 成员。
  • 约束写反方向:struct 约束排除引用类型,不能与 class 同时使用。

追问

  • unmanaged 约束用于什么?答:限定不含引用类型字段的值类型,可做内存/指针互操作。
  • notnull 约束?答:排除可空引用类型与可空值类型,配合 NRT 使用。

04.6.1.2-004 约束组合与顺序规则?

一句话结论

多个约束按「基类 → 接口 → class/struct/notnull → new()」顺序书写;一个类型参数一条 where,类型参数之间可互相约束。

概念解释

基类约束最多一个且必须在接口前;new() 放最后。类型参数约束(where U : T)表达派生关系,用于泛型继承与工厂场景。

原理流程

  1. 列出需要的基类、接口、引用/值类型标记、构造约束。
  2. 按语法顺序排列。
  3. 实参同时满足所有条件才可实例化。

代码或图示

public class Repo<T, U> where T : Base, IRepo, new() where U : T { }

常见误区

  • 把 new() 写在接口约束前:编译顺序错误。
  • 同时写 class 与 struct:互斥约束,无法满足。

追问

  • 裸类型约束是什么?答:一个类型参数约束另一个类型参数,如 where U : T,用于表达 U 派生自 T。
  • 约束能否在运行时放宽?答:不能,约束是编译期契约;反射实例化需自行校验。

04.6.1.2-005 泛型实例化在运行时怎么发生?

一句话结论

开放泛型类型在使用具体类型时由 JIT 实例化;引用类型共享类型系统实现,值类型按各自类型生成代码;这是理解泛型静态字段与装箱行为的基础。

概念解释

泛型类型元数据保留类型参数,运行时绑定具体类型。引用类型的实例化因引用表示一致可共享代码;不同值类型有独立布局与静态状态。具体共享/生成策略以当前运行时实现为准。

原理流程

  1. 元数据中保存开放泛型定义。
  2. 首次使用具体类型触发实例化。
  3. 静态字段按实例化类型分别初始化。

代码或图示

public class Counter<T> { public static int Count; }
// Counter<int>.Count 与 Counter<string>.Count 各自独立

常见误区

  • 以为所有泛型实例化共享静态字段:静态状态按具体类型参数隔离。
  • 以为值类型泛型也不生成代码:值类型实例化有独立代码与布局。

追问

  • 开放类型能实例化吗?答:typeof(List<>) 可用于反射;new List<>() 不能直接构造,需绑定具体类型。
  • 实例化时机?答:首次 JIT 触及具体封闭类型时;预热场景可显式触发。

04.6.1.2-006 协变 out 是什么?

一句话结论

out 标记类型参数只用于返回位置(输出),使 派生类型 的泛型可赋值给 基类型 的泛型,如 IEnumerable<Derived> 可赋给 IEnumerable<Base>。

概念解释

协变保持类型方向:派生 → 基类的赋值兼容沿泛型类型方向保留。只返回 T、不从外部接收 T 的位置才能标 out,否则返回值可能被错误写入。

原理流程

  1. 接口/委托类型参数标 out T。
  2. 方法签名中 T 仅出现在返回类型。
  3. 派生泛型可隐式转换为基类泛型。

代码或图示

IEnumerable<Derived> src = ...;
IEnumerable<Base> target = src;   // out 协变

常见误区

  • 在 out 接口的方法参数中使用 T:编译器禁止,参数位置破坏协变安全。
  • 以为所有泛型集合都协变:List<T> 不变,因为有写入方法。

追问

  • 哪些 BCL 类型是 out 协变?答:IEnumerable<out T>、IEnumerator<out T>、Func<out TResult> 等;以 BCL 定义为准。
  • 协变解决什么场景?答:按基类消费派生对象集合,避免逐个转换。

04.6.1.2-007 逆变 in 是什么?

一句话结论

in 标记类型参数只用于参数位置(输入),使 基类型 的泛型可赋值给 派生类型 的泛型,如 Action<Base> 可赋给 Action<Derived>。

概念解释

逆变反转方向:能处理基类的委托/接口,也能处理派生类。T 只出现在入参位置时可标 in;返回位置使用会破坏逆变安全。

原理流程

  1. 类型参数标 in T。
  2. T 仅作为方法参数出现。
  3. 基类泛型可赋给派生泛型。

代码或图示

Action<Base> handle = b => { };
Action<Derived> derivedHandle = handle;  // in 逆变

常见误区

  • 在 in 委托中返回 T:编译器禁止,返回位置不满足逆变。
  • 混淆协变逆变方向:记「out 往外给、in 往里收」。

追问

  • 哪些 BCL 类型是 in 逆变?答:Action<in T>、IComparer<in T>、IEqualityComparer<in T> 等;以 BCL 定义为准。
  • 委托逆变的实际用途?答:通用处理器注册到派生类型回调位置,无需为派生类重复包装。

04.6.1.2-008 泛型委托的协变逆变怎么用?

一句话结论

Func<out TResult> 结果协变,Action<in T> 参数逆变;多参数委托可同时存在 in/out 标记,Lambda 与方法按签名兼容规则匹配。

概念解释

委托类型参数的位置决定标记:返回值 out,入参 in。组合标记后,委托赋值遵循类型方向规则,减少包装转换。

原理流程

  1. 定义委托参数标记。
  2. 方法/Lambda 签名兼容目标委托。
  3. 赋值时按协变逆变规则检查。

代码或图示

Func<Derived> getD = () => new Derived();
Func<Base> getB = getD;              // 协变
Action<Base> actBase = b => { };
Action<Derived> actDer = actBase;    // 逆变

常见误区

  • 以为委托参数双向都能标:同一 T 不能同时 in 与 out 用于冲突位置。
  • 忽略返回值兼容性:返回派生可赋给基类(协变),参数基类可赋给派生(逆变)。

追问

  • 非泛型委托有协变逆变吗?答:普通委托方法参数/返回也支持基本的逆变/协变转换;泛型委托用标记显式表达。
  • 委托链与协变冲突吗?答:不冲突,链上各方法签名仍需兼容委托类型。

04.6.1.2-009 泛型接口协变与集合场景?

一句话结论

只读/只消费接口可声明 out 协变(如 IEnumerable<out T>);有写入的接口保持不变,防止通过基类引用写入不兼容类型。

概念解释

协变安全的前提是 T 不会被写入。集合接口若含 Add/索引器 setter,T 出现在输入位置,不能协变。这也是 List<T> 不变而 IEnumerable<T> 协变的原因。

原理流程

  1. 分析接口成员中 T 的位置。
  2. 仅返回位置标 out。
  3. 消费方按基类接口使用派生集合。

代码或图示

IReadOnlyCollection<Derived> d = ...;
IReadOnlyCollection<Base> b = d;   // 只读集合协变

常见误区

  • 把可变集合当协变传递:写入路径会引入类型不匹配对象。
  • 以为接口继承自动获得协变:标记需在接口定义处声明。

追问

  • 数组协变为什么不安全?答:数组是引用类型且元素可写,object[] 写入派生数组会类型不匹配;泛型不变接口避免该问题。
  • 只读接口有哪些?答:IEnumerable、IReadOnlyCollection、IReadOnlyList 等;具体标记以 BCL 为准。

04.6.1.2-010 不变性与数组协变对比?

一句话结论

泛型默认不变(不支持隐式方向转换),类型安全;数组协变是历史遗留的不安全转换,写入可能抛 ArrayTypeMismatchException。

概念解释

不变性要求类型严格匹配,杜绝通过泛型引用写入错误类型。数组协变允许 Derived[] 赋给 Base[],但运行时仍检查元素类型,写入非兼容元素抛异常。

原理流程

  1. 泛型赋值:严格匹配或按 in/out 规则。
  2. 数组赋值:引用转换兼容,元素写入运行时校验。
  3. 不兼容写入抛异常。

代码或图示

string[] arr = { "a" };
object[] obj = arr;          // 数组协变(不安全)
// obj[0] = 1;               // 运行时抛 ArrayTypeMismatchException

常见误区

  • 以为数组协变在编译期保证安全:只保证引用转换,不保证元素写入安全。
  • 用泛型集合模拟数组协变:不变集合不提供该转换,需显式投影/转换。

追问

  • 为什么 BCL 保留数组协变?答:早期语言兼容遗留;新代码优先泛型集合。
  • 安全替代方案?答:IEnumerable<out T> 只读投影,或显式 Cast<T>()/Select 转换。

04.6.1.2-011 default 与 default(T) 怎么取值?

一句话结论

default(T) 返回类型参数默认值:引用类型为 null,值类型为零初始化;default 字面量可由上下文推断类型,简化泛型与可空场景代码。

概念解释

值类型默认是字段零值(数值 0、bool false、struct 零实例);引用类型默认 null。泛型方法无法直接 new T() 时用 default 占位。

原理流程

  1. 无约束类型参数取 default。
  2. 编译器按类型类别确定零值/null。
  3. 比较 EqualityComparer<T>.Default.Equals(x, default) 做安全相等判断。

代码或图示

public T GetOrDefault<T>() => default;
T x = default;
bool isDefault = EqualityComparer<T>.Default.Equals(x, default);

常见误区

  • 直接 x == default:未约束 T 可能不支持运算符,编译报错;用 EqualityComparer<T>。
  • 以为 default 对引用类型是空字符串:引用类型默认是 null。

追问

  • default 字面量与 default(T) 区别?答:语义相同,字面量由上下文推断类型参数;显式写法用于无法推断处。
  • 可空值类型 default 是什么?答:int? 默认是 null(HasValue=false)。

04.6.1.2-012 泛型类型参数如何比较相等与 null?

一句话结论

无约束 T 不能直接用 == 比较;用 EqualityComparer<T>.Default 做相等判断,用 default 判空;需要 null 比较时加 class 约束。

概念解释

编译器不知道 T 是否重载相等运算符,直接 == 报错。EqualityComparer<T>.Default 缓存类型比较器,值类型按值比较、引用类型按相等规则比较。

原理流程

  1. 优先用约束表达能力(如 IEquatable<T>)。
  2. 无约束用 EqualityComparer<T>.Default.Equals。
  3. 需要 null 判断时加 where T : class。

代码或图示

public bool IsZero<T>(T x) =>
    EqualityComparer<T>.Default.Equals(x, default);

常见误区

  • 对无约束 T 写 x == null:编译错误或语义不符;按约束选择比较方式。
  • 每次新建比较器:EqualityComparer<T>.Default 已缓存,复用即可。

追问

  • IEquatable<T> 约束有什么用?答:限定类型实现强类型相等,可直接调用 Equals(T)。
  • 哈希码在泛型中怎么取?答:EqualityComparer<T>.Default.GetHashCode(x),避免直接对 T 调 GetHashCode 的装箱/语义问题。

04.6.1.2-013 泛型静态字段与缓存隔离?

一句话结论

每个封闭泛型类型(具体类型参数组合)拥有独立静态字段;可利用这一特性做按类型隔离的缓存,但要注意内存占用与生命周期。

概念解释

静态状态按实例化类型隔离,Cache<Int32> 与 Cache<String> 互不影响。该机制常被用于泛型工厂/元数据缓存;但静态引用会持有类型与对象,注意不要造成泄漏。

原理流程

  1. 泛型类声明静态字段。
  2. 首次实例化某封闭类型时初始化。
  3. 不同类型参数的静态状态独立。

代码或图示

public static class TypeMeta<T> { public static readonly string Name = typeof(T).Name; }

常见误区

  • 以为静态字典按 key 隔离即可:泛型静态隔离是类型级,不能替代业务 key 缓存。
  • 静态集合持有对象不释放:长期驻留造成内存增长。

追问

  • 静态字段何时初始化?答:类型首次被访问/实例化时;具体触发时机以运行时类型初始化规则为准。
  • 泛型静态缓存的清理?答:静态生命周期跟随程序域;需要回收的缓存应放在实例容器中。

04.6.1.2-014 泛型方法类型推断规则?

一句话结论

编译器根据实参类型推断类型参数;推断不足(返回值/无参方法)时需显式指定 <T>;Lambda 表达式参数类型也参与推断。

概念解释

类型推断从参数类型出发反推 T,多个参数约束同一 T 时必须一致。泛型委托与方法组转换时,Lambda 体可帮助推断返回类型。

原理流程

  1. 收集实参类型。
  2. 推断每个类型参数。
  3. 无法唯一确定则报错,提示显式指定。

代码或图示

T Identity<T>(T x) => x;
var n = Identity(1);            // 推断 int
var t = Identity<long>(1);     // 显式指定

常见误区

  • 返回值参与推断:C# 类型推断不从赋值目标反推泛型参数(具体版本行为以语言规范为准)。
  • 多参数类型不一致:推断冲突导致编译错误。

追问

  • 显式指定泛型参数的场景?答:无参泛型方法、推断歧义、实参为 null/基类引用时。
  • 方法组与委托泛型匹配?答:委托类型参数约束方法签名,逆变协变规则参与兼容判断。

04.6.1.2-015 类型参数与反射怎么配合?

一句话结论

反射可读取开放/封闭泛型类型的类型参数与约束;运行时构造封闭类型后调用,注意 AOT/裁剪场景下反射可用性受限。

概念解释

Type.GetGenericArguments() 取类型参数,MakeGenericType 绑定具体类型。反射绕过编译期约束检查,需自行校验实参满足约束,否则运行时抛异常。

原理流程

  1. 获取开放泛型 typeof(Repo<>)。
  2. MakeGenericType(typeof(T)) 构造封闭类型。
  3. 反射创建实例并调用成员。

代码或图示

var open = typeof(Repo<>);
var closed = open.MakeGenericType(typeof(int));
var inst = Activator.CreateInstance(closed);

常见误区

  • 反射实例化不校验约束:不满足构造约束会抛 ArgumentException。
  • 在 AOT/裁剪环境依赖反射:动态代码可能被裁剪,需标注保留或改用源生成。

追问

  • 开放类型与封闭类型区别?答:开放类型参数未绑定,封闭类型参数已全部指定。
  • 泛型类型反射缓存?答:Type 对象可缓存,避免重复反射查询。

04.6.1.2-016 泛型与继承的约束关系?

一句话结论

泛型基类可带类型参数,派生类可固定参数或继续泛型;约束可沿继承传递,派生类需满足基类约束。

概念解释

Repository<T> 派生 BaseRepo<T> 继承链保留参数;IntRepo : Repository<Order> 固定为具体类型。构造派生类时,类型参数必须满足基类约束。

原理流程

  1. 基类声明类型参数与约束。
  2. 派生类复用参数或绑定具体类型。
  3. 编译器校验派生方向满足约束。

代码或图示

public abstract class Repo<T> where T : Entity { }
public class OrderRepo : Repo<Order> { }
public class ChildRepo<T> : Repo<T> where T : Entity { }

常见误区

  • 派生类忘记重复约束:若约束是派生类自身使用的成员所需,需在派生 where 中声明。
  • 固定参数不满足基类约束:编译错误。

追问

  • 泛型接口多实现?答:一个类可实现同接口的不同封闭版本(如 IRepo<int> 与 IRepo<string>)。
  • 基类泛型静态字段隔离?答:按封闭派生类型各自独立。

04.6.1.2-017 泛型委托与 Lambda 兼容规则?

一句话结论

Lambda/方法组按委托签名匹配泛型委托;返回类型与参数类型满足协变逆变即可转换,无需显式包装。

概念解释

Func<T, TResult> 的参数逆变、结果协变使 Lambda 与方法签名方向兼容。捕获闭包不影响委托类型兼容,只影响实例状态。

原理流程

  1. 目标委托声明泛型签名。
  2. Lambda 参数/返回类型匹配(含方向规则)。
  3. 编译器生成委托实例绑定方法/闭包。

代码或图示

Func<int, string> map = x => x.ToString();
Action<Derived> act = (Base b) => { };   // 逆变兼容

常见误区

  • 以为 Lambda 必须显式写参数类型:可由委托推断,但与显式类型混合时需一致。
  • 方法组转换忽略返回值:目标委托要求返回值时,方法必须有兼容返回。

追问

  • 闭包捕获对委托的影响?答:捕获变量提升到闭包对象,委托持有该对象生命周期。
  • 委托相等比较?答:委托按目标方法与目标对象比较,链组合后相等规则不同。

04.6.1.2-018 类型参数作为约束(裸约束)有什么用?

一句话结论

where U : T 让一个类型参数约束另一个参数,表达「U 必须是 T 的派生」,用于泛型工厂、拷贝与组合场景保证类型方向。

概念解释

裸约束把两个泛型参数的继承关系写入签名,编译器在实例化时检查。典型用途:返回 U 类型的工厂方法从 T 基类构造,或约束集合元素派生关系。

原理流程

  1. 声明两个类型参数 T、U。
  2. where U : T 约束派生方向。
  3. 方法体内可把 U 当 T 使用。

代码或图示

public TBase Create<TBase, TDerived>()
    where TDerived : TBase, new() => new TDerived();

常见误区

  • 把裸约束写成基类约束:类型参数之间的关系需单独 where 子句。
  • 反向约束导致无法实例化:方向与需求不符。

追问

  • 裸约束与普通接口约束区别?答:普通约束绑定固定基类/接口;裸约束在两个开放参数间表达派生。
  • 运行时校验?答:编译期保证;反射构造时仍需自行确认派生关系。