C# 协变和逆变

2026-02-19

协变（Covariance）和逆变（Contravariance）

C#里的协变（Covariance）和逆变（Contravariance）主要是解决泛型类型之间能不能“安全替换”的问题，本质是“类型兼容性在泛型里的延伸”。

协变（out）：👉 “可以用更具体的类型替换更通用的类型”
逆变（in）：👉 “可以用更通用的类型替换更具体的类型”

1 2	class Animal {} class Dog : Animal {}

1.协变（out）：需要Animal但给Dog也可以
特点：只能用于返回值，不能用于参数输入
示例：

interface IProducer<out T>
{
    T Produce();
}

使用：

1 2	IProducer<Dog> dogProducer = ...; IProducer<Animal> animalProducer = dogProducer; // 协变成立

因为Dog是Animal的子类
❗为什么安全？
你只是“取出来”，不会往里面塞东西。
反例：

interface IBad<out T>
{
    void Set(T value); // ❌ 不允许
}

2.逆变（in）：需要Dog但给一个能处理的Animal也可以
特点：只能用于方法传参，不能用于返回值
示例：

interface IConsumer<in T>
{
    void Consume(T item);
}

使用

1 2	IConsumer<Animal> animalConsumer = ...; IConsumer<Dog> dogConsumer = animalConsumer; // 逆变成立

❗为什么安全？

因为：

1	dogConsumer.Consume(new Dog());

👉 实际调用的是：

1	animalConsumer.Consume(Animal);

✔️ Dog 也是 Animal → 安全
🚫 错误用法

interface IBad<in T>
{
    T Get(); // ❌ 不允许
}

类型	方向	记忆
协变	子 → 父	“给我更具体也行”
逆变	父 → 子	“我能处理更泛的”

何时用？

你在设计接口时：

✅ 用协变（out）

只返回 T 不接收 T

👉 典型：读取数据

✅ 用逆变（in）

只接收 T 不返回 T

👉 典型：处理/消费数据

总结一句话

👉 协变和逆变的本质：

让泛型在“只读”或“只写”的情况下变得更灵活且类型安全

完整例子

using System;

namespace VarianceDemo
{
    // ===== 基础类型 =====
    class Animal
    {
        public string Name { get; set; }
    }

    class Dog : Animal
    {
        public void Bark()
        {
            Console.WriteLine("Dog is barking");
        }
    }

    // ===== 协变接口（out）=====
    interface IProducer<out T>
    {
        T Produce();
    }

    class DogProducer : IProducer<Dog>
    {
        public Dog Produce()
        {
            return new Dog { Name = "Buddy" };
        }
    }

    // ===== 逆变接口（in）=====
    interface IConsumer<in T>
    {
        void Consume(T item);
    }

    class AnimalConsumer : IConsumer<Animal>
    {
        public void Consume(Animal item)
        {
            Console.WriteLine($"Consuming animal: {item.Name}");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("=== 协变（Covariance）示例 ===");

            // DogProducer 实现的是 IProducer<Dog>
            IProducer<Dog> dogProducer = new DogProducer();

            // 👇 关键：协变（子类型 -> 父类型）
            IProducer<Animal> animalProducer = dogProducer;

            // 调用返回 Animal（实际上是 Dog）
            Animal animal = animalProducer.Produce();
            Console.WriteLine($"Produced animal: {animal.Name}");

            Console.WriteLine();

            Console.WriteLine("=== 逆变（Contravariance）示例 ===");

            // AnimalConsumer 实现的是 IConsumer<Animal>
            IConsumer<Animal> animalConsumer = new AnimalConsumer();

            // 👇 关键：逆变（父类型 -> 子类型）
            IConsumer<Dog> dogConsumer = animalConsumer;

            // 传入 Dog
            dogConsumer.Consume(new Dog { Name = "Max" });

            Console.WriteLine();

            Console.WriteLine("=== 委托示例 ===");

            // 协变（返回值）
            Func<Dog> dogFunc = () => new Dog { Name = "Rocky" };
            Func<Animal> animalFunc = dogFunc;

            Console.WriteLine($"Func result: {animalFunc().Name}");

            // 逆变（参数）
            Action<Animal> actAnimal = a => Console.WriteLine($"Action: {a.Name}");
            Action<Dog> actDog = actAnimal;

            actDog(new Dog { Name = "Charlie" });
        }
    }
}

输出：

=== 协变（Covariance）示例 ===
Produced animal: Buddy

=== 逆变（Contravariance）示例 ===
Consuming animal: Max

=== 委托示例 ===
Func result: Rocky
Action: Charlie