在C#里写泛型方法或泛型类时，如果不对类型参数T做任何限制，编译器只能把它当成object来对待。你想调用T上的某个方法、比较两个T的大小、或者new一个T的实例，编译器都会直接报错。解决这个问题的办法就是使用where关键字给类型参数添加约束，告诉编译器T必须满足什么条件，约束一旦声明，编译器就允许你在泛型代码里使用这些条件带来的能力。本文从基础语法讲到高级用法，配合可直接运行的代码示例，把泛型约束这件事彻底讲清楚。
一、为什么需要泛型约束：从一段报错的代码说起
先看一段不加约束时的典型错误写法：
public class Container<T>
{
public T Value { get; set; }
public Container()
{
// 编译错误：无法创建类型 T 的实例
Value = new T();
}
public bool Compare(Container<T> other)
{
// 编译错误：运算符"=="无法应用于 T 和 T
return this.Value == other.Value;
}
}这两处报错的原因是一样的：编译器只知道T是一个类型参数，对它一无所知，不知道它有没有公共无参构造函数，也不知道两个T实例之间能不能用等号比较。要消除这些错误，就要在类型参数声明处加上where子句。
加上约束之后的效果：
public class Container<T> where T : new()
{
public T Value { get; set; }
public Container()
{
Value = new T(); // 编译通过，T保证有无参构造函数
}
}可以看到，约束的本质是一种“契约”：调用方承诺传入的类型必须满足条件，作为交换，泛型代码内部就获得了使用这些条件的能力。这也是泛型约束的核心价值，它把运行时才能发现的类型错误提前到了编译期，既保证了类型安全，又没有牺牲泛型的灵活性。
二、where关键字的基础语法与常用约束类型
where子句写在类型参数列表之后，语法是where T : 约束列表。多个约束之间用逗号隔开，比如where T : BaseClass, IComparable<T>, new()。如果一个泛型类有多个类型参数，可以写多个where子句，每个子句针对一个类型参数。
下面这段代码展示了常见的几种约束写法：
// 1. 类约束：T必须是Employee或其派生类
public class EmployeeRepository<T> where T : Employee
{
}
// 2. 接口约束：T必须实现IComparable接口
public class Sorter<T> where T : IComparable<T>
{
public T Max(T a, T b)
{
// CompareTo方法来自接口约束
return a.CompareTo(b) >= 0 ? a : b;
}
}
// 3. 构造函数约束：T必须有公共无参构造函数
public class Factory<T> where T : new()
{
public T Create() => new T();
}
// 4. 引用类型约束：T必须是类
public class Cache<T> where T : class
{
private Dictionary<string, T> _store = new();
public T? Get(string key) =>
_store.TryGetValue(key, out var v) ? v : null; // 可用null
}
// 5. 值类型约束：T必须是结构
public class Calculator<T> where T : struct
{
public T Zero => default; // 值类型的default是0，不是null
}
// 多个类型参数，各自带约束
public class Pair<TKey, TValue>
where TKey : notnull
where TValue : class, new()
{
}几点需要注意的规则：第一，where T : class中的class指的是引用类型，而写成具体类名如where T : Employee指的是继承关系，两者含义不同。第二，new()约束必须放在约束列表的最后一位。第三，struct约束和class约束互斥，不能同时出现。第四，类约束只能指定一个基类（因为C#不支持多重继承），但接口约束可以有多个。
还有一个容易混淆的点：约束为struct时，T不能是可空值类型（如int?），因为Nullable本身也是结构体，会造成约束歧义，编译器直接禁止了这种组合。此外，如果约束的是枚举类型，可以写成where T : struct, Enum的组合形式。
三、高级约束：notnull、unmanaged与委托约束
C# 8.0引入了可空引用类型之后，notnull约束应运而生。它要求类型参数是非可空类型，也就是说string满足约束，而string?不满足。这个约束主要服务于启用可空注解的代码库：
#nullable enable
public class Settings<TKey> where TKey : notnull
{
private Dictionary<TKey, string> _map = new();
public void Set(TKey key, string value) => _map[key] = value;
}
// 正确用法
var s1 = new Settings<string>();
// 警告：string?不满足notnull约束
var s2 = new Settings<string?>();unmanaged约束要求T是非托管类型，即基元类型、枚举、指针，或者只包含非托管类型字段的结构体。满足这个约束的类型可以直接和底层内存交互，最常见的用途是高性能序列化场景，直接把结构体的字节拷贝出来而不用反射：
public static class BinaryHelper
{
public static byte[] ToBytes<T>(T value) where T : unmanaged
{
int size = System.Runtime.InteropServices.Marshal.SizeOf(typeof(T));
byte[] buffer = new byte[size];
unsafe
{
System.Runtime.InteropServices.Marshal.Copy(
(IntPtr)(&value), buffer, 0, size);
}
return buffer;
}
}
// int、double、自定义的纯值类型结构体都可以
byte[] bytes = BinaryHelper.ToBytes(3.14);约束还可以是接口或基类的泛型形式，也支持自引用约束，让继承体系保持类型安全：
// 基类本身是泛型的，约束写成 BaseComparer<T>
public class AdvancedComparer<T> : BaseComparer<T> where T : BaseComparer<T>
{
}
// 委托约束：C# 7.3开始支持
public static class Invoker
{
public static void Run<T>(T action) where T : System.Delegate
{
action.DynamicInvoke();
}
}四、约束的继承规则与实战场景
泛型约束有一个重要的继承特性：派生的泛型类不能移除基类的约束，只能保留或追加更严格的约束。看下面的例子：
public class BaseRepository<T> where T : Entity, new()
{
public virtual T CreateNew() => new T();
}
// 正确：保留基类约束
public class SqlRepository<T> : BaseRepository<T> where T : Entity, new()
{
}
// 编译错误：不能放宽或移除基类的约束
// public class WeakRepository<T> : BaseRepository<T> { }
// 允许：追加额外约束，约束变得更严格
public class CachedRepository<T> : BaseRepository<T>
where T : Entity, new(), ICacheable
{
}在方法层面，覆写和显式实现接口方法时，约束会自动继承，不需要也不能重新声明。但普通方法重载时，如果两个方法仅靠约束区分，编译会失败，因为约束不属于方法签名的一部分，这是初学者常踩的坑。
最后看一个综合实战：利用约束实现一个通用的缓存包装器，它要求缓存对象是引用类型、可比较、且有无参构造函数，全部约束条件叠加在一起：
public interface IIdentifiable<TKey> where TKey : notnull
{
TKey Id { get; }
}
public class MemoryCache<TEntity, TKey>
where TEntity : class, IIdentifiable<TKey>, new()
where TKey : notnull
{
private readonly Dictionary<TKey, TEntity> _data = new();
public TEntity GetOrCreate(TKey id)
{
if (!_data.TryGetValue(id, out var entity))
{
entity = new TEntity(); // 依赖new()约束
_data[id] = entity;
}
return entity;
}
public bool Remove(TEntity entity)
{
return _data.Remove(entity.Id); // 依赖接口约束
}
}这个例子体现了约束设计的思路：只声明真正需要的条件。约束越少，泛型代码适用面越广；约束越多，能力越强但限制也越大。写泛型时的推荐做法是，先不加任何约束，遇到编译错误时再逐条添加最小化的约束，这样能保证API不会被过度限制。
总结一下：where关键字是C#泛型体系里承上启下的关键语法，类和接口约束解决能力问题，new()约束解决实例化问题，struct、class、notnull、unmanaged解决类型分类问题。理解每种约束的适用场景和继承规则，再结合最小化约束原则，就能写出既类型安全又不失灵活性的泛型代码。