泛型的协变（Covariance）和逆变（Contravariance）

原创 已于 2025-11-02 01:08:48 修改 · 369 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c#

于 2025-10-28 18:17:32 首次发布

一、什么是协变和逆变

  • 如果存在一个泛型接口IFoo<T>
    它的泛型参数的子类型IFoo<Dog>可以安全的转换成泛型父类型的IFoo<Animal>
    这个过程就称为协变

  • 如果存在一个泛型接口IFoo<T>
    它的泛型参数的父类型IFoo<Animal>可以安全的转换成泛型子类型的IFoo<Dog>
    这个过程就成为逆变

    我们先明确两个术语：

  • 协变（Covariance）：保持类型顺序。如果 Dog 是 Animal 的子类，那么 IEnumerable<Dog> 可以被视为 IEnumerable<Animal>

  • 逆变（Contravariance）：反转类型顺序。如果 Dog 是 Animal 的子类，那么 Action<Animal> 可以被视为 Action<Dog>

二、协变与逆变解决的问题

  • 假设你有如下类层次：
    class Animal { }
class Dog : Animal { }
    在没有协变的情况下，以下代码会编译失败：
    List<Dog> dogs = new List<Dog>();

List<Animal> animals = new List<Dog>(); //❌编译错误！List<Dog> 不能赋值给 List<Animal> ,泛型不变性，非法。

IEnumerable<Animal> = new List<Dog>();  //✅协变，合法。因为IEnumerable是支持协变的
//IEnumerable泛型的定义为：public interface IEnumerable<out T> : IEnumerable
    因为泛型默认是 不变（Invariant） 的，即 List<Dog> 和 List<Animal> 没有继承关系。
    但直觉上，狗的列表“应该是”动物列表的一种。协变就是为了解决这种合理的类型转换需求，同时保证类型安全。

三、实际应用场景

  • 协变： 你有一个 IReadOnlyList<IDocument>，但实际传入的是 IReadOnlyList<PdfDocument>，协变让它可以接受。
  • 逆变： 你有一个排序器IComparer<object>，它可以用于比较任何对象，包括 string 或 Person，所以可以赋值给 IComparer<string>

四、协变与逆变的使用

  • 协变（out）和逆变（in）关键字 只能用于 泛型接口（interface）和泛型委托（delegate） 的类型参数上。
    它们不能用于类（class）、结构体（struct）或枚举（enum）的泛型参数。

1、C# 使用 out 和 in 关键字来声明协变和逆变：

  • out T：表示 协变（Covariance），T 只能作为方法的返回值（输出），不能作为方法的参数

    // 协变：T 只作为返回值（生产者），不能作为接口内部方法的参数类型。
public interface IProducer<out T>
{
	T Produce(); // ✅方法返回 T，T 是“输出” 
	//void  Produce(T t); // ❌out T 表示这个类型参数 T 只能作为接口内部方法的返回值，不能作为参数。
}

  • in T ：表示 逆变（Contravariance），T 只能作为方法的参数（输入），不能作为方法的返回值

    // 逆变：T 只作为输入参数（消费者），不能作为接口内部方法的返回值
public interface IConsumer<in T>
{
	void Consume(T item); // ✅T 是“输入”，不能作为返回值
	//T Produce(); // ❌in T 表示这个类型参数 T 只能接口内部方法的参数，不能作为返回值。
}

2、要这么设计？

  • 协变 out T：T 只能作为返回值（输出）

  • 含义： 如果 T 是协变的，那么 IEnumerable<Cat> 可以当作 IEnumerable<Animal> 使用，因为“猫是动物”。

  • 安全前提： 你只能“读”出 T 类型的对象，不能往里面写。因为写入可能会破坏类型安全。

  • 设计原因： 允许更宽松的类型赋值，提升多态性，同时保证类型安全。

  • ✅ 安全：从 IEnumerable<猫> 读出一个“猫”，当作“动物”用，没问题！

  • 逆变 in T：T 只能作为参数（输入）

  • 含义： 如果 T 是逆变的，那么 IComparer<Animal> 可以当作 IComparer<Cat> 使用。

  • 安全前提： 你只会把 T 类型的对象传给方法，而不会从方法中返回 T。

  • 设计原因： 一个能比较“任何动物”的比较器，当然也能比较“猫”。

  • ✅ 安全：把一只“猫”传给一个能处理“动物”的比较器，没问题！

3、如果不加限制会怎样？

🛑1、为什么 out T 必须禁止 T 作为参数

  • 错误案例1：

    // 错误示例：如果允许协变位置传参
IEnumerable<动物> animals = new List<猫>(); // 假设协变允许
animals.Add(new 狗()); // ❌ 危险！List<猫> 里加入了 狗！

  • 错误案例2：

    // ❌ 错误设计：逆变接口却允许返回 T
public interface IProblematic<in T>
{
	void SetAnimal(T animal);     // ✅ 输入：逆变允许
	T GetAnimal();                // ❌ 危险！逆变不允许返回 T，但假设这里允许
}

    ⚠️ 注意：C# 编译器会阻止你在 in T 接口中将 T 作为返回值。但我们现在“假设”它允许，来看后果。

    实现这个危险接口：

    public class AnimalHandler<T> : IProblematic<T>
{
	private T _animal;

	public void SetAnimal(T animal)
	{
    	_animal = animal;
	}

	public T GetAnimal()
	{
    	// 假设我们返回一个“通用的默认动物”
    	if (_animal == null)
        	return (T)(object)new Animal { Name = "Generic Animal" };
    	return _animal;
	}
}

    现在开始“类型欺骗”：

    // 1. 创建一个处理 Animal 的实例
IProblematic<Animal> animalHandler = new AnimalHandler<Animal>();

// 2. 逆变转换：把它当作 IProblematic<Cat> 使用（因为 Animal 是 Cat 的父类）
IProblematic<Cat> catHandler = animalHandler; // ❌ 如果允许，这里就出问题了

    ✅ 逻辑上似乎合理：一个能处理“任何动物”的组件，应该也能处理“猫”。

    但危险来了：

    // 3. 使用 catHandler 设置一个猫
catHandler.SetAnimal(new Cat { Name = "Mimi" });

// 4. 现在尝试获取一个 Cat
Cat myCat = catHandler.GetAnimal(); // ❌ 运行时错误！

    💥 问题在哪？
    catHandler 实际是 AnimalHandler<Animal>，它的 _animal 是 Animal 类型。
    GetAnimal() 返回的是 Animal，但 catHandler.GetAnimal() 声称返回的是 Cat。
    如果内部返回的是普通 Animal（不是 Cat），强转成 Cat 会抛出 InvalidCastException。

🛑 2、为什么 in T 必须禁止 T 作为返回值？

  • 因为：
    逆变允许：IContravariant<Animal> → IContravariant<Cat>
    但 IContravariant<Animal>.GetAnimal() 可能返回 Dog、Cat等任何动物
    如果你把它当作 IContravariant<Cat>，就期望 GetAnimal() 返回 Cat
    但实际上可能返回 Dog，导致类型系统崩溃

    结论：逆变位置如果允许返回 T，就会破坏类型安全。

    ✅ 正确设计：in T 只允许 T 作为输入

    public interface ISafeConsumer<in T>
{
	void Feed(T animal);  // ✅ 安全：传入 Cat，实际处理 Animal，没问题
	// T GetAnimal();     // ❌ 编译错误！不允许返回 T
}

    使用：

    ISafeConsumer<Animal> animalFeeder = new AnimalFeeder();
ISafeConsumer<Cat> catFeeder = animalFeeder;

catFeeder.Feed(new Cat()); // ✅ 安全：Cat 传给能处理 Animal 的方法

    ✅ 安全原因：你只传入 Cat，系统把它当作 Animal 处理，没问题。

五、协变与逆变的使用案例

  • 1、定义基础类和继承关系

    // 动物基类
public class Animal
{
	public string Name { get; set; }

	public Animal(string name)
	{
		Name = name;
	}

	public virtual void Speak()
	{
		Console.WriteLine($"{Name} 发出了声音。");
	}
}

// 狗类，继承自动物
public class Dog : Animal
{
	public Dog(string name) : base(name) { }

	public override void Speak()
	{
		Console.WriteLine($"{Name} 汪汪叫。");
	}
}

// 猫类，继承自动物
public class Cat : Animal
{
	public Cat(string name) : base(name) { }

	public override void Speak()
	{
		Console.WriteLine($"{Name} 喵喵叫。");
	}
}

  • 2、协变（Covariance）示例：out T

    // 协变：使用 out T
public interface ICovariant<out T>
{
	T GetAnimal();
}

public class AnimalProducer : ICovariant<Animal>
{
	public Animal GetAnimal() => new Animal("普通动物");
}

public class DogProducer : ICovariant<Dog>
{
	public Dog GetAnimal() => new Dog("小狗旺财");
}

    使用协变

    // 因为 ICovariant<out T> 是协变的，所以 DogProducer 可以当作 AnimalProducer 使用
ICovariant<Animal> producer = new DogProducer(); // 协变：Dog -> Animal
Animal animal = producer.GetAnimal();
animal.Speak(); // 输出：小狗旺财 汪汪叫。

  • 3、逆变（Contravariance）示例：in T
    逆变允许你将 IContravariant 赋值给 IContravariant，适用于消费输入的场景。

    // 逆变：使用 in T
public interface IContravariant<in T>
{
	void Feed(T animal);
}

public class AnimalFeeder : IContravariant<Animal>
{
	public void Feed(Animal animal)
	{
		Console.WriteLine($"喂食 {animal.Name}（通用饲料）");
	}
}

public class DogFeeder : IContravariant<Dog>
{
	public void Feed(Dog dog)
	{
		Console.WriteLine($"喂食 {dog.Name}（狗粮）");
	}
}

    使用逆变

    // 因为 IContravariant<in T> 是逆变的，所以 AnimalFeeder 可以用于 Dog
IContravariant<Dog> dogFeeder = new AnimalFeeder(); // 逆变：Animal <- Dog
dogFeeder.Feed(new Dog("小狗乐乐")); // 输出：喂食 小狗乐乐（通用饲料）

六、排序器案例（in 逆变）：

  • 在 .NET 中，IComparer 接口已经声明了逆变（in 关键字）。这意味着你不需要“实现一个支持逆变的 IComparer”，因为这个接口本身就支持逆变。

    IComparer<T> 的定义：

    public interface IComparer<in T>
{
	int Compare(T x, T y);
}

    注意泛型参数 T 前面的 in 关键字。这表示 IComparer 是逆变的。
    逆变意味着什么？
    如果 Dog 是 Animal 的子类（Dog : Animal），那么 IComparer 可以被当作 IComparer 来使用

    using System;
using System.Collections.Generic;

public class Animal
{
	public string Name { get; set; }
	public int Age { get; set; }
}

public class Dog : Animal
{
	public string Breed { get; set; } // Dog 特有的属性
}

// 实现一个针对比较所有 Animal 的比较器，可以用于 Dog、Cat 等子类（逆变）
// 这种支持逆变的排序器，一般用用于一个父类，比如Animal，
public class AnimalComparer : IComparer<Animal>
{
	public int Compare(Animal? x, Animal? y)
	{
		if (x is null) return y is null ? 0 : -1;
		if (y is null) return 1;

		// 只使用 Animal 类中定义的成员
		// 这样做是安全的，并且支持逆变
		int nameComparison = string.Compare(x.Name, y.Name, StringComparison.Ordinal);
		if (nameComparison != 0) return nameComparison;

		return x.Age.CompareTo(y.Age);
	}
}

// 另一个例子：按年龄比较
public class AgeComparer : IComparer<Animal>
{
	public int Compare(Animal? x, Animal? y)
	{
		if (x is null) return y is null ? 0 : -1;
		if (y is null) return 1;
		return x.Age.CompareTo(y.Age);
	}
}

    利用逆变

    class Program
{
	static void Main()
	{
		List<Dog> dogs = new List<Dog>
		{
			new Dog { Name = "Buddy", Age = 5, Breed = "Golden Retriever" },
			new Dog { Name = "Max", Age = 3, Breed = "German Shepherd" },
			new Dog { Name = "Charlie", Age = 7, Breed = "Bulldog" }
		};

		// 创建一个 Animal 的比较器
		IComparer<Animal> comparer = new AnimalComparer();

		// 利用逆变，直接用于 Dog 列表
		dogs.Sort(comparer); // ✅ 因为 IComparer<Animal> 是 IComparer<Dog> 的“超类型”

		// 或者，直接赋值
		IComparer<Dog> dogComparer = comparer; // ✅ 逆变允许这种赋值
		dogs.Sort(dogComparer);

		foreach (var dog in dogs)
		{
			Console.WriteLine($"{dog.Name} ({dog.Age}) - {dog.Breed}");
		}
	}
}

七、通用排序的封装

  • 代码
    using System;
using System.Collections.Generic;
using System.Linq;

// 示例类：动物和其子类
public class Animal
{
	public string Name { get; set; }
}

public class Dog : Animal
{
	public string Breed { get; set; }
}

public class Cat : Animal
{
	public string Color { get; set; }
}

// 一个通用的、支持逆变的排序器
public static class SortHelper
{
	/// <summary>
	/// 对任意类型的集合进行排序，支持逆变比较器
	/// </summary>
	/// <typeparam name="T">集合元素类型</typeparam>
	/// <param name="items">待排序的集合</param>
	/// <param name="comparer">比较器，支持逆变（IComparer<in T>）</param>
	/// <returns>排序后的列表</returns>
	public static List<T> Sort<T>(IEnumerable<T> items, IComparer<T> comparer)
	{
		if (items == null) throw new ArgumentNullException(nameof(items));

		var list = items.ToList();
		list.Sort(comparer);
		return list;
	}

	/// <summary>
	/// 使用 Func 创建比较器（方便使用）
	/// </summary>
	/// <typeparam name="T">元素类型</typeparam>
	/// <typeparam name="TKey">排序键类型，需支持比较</typeparam>
	/// <param name="items">集合</param>
	/// <param name="keySelector">选择排序键的函数</param>
	/// <param name="descending">是否降序</param>
	/// <returns>排序后的列表</returns>
	public static List<T> SortBy<T, TKey>(
		IEnumerable<T> items, 
		Func<T, TKey> keySelector, 
		bool descending = false) 
		where TKey : IComparable<TKey>
	{
		return descending 
			? items.OrderByDescending(keySelector).ToList()
			: items.OrderBy(keySelector).ToList();
	}
}

// 一个针对 Animal 的比较器，可以用于 Dog、Cat 等子类（逆变）
public class AnimalNameComparer : IComparer<Animal>
{
	public int Compare(Animal x, Animal y)
	{
		if (x == null && y == null) return 0;
		if (x == null) return -1;
		if (y == null) return 1;
		return string.Compare(x.Name, y.Name, StringComparison.OrdinalIgnoreCase);
	}
}

// 演示程序
class Program
{
	static void Main()
	{
		var dogs = new List<Dog>
		{
			new Dog { Name = "Buddy" },
			new Dog { Name = "Max" },
			new Dog { Name = "Charlie" }
		};

		// ✅ 关键：AnimalNameComparer 实现了 IComparer<Animal>
		// 但由于 IComparer<in T> 是逆变的，它可以赋值给 IComparer<Dog>
		IComparer<Dog> dogComparer = new AnimalNameComparer();

		// 使用通用排序方法
		var sortedDogs = SortHelper.Sort(dogs, dogComparer);

		Console.WriteLine("Sorted Dogs by Name:");
		foreach (var dog in sortedDogs)
		{
			Console.WriteLine(dog.Name);
		}

		// 使用 SortBy 辅助方法（更简洁）
		var sortedByLambda = SortHelper.SortBy(dogs, d => d.Name);
		Console.WriteLine("\nSorted by Lambda:");
		sortedByLambda.ForEach(d => Console.WriteLine(d.Name));
	}
}

八、.Net 内置支持协变和逆变的接口和委托

1、内置支持协变的 接口 和 委托

  • IEnumerable<out T> 作用: 所有可枚举集合的基础接口。

    List<string> strings = new List<string> { "hello", "world" };
IEnumerable<object> objects = strings; // 协变：IEnumerable<string> -> 	IEnumerable<object>

  • IEnumerator<out T> 作用: 枚举器接口。

    IEnumerator<string> stringEnumerator = GetStrings().GetEnumerator();
IEnumerator<object> objectEnumerator = stringEnumerator; // 协变

  • IQueryable<out T> 作用: LINQ 查询的核心接口。

    IQueryable<string> stringQuery = context.Strings;
IQueryable<object> objectQuery = stringQuery; // 协变

  • IComparable<out T> 作用: 定义通用比较方法。

    IComparable<string> stringComparer = ...;
IComparable<object> objectComparer = stringComparer; // 协变

  • IAsyncEnumerable<out T> 作用：用于表示一个可以异步枚举的元素序列。它是 IEnumerable 的异步对应物，是 async/await 和 await foreach 语法的基础。

    // 假设有一个返回 IAsyncEnumerable<string> 的异步方法
IAsyncEnumerable<string> GetStringsAsync()
{
	return AsyncEnumerable.FromArray("hello", "world");
}

// 因为 IAsyncEnumerable<out T> 是协变的，所以可以将 IAsyncEnumerable<string> 赋值给 	IAsyncEnumerable<object>
IAsyncEnumerable<object> GetObjectsAsync()
{
	return GetStringsAsync(); // ✅ 这是合法的协变赋值
}

// 使用 await foreach
await foreach (object obj in GetObjectsAsync())
{
	Console.WriteLine(obj);
}

  • IReadOnlyCollection<out T> 作用：表示其元素可读但不可修改的元素集合。它继承自 IEnumerable，并添加了 Count 属性。

    IReadOnlyCollection<string> stringCollection = new List<string> { "a", "b" };
IReadOnlyCollection<object> objectCollection = stringCollection; // ✅ 协变

  • IReadOnlyList<out T> 作用：表示其元素可读但不可修改的元素列表。它继承自 IReadOnlyCollection 和 IEnumerable，并提供了基于索引的访问（this[int index]）。

    IReadOnlyList<string> stringList = new List<string> { "first", "second" };
IReadOnlyList<object> objectList = stringList; // ✅ 协变

  • Func<out TResult> 作用: 表示一个不带参数、返回 TResult 类型的函数。

    Func<string> getString = () => "Hello";
Func<object> getObject = getString; // 协变：Func<string> -> Func<object>

  • Func<in T, out TResult> 作用: 表示一个带一个参数 T 并返回 TResult 的函数。TResult 是协变的。

    Func<int, string> intToString = x => x.ToString();
Func<int, object> intToObject = intToString; // 协变：Func<int, string> -> Func<int, object>

    同理，Func<in T1, in T2, out TResult>, Func<in T1, in T2, in T3, out TResult> 等，
    所有 Func 委托的最后一个类型参数（返回值）都是协变的。

2、内置支持逆变的 接口 和 委托

  • IComparer<in T> 作用: 定义对象的比较方法。
    IComparer<object> objectComparer = Comparer<object>.Default;
IComparer<string> stringComparer = objectComparer; // 逆变：IComparer<object> -> IComparer<string>
// 因为任何能比较 object 的比较器，也一定能比较 string（string 是 object 的子类）
  • IEqualityComparer<in T> 作用: 定义对象的相等性比较方法。
    IEqualityComparer<object> objectEq = EqualityComparer<object>.Default;
IEqualityComparer<string> stringEq = objectEq; // 逆变
  • IObserver<in T> 作用: 这是响应式扩展（Reactive Extensions, Rx）模式的核心接口，定义了数据“消费者”的契约。它与 IObservable 配对使用，构成了 .NET 中的观察者模式（发布-订阅模式）的基础。
    // 假设我们有一个可以处理任何 object 事件的通用日志记录观察者
IObserver<object> loggerObserver = new LoggerObserver(); // 实现了 OnNext, OnError, OnCompleted

// 因为 IObserver<in T> 是逆变的，所以可以将 IObserver<object> 赋值给 IObserver<string>
IObserver<string> stringObserver = loggerObserver; // ✅ 这是合法的

// 现在，一个发布 string 事件的可观察对象，可以安全地使用这个 object 观察者
var stringObservable = Observable.Return("Hello, Rx!");
stringObservable.Subscribe(stringObserver); // 会调用 loggerObserver.OnNext("Hello, Rx!")
  • Action<in T> 作用: 表示一个接受 T 类型参数、无返回值的操作。
    Action<object> printObject = obj => Console.WriteLine(obj);
Action<string> printString = printObject; // 逆变：Action<object> -> Action<string>
// 因为任何能处理 object 的操作，也一定能处理 string
printString("Hello"); // 实际上调用 printObject("Hello")
  • Action<in T1, in T2> 作用: 表示一个接受两个参数的操作。所有参数类型都是逆变的。
    Action<object, object> logObjects = (a, b) => Console.WriteLine($"{a}, {b}");
Action<string, string> logStrings = logObjects; // 逆变
  • Predicate<in T> 作用: 表示一个定义一组条件并判断对象是否符合条件的委托。
    Predicate<object> isNotNull = obj => obj != null;
Predicate<string> isStringNotNull = isNotNull; // 逆变
  • Func<in T, out TResult> 作用: 如前所述，Func 委托的输入参数 T 是逆变的。
    Func<object, string> objectToString = obj => obj?.ToString() ?? "null";
Func<string, string> stringToString = objectToString; // 逆变：Func<object, string> -> Func<string, string>
// 因为这个函数能处理任何 object，自然也能处理 string
C#中的泛型约束与协变、逆变详解
java专栏
04-22 956
上述内容包含了C#泛型约束与协变、逆变的基本概念、实现步骤以及代码示例，每个示例均配有详细的注释，解释了其工作原理和适用场景。通过这些示例，您可以逐步理解和掌握如何在实际项目中运用泛型约束以及协变、逆变特性来编写类型安全、灵活且高效的代码。通过本篇深入剖析，您应已全面理解C#泛型约束与协变、逆变的概念及其应用场景，并掌握了如何通过代码实现这些特性。泛型约束是C#中用于限制泛型类型参数的特性，确保它们满足特定条件或具有特定功能。这些约束增强了编译时类型安全性，允许开发者在泛型代码中使用特定类型的操作。
C#中的泛型协变和逆变
NoerrorCode的博客
09-27 137
在C#中，泛型是一种非常强大的特性，它允许我们编写可以在多种类型上工作的可重用代码。泛型协变（covariance）和逆变（contravariance）是C# 4.0引入的概念，它们使得泛型类型更加灵活，并能够更好地支持类型转换。泛型协变和逆变是C#中非常有用的特性，它们使得泛型类型参数更加灵活，并能够更好地适应派生类和基类之间的关系。通过使用泛型协变和逆变，我们可以提高代码的复用性和灵活性。，但是该接口的类型参数被声明为逆变类型。通过泛型协变，我们可以将。通过泛型逆变，我们可以将。
scala中泛型，协变和逆变
LeoHan
01-03 486
<:表示泛型的上限，传递数据应该是当前类，或者当前类的子类 >:表示泛型的下限，和java不太一样，什么类型都可以传递 scala中为了丰富泛型的功能，提供了协变（+）和逆变（-）的功能 Scala的协变(+)，逆变(-)，协变covariant、逆变contravariant、不可变invariant 对于一个带类型参数的类型，比如 C[T]，如果对A及其子类型B，满足C[B]也符合 C[A]的子类型，那么就称为covariance(协变) ，如果 C[A]是 C[B]的子类型，即与原来的父
C# 泛型中的协变和逆变
李赛赛的专栏
01-07 1441
💎协变和逆变都是术语，前者指能够使用比原始指定的派生类型的派生程度更大（更具体的）的类型，后者指能够使用比原始指定的派生类型的派生程度更小（不太具体的）的类型。泛型类型参数支持协变和逆变，可在分配和使用泛型类型方面提供更大的灵活性。在引用类型系统时，协变、逆变和不变性具有如下定义。这些示例假定一个名为Base的基类和一个名为Derived的派生类。Covariance使你能够使用比原始指定的类型派生程度更大的类型。你可以将的实例分配给类型的变量。
C#中泛型的协变和逆变
qq_38655556的博客
03-03 1178
通过在接口中使用。
Java 泛型的协变与逆变
qq_38074398的博客
06-06 1765
Java 泛型中的协变与逆变
C# 泛型-协变、逆变
素弦的博客
05-20 573
协变就是对具体成员的输出参数进行一次类型转换，且类型转换的准则是 “里氏替换原则3. 逆变(Contravariance)逆变就是对具体成员的输入参数进行一次类型转换，且类型转换的准则是 “里氏替换原则4. 总结本质上是里氏替换原则，由里氏替换原则可知：派生程度小的是派生程度大的子集，所以子类替换父类的位置整个程序功能都不会发生改变。原文链接[C# 协变、逆变。
Java泛型的协变与逆变
m0_54828003的博客
08-03 1085
从面向对象说起 Java作为一门面相对象的语言，当然是支持面相对象的三大基本特性的，反手就蹦出三个词：封装、继承、多态。我们假设有三个类，动物、猫、狗。父类是动物Animal，有两个子类猫Cat和狗Dog。那在Java中或其它任何支持面相对象的语言中，子类可以把引用赋值给父类。下面这段代码没有任何问题：Animal animalOne = new Cat(); Animal animalTwo = new Dog(); 1 理论上来说，一只猫是一只动物，一只狗也是一只动物，所以这完全是可以理解的。其实，这也
C#-弄懂泛型和协变、逆变
进击的前端小白
05-25 800
C#-弄懂泛型和协变、逆变 脑图概览# 泛型声明和使用# 协变和逆变# 《C#权威指南》上在委托篇中这样定义： 协变：委托方法的返回值类型直接或者间接地继承自委托前面的返回值类型; 逆变：委托签名中的参数类型继承自委托方法的参数类型； 在泛型篇中这样定义： 协变：泛型参数定义的类型只能作为方法的返回类型，不能作为方法的参数类型，且该类型直接或者间接地继承自接口方法的返回值类型;可以使用out关键字声明协变参数。 逆变：泛型参数定义的类型只能作为方法参数的类型，不能作为返回值类型，且该类型是接口方法的
解析Java中泛型，重点说明协变与逆变
weixin_40261082的博客
06-27 1419
解析Java中的泛型，重点说明协变与逆变
泛型协变与逆变：Kotlin 与 Java 的异同
liuzipeizliuziyu的博客
12-03 707
在编程中，泛型的协变（covariance）和逆变（contravariance）是处理类型兼容性和安全性的重要工具。Kotlin 提供out和in关键字，而 Java 使用?extends和?super通配符实现类似功能。本文将从概念、规则、使用场景及示例等方面，详细分析 Kotlin 和 Java 的实现方式及异同点。协变允许使用子类型的泛型对象赋值给父类型的泛型变量，解决“生产者”场景的问题。out?extends逆变允许使用父类型的泛型对象赋值给子类型的泛型变量，解决“消费者”场景的问题。
理解 C# 泛型接口中的协变与逆变（抗变）
sudons的博客
03-06 1259
最近在看《C#高级编程（第九版）》这本书，看到了泛型接口这章。其中关于协变和逆变没太理解，讲得有点坑爹，网上查了许多资料，总算（感觉）弄清楚了，来这里记录一下。
泛型协变 逆变 类型擦除
02-25
### Java 泛型中的协变、逆变及类型擦除 #### 协变 (Covariance) 协变是指当子类对象可以被当作父类对象处理时，在泛型中也遵循这一原则。具体来说，如果 `T` 是 `S` 的子类，则 `List<T>` 可以作为 `List<S>` ...
C#1119记录 类 string.Split type.TryParse(String,out type 变量)
czhc1140075663的博客
11-19 237
文章摘要 这段C#代码实现了一个猜数字游戏，主要功能如下： 程序要求用户输入最小值和最大值（格式如"2,992"） 使用Split()方法分割输入字符串，并验证是否为合法数字 通过TryParse()安全转换数据类型，避免异常 使用Random生成目标数字 循环猜数环节中处理非法输入（非数字字符、格式错误等情况） 通过continue跳过无效输入，确保游戏正常进行 代码展示了字符串处理、类型转换、输入验证和循环控制等核心编程概念。
1.7 C#传递参数给Shader
xxxxxxxx___的博客
11-19 177
【代码】1.7 C#传递参数给Shader。
WinForm+C#小案例---＞猜字母PK游戏
最新发布
MM_MS的博客
11-22 175
实现这个案例我们可以分为2个步骤。
C# 调用php的接口上传附件
kuyz1的专栏
11-19 343
/ ----- 普通参数 exsld=1 -----// ----- 结束 boundary -----// ----- 文件 upload -----// ----- 获取返回 -----
探讨 Java、C# 与 C++ 在现代软件开发中的应用与选择
2501_94114670的博客
11-17 457
本文分析了Java、C#和C++三大主流编程语言的特性与应用场景。Java凭借跨平台能力和丰富的框架，适合企业级开发和大数据应用；C#依托微软生态，在Web、桌面和游戏开发领域表现突出；C++则以高性能和底层控制优势，广泛应用于系统编程和游戏引擎开发。开发者需根据项目需求、团队技能和目标平台选择合适语言：跨平台企业应用选Java，微软技术栈选C#，高性能系统开发则首选C++。合理选择语言是项目成功的重要因素。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值