C# 中为什么List<List<T>> 不能转换为 IList<IList<T>> ?

我们来聊聊 C 中 `List>` 和 `IList>` 之间的转换问题。这并不是一个简单的“类型兼容”的直接问题，而是涉及到 C 类型系统中的一个重要概念：协变性和逆变性。

理解这个问题，我们需要先明确几个基础：

1. `List` 的性质： `List` 是一个具体的类，它实现了 `IList` 接口。这意味着 `List` 具备 `IList` 定义的所有方法和属性，并且它是一个具体的可变集合。你可以往里面添加、删除、修改元素。

2. `IList` 的性质： `IList` 是一个接口。它定义了一组操作，描述了一个“索引列表”的契约。任何实现了这个契约的类型都可以被看作 `IList`。但重要的是，`IList` 本身并没有规定元素的类型。例如，`List` 是 `IList`，`ArrayList`（在某些情况下）也可以被视为 `IList`，但 `ArrayList` 存放的是 `object`。

3. 泛型类型参数的协变性与逆变性：
协变性 (Covariance) 允许你使用比实际类型更“宽泛”的类型。简单来说，如果 A 可以转换为 B，那么对于一个泛型类型 `Generic`，它也可以被视为 `Generic`（前提是 B 是 A 的基类或接口）。
逆变性 (Contravariance) 允许你使用比实际类型更“狭窄”的类型。如果 A 可以转换为 B，那么对于一个泛型类型 `Generic`，它也可以被视为 `Generic`（前提是 B 是 A 的基类或接口）。

现在，让我们回到 `List>` 和 `IList>`：

我们想将 `List>` 赋值给 `IList>` 变量。这里的关键在于内层的 `List` 和 `IList`。

假设我们有一个 `List>`。我们想把它赋值给一个 `IList>` 类型的变量。

外层： `List>` 的外层类型是 `List`，目标是 `IList`。`List` 实现了 `IList`，所以 `List` 可以被视为 `IList`。这层没问题。

内层： 问题出在泛型类型参数。
`List>` 的内层类型参数是 `List`。
`IList>` 的内层类型参数是 `IList`。

现在，我们来思考 `List` 和 `IList` 之间的关系。

`List` 是 `IList` 的一个具体实现。 这意味着，任何 `List` 对象都拥有 `IList` 所需的所有功能。

为什么 C 不允许 `List>` 直接转换为 `IList>`？

答案在于 类型安全 和 泛型参数的协变/逆变限制。

1. 泛型类型的协变性是针对“输出”位置的 (out T)：
C 的泛型协变性（允许子类型用作基类型）通常是为标记为 `out` 的类型参数设计的。`out` 参数表示该泛型类型仅用于产生值（输出），而不用于接受值（输入）。
例如，`IEnumerable` 是协变的。你可以将 `IEnumerable>` 赋值给 `IEnumerable>`，因为 `IEnumerable` 只允许你遍历（`GetEnumerator`），这是一种输出操作。

2. `List` 是一个“输入/输出”位置的泛型 (in/out T)：
`List` 允许你读取 (`T Item`) 和修改 (`set Item(T value)`) 元素，还允许你添加 (`Add(T item)`) 和删除 (`Remove(T item)`) 元素。这意味着 `T` 在 `List` 中既是输出位置（读取），也是输入位置（添加、设置）。

3. `IList` 同样是“输入/输出”位置的泛型：
`IList` 接口定义了索引器 (`T this[int index] { get; set; }`)，这意味着 `T` 同样是输入和输出位置。

关键点：

当你想将 `List>` 赋值给 `IList>` 时，编译器看到的不是“`List` 可以被视为 `IList`”，而是“`List>` 这个泛型类型，它的类型参数 `List`，能不能被强制转换为 `IList`？”

如果 C 允许这种转换，会发生什么？

想象一下，你有一个 `List>`。它的内层元素都是 `List`。
现在，你把它强制转换为 `IList>`。
理论上，你可以通过这个 `IList>` 接口，尝试将一个 `IList`（比如一个 `ArrayList` 里的 `int` 列表，或者其他任何实现了 `IList` 但可能不是 `List` 的东西）赋值给内层的元素。

示例场景（为了说明风险）：

假设我们有一个 `List>` 叫做 `outerList`。
`outerList` 里面有一个 `List` 叫做 `innerList1`。

如果我们强行把 `outerList` cast 成 `IList>`：

```csharp
List> listOfLists = new List>();
listOfLists.Add(new List() { 1, 2 });
listOfLists.Add(new List() { 3, 4 });

// 假设 C 允许这种转换 (虽然它不允许)
// IList> iListOfIList = listOfLists; // 编译错误

// 如果我们通过 unsafe cast，就可能遇到运行时问题
// IList> iListOfIList = (IList>)listOfLists; // 仍然会因为类型不匹配抛出 InvalidCastException

// 考虑一个更危险的场景，如果我们有一个更底层的类型
// 比如我们有个旧的、不安全的 List

网友意见

因为IList<T>的泛型参数T是invariant的，而不是题主所期待的covariant（或者说IList<out T>）：

       public interface IList<T> : ICollection<T>, IEnumerable<T>, IEnumerable      

从 List<List<T>> 转成 IList<List<T>> 是完全没问题的，因为这个转换从泛型参数的角度看是invariant的。然而进一步转成 IList<IList<T>> 就不行了，因为把泛型参数中（内层）的 List<T> 转成 IList<T> 需要covariant。

传送门：

Covariance and Contravariance in Generics

具体到题主的例子，其实这样就好了：

       using System.Collections.Generic; using System.Linq;  class Record {   public List<Record> Data {     get { return null; }   } }  class Program {   static void Main(string[] args) {     var records = new List<Record>();     var casted1 = (IList<IList<Record>>)records.Select(r => r.Data as IList<Record>).ToList(); // ok     Console.WriteLine("cast1 succeeded.");     var casted2 = (IList<IList<Record>>)records.Select(r => r.Data).ToList<IList<Record>>(); // ok     Console.WriteLine("cast2 succeeded.");     var casted3 = (IList<IList<Record>>)records.Select(r => r.Data).ToList(); // fail     Console.WriteLine("cast3 succeeded.");   } }      

这是因为我的例子中，ToList()其实是个泛型方法，其泛型参数通常是被自动推导出来的；Record.Data的类型是List<Record>，于是用在那个ToList()调用时推导出来的就是ToList<List<Record>>。我们要么在Select()的时候就as一下来让Select推导出来的类型改变，要么直接在ToList()的地方指定清楚泛型参数，就好啦。

类似的话题

• 

  C# 中为什么List<List<T>> 不能转换为 IList<IList<T>> ?

  

  我们来聊聊 C 中 `List>` 和 `IList>` 之间的转换问题。这并不是一个简单的“类型兼容”的直接问题，而是涉及到 C 类型系统中的一个重要概念：协变性和逆变性。理解这个问题，我们需要先明确几个基础：1. `List` 的性质： `List` 是一个具体的类，它实现了 `IList` .............
• 

  c++中 为什么数组不能被vector完全替代?

  

  这真是个好问题，而且触及到了C++中一些非常基础但又很重要的概念。虽然 `std::vector` 在现代C++编程中确实非常强大且常用，但说它能“完全”替代C风格的数组，那是绝对不行的。原因嘛，要说详细，得从几个关键点上掰扯掰扯。首先，我们要明白，C++中的数组，尤其是C风格数组，是语言层面的一个.............
• 

  c#中为什么async方法里必须还要有await？

  

  在 C 中，`async` 和 `await` 是紧密相连的，就像一对默契的舞伴，共同 orchestrate 异步操作。你问为什么 `async` 方法里“必须”还要有 `await`，这其实触及到了 `async` 方法本质的设计理念。我们先要理解，`async` 关键字本身并没有让方法变成异步.............
• 

  在C++中，为什么部分程序员喜欢在循环中写‘++i’而不是‘i++’？

  

  一些C++程序员在循环中偏爱使用前缀自增运算符`++i`，而不是后缀自增运算符`i++`，这背后并非简单的个人喜好，而是基于一些实际的考量和性能上的微妙区别。虽然在现代编译器优化下，这种区别在很多情况下几乎可以忽略不计，但理解其根源有助于我们更深入地理解C++的运算符机制。要详细解释这个问题，我们需.............
• 

  C语言和C++中，为什么malloc函数需要传入申请的内存大小，而free时候却不需要传大小呢？

  

  好的，我来详细解释一下 C 和 C++ 中 `malloc` 和 `free` 函数的设计理念，以及为什么一个需要大小，一个不需要。想象一下，你需要在一个储物空间里存放物品。`malloc`：告诉空间管理员你要多大的箱子当你调用 `malloc(size_t size)` 时，你就是在对内存的“管理.............
• 

  c中struct 为什么可以在数据结构这样用？

  

  在C语言中，`struct`（结构体）之所以能成为构建复杂数据结构的基石，在于它提供了将不同类型的数据成员组合成一个单一逻辑单元的能力。这就像我们在现实生活中将不同零散的物品（姓名、年龄、学号等）打包成一个“学生”的概念一样。让我们一层层剥开，看看`struct`是如何做到这一点的，以及它在数据结构.............
• 

  C语言中，为什么(int) ((100.1 - 100) * 10) = 0？

  

  关于你提到的 `(int) ((100.1 100) 10)` 在 C 语言中结果为 0 的问题，这确实是一个很有意思的陷阱，它涉及到浮点数运算的精度以及类型转换的细节。我们来一步一步地把它掰开了揉碎了讲明白。首先，让我们分解一下这个表达式：`100.1 100` 是第一步，然后乘以 `10`.............
• 

  C语言中，为什么指向指针的指针的类型是int **？类型的话直接int*不就行了？

  

  好的，我们来深入探讨一下 C 语言中为什么需要 `int `（指向指针的指针）而不是直接用 `int ` 来表示，以及这里的类型系统是如何工作的。首先，我们得明白什么是“类型”在 C 语言中的作用。在 C 语言中，类型不仅仅是一个标签，它承载着至关重要的信息，指导着编译器如何理解和操作内存中的数据：.............
• 

  C/C++中的数组为什么必须定义之后在一行内立刻赋值，而不能定义数组之后换一行再赋值?

  

  在C/C++中，关于数组的定义与赋值，确实存在一个常见的误解，认为“必须在定义后立即在一行内完成赋值”。这其实是一种简化的说法，更准确地理解是：C/C++中的数组初始化，如果要在定义时进行，必须写在同一条声明语句中；而如果要在定义之后进行赋值，则需要分步操作，并且不能使用初始化列表的方式。让我们一步.............
• 

  为什么c++中要分为heap（堆）和stack（栈）?

  

  C++ 中将内存划分为 堆（Heap） 和 栈（Stack） 是计算机科学中一个非常重要的概念，它关乎程序的内存管理、变量的生命周期、性能以及程序的灵活性。理解这两者的区别对于编写高效、健壮的 C++ 程序至关重要。下面我将详细阐述为什么需要将内存划分为堆和栈： 核心原因：不同的内存管理需求和生命周.............
• 

  为什么C++中，含有函数声明的头文件应该被包含在定义函数的源文件中？

  

  在C++开发中，我们习惯将函数的声明放在头文件里，而函数的定义放在源文件里。而对于一个包含函数声明的头文件，将其包含在定义该函数的源文件（也就是实现文件）中，这似乎有点多此一举。但实际上，这么做是出于非常重要的考虑，它不仅有助于代码的清晰和组织，更能避免不少潜在的麻烦。咱们先从根本上说起。C++的编.............
• 

  为什么C++中virtual要翻译为虚函数？

  

  在C++的世界里，“virtual”这个词被翻译成“虚函数”，这可不是随意为之，而是因为它精确地抓住了这种函数在继承和多态机制中的核心特征。理解“虚”这个字的关键，在于它暗示了一种“不确定性”，或者说是一种“在运行时才确定”的行为。设想一下，你有一系列动物，比如猫、狗，它们都属于一个更大的“动物”类.............
• 

  为什么 C++ 中一个类的成员类型不能是该类本身，而 C# 中就可以?

  

  这个问题很有意思，涉及到 C++ 和 C 在类型定义和内存模型上的根本性差异。简单来说，C++ 的限制是为了保证类型的大小在编译时是确定的，而 C 的灵活性则来自于它对引用类型的处理方式。我们先从 C++ 的角度来看。在 C++ 中，当你定义一个类时，编译器需要知道这个类在内存中占据多大的空间。这个.............
• 

  c++ 中明明有vector了为什么还要有stack？

  

  vector 和 stack 在 C++ 中都有各自的用处，它们虽然都属于序列容器，但设计目标和侧重点不同。可以这么理解：vector 就像一个可以随意伸缩的储物空间，你可以按照任何顺序往里面放东西，也可以随时拿出任何一个东西。而 stack 就像一个堆叠的盘子，你只能在最上面放盘子，也只能从最上面.............
• 

  c++ 中 结构体中的变量读写速度为什么比普通变量快?

  

  结构体变量的读写速度 并不比普通变量快。这是一个常见的误解。事实上，在很多情况下，访问结构体成员的开销会比直接访问普通变量稍微 大一些，而不是更小。要详细解释这一点，我们需要深入理解 C++ 中的变量、内存模型以及编译器的工作方式。 1. 普通变量的读写首先，我们来看看一个简单的普通变量，例如：``.............
• 

  C#中字符串可以使用可变大小的内存，为什么数字不能？

  

  在C中，字符串之所以能够表现出“可变大小”的内存使用方式，而我们常说的数字类型（比如 `int`, `double` 等）则表现为固定大小，这背后是两者在内存中的根本存储机制和设计哲学上的差异。首先，我们得明确“可变大小”和“固定大小”在C中的具体含义。C 中的字符串：C 中的 `string` 类.............
• 

  C/C++中，设计的时候字符/字符串为什么要加引号？

  

  为何C/C++中字符和字符串要用引号包裹？在C/C++的世界里，我们经常会看到单引号 `' '` 包裹着一个字符，双引号 `""` 包裹着一串字符（也就是字符串）。这不仅仅是语言的规定，背后有着深刻的设计哲学和实际考量。今天我们就来好好掰扯掰扯，为啥它们需要这些“外衣”。 先聊聊字符（char）和它.............
• 

  C++ 中 new 和定位 new 的返回值都是 void*，却为什么可以被赋值给不同类型的指针？

  

  在 C++ 中，`new` 和定位 `new` 操作符的返回值都是 `void`，这确实是它们能够被赋值给不同类型指针的关键。要理解这一点，我们需要深入 C++ 的内存管理和类型转换机制。 `new` 操作符：动态内存分配的通用接口首先，我们来看看 `new` 操作符。它的核心作用是在堆（heap）.............
• 

  为什么C/C++中“(*p).number”和“p->number”作用一样但却有两种写法？

  

  在C/C++的世界里，指针和结构体（或类）的组合使用是再常见不过的了。当你有一个指向结构体或类的指针，想要访问其中的成员时，你会发现有两种方式可以做到：`(p).member` 和 `p>member`。很多人会疑惑，既然它们的作用完全一样，为什么语言设计者要提供两种写法呢？这背后其实有其历史原因和.............
• 

  E-NCAP和C-NCAP等碰撞测试中为什么同时存在40%和100%碰撞？

  

  在汽车安全碰撞测试中，同时存在40%和100%碰撞并非偶然，而是为了更全面、更深入地评估车辆在不同冲击场景下的安全性能。这两种碰撞形式，以及它们各自的测试方式和评分侧重点，共同构成了对车辆安全性的严谨考察。1. 100%正面碰撞：模拟最直接、最严酷的正面冲击 测试目的： 100%正面碰撞，顾名思.............