C#的泛型约束(Generic Constraints)有哪些类型？

c#的泛型约束主要有8种类型：1. where t : class（引用类型约束），确保t为引用类型，适用于处理对象实例的场景；2. where t : struct（值类型约束），要求t为值类型，常用于高性能数值操作；3. where t : new()（无参构造函数约束），允许通过new t()创建实例，适用于工厂模式；4. where t : （基类约束），限定t必须继承自指定基类，支持多态调用；5. where t : （接口约束），要求t实现特定接口，适用于行为契约统一处理；6. where t : u（裸类型约束），表示t必须是u或其派生类型，用于泛型间类型关系控制；7. where t : notnull（非空约束，c# 8.0+），确保t不可为空，提升代码可靠性；8. where t : unmanaged（非托管类型约束，c# 7.3+），限定t为非托管值类型，适用于低层高性能编程。这些约束共同提升了泛型代码的安全性与灵活性。

C# 的泛型约束主要有几种类型，它们帮助我们限制泛型类型参数可以接受的数据类型。简单来说，就是告诉编译器，这个泛型参数 T，它必须满足什么条件，比如它得是个引用类型，或者它得实现某个接口，再或者它得有个无参构造函数等等。这让我们的泛型代码既灵活又安全。

解决方案

谈到C#的泛型约束，这玩意儿在写一些通用组件或者库的时候，简直是神器。它让你能写出高度复用但又不会“失控”的代码。我个人在处理一些数据结构或者服务层抽象时，没少和它们打交道。

1.

where T : class

object

int

bool

public class ReferenceTypeProcessor<T> where T : class
{
    public void Process(T item)
    {
        // 可以在这里安全地对item进行引用类型的操作，比如检查是否为null
        if (item == null)
        {
            Console.WriteLine("Item is null.");
        }
        else
        {
            Console.WriteLine($"Processing a reference type: {item.GetType().Name}");
        }
    }
}

我发现这个约束在写ORM或者序列化工具时特别有用，因为你通常只关心对象实例。

2.

where T : struct

class

struct

null

public class ValueTypeProcessor<T> where T : struct
{
    public void Process(T item)
    {
        // 值类型天然不为null，可以直接使用
        Console.WriteLine($"Processing a value type: {item}");
    }
}

这个在处理数值计算或者需要避免堆分配的场景下挺方便的，比如一些高性能的集合操作。

3.

where T : new()

new T()

public class Factory<T> where T : new()
{
    public T CreateInstance()
    {
        return new T(); // 只有加了 new() 约束才能这么做
    }
}

我在写一些对象池或者简单工厂模式的时候，这个约束简直是必备的。否则，你根本不知道能不能

new

4.

where T : <base class name>

public class Animal { public virtual void MakeSound() => Console.WriteLine("Generic animal sound."); }
public class Dog : Animal { public override void MakeSound() => Console.WriteLine("Woof!"); }
public class AnimalProcessor<T> where T : Animal
{
    public void ProcessAnimal(T animal)
    {
        animal.MakeSound(); // 确保 T 有 MakeSound 方法
    }
}

这个约束在处理多态性的时候非常有用，比如我有一个处理不同类型动物的系统，但它们都继承自

Animal

5.

where T : <interface name>

public interface ILoggable { void Log(); }
public class MyData : ILoggable { public void Log() => Console.WriteLine("Logging MyData."); }
public class Logger<T> where T : ILoggable
{
    public void LogItem(T item)
    {
        item.Log(); // 确保 T 实现了 ILoggable 接口
    }
}

在设计插件系统或者需要特定行为契约的模块时，接口约束是我的首选。

6.

where T : U

public class Comparer<T, U> where T : U
{
    public bool IsCompatible(T itemT, U itemU)
    {
        // 如果 T 是 U 或 U 的派生类，这个逻辑才有意义
        return itemT.Equals(itemU);
    }
}

说实话，这个约束我用的相对少一些，但偶尔在设计一些复杂的数据转换或类型匹配逻辑时，它能派上大用场。

7.

where T : notnull

notnull

int?

string?

#nullable enable // 开启可空引用类型
public class NonNullProcessor<T> where T : notnull
{
    public void Process(T item)
    {
        // 编译器知道 item 不会是 null
        Console.WriteLine($"Processing non-null item: {item.ToString()}");
    }
}

这个约束在编写高可靠性的库时尤其重要，能有效减少

NullReferenceException

8.

where T : unmanaged

sbyte

byte

short

ushort

int

uint

long