为什么泛型 IList<> 不继承非泛型 IList

Question

IList<T> 不继承 IList，其中 IEnumerable<out T> 继承 IEnumerable。

如果out 修饰符是唯一的原因，那么为什么大多数IList<T> 的实现（例如Collection<T>、List<T>）都实现了IList 接口。

所以任何人都可以说好的，如果该陈述对于IList<T> 的所有实现都是正确的，那么在必要时直接将其转换为IList。但问题是虽然IList<T> 不继承IList 所以不能保证每个IList<T> 对象都是IList。

此外，使用IList<object> 显然不是解决方案，因为没有out 修饰符，泛型不能分配给继承较少的类；并且在这里创建 List 的新实例不是解决方案，因为有人可能希望将 IList<T> 的实际引用作为 IList 指针；并使用 List<T> 而不是 IList<T> 实际上是一种糟糕的编程习惯，并不能满足所有目的。

如果 .NET 想要提供灵活性，IList<T> 的每个实现都不应该有非泛型实现的合同（即IList），那么为什么他们不保留另一个实现泛型和非泛型的接口版本，并没有建议所有想要为通用和非遗传项目收缩的具体类都应该通过该接口收缩。

将ICollection<T> 转换为ICollection 和IDictionary<TKey, TValue> 转换为IDictionary 也会出现同样的问题。

Answer 1

如您所见，IList<T> 中的T 不是协变的。根据经验：任何可以修改其状态的类都不能是协变的。原因是此类类通常具有将T 作为其参数之一的类型的方法，例如void Add(T element)。 input 位置中不允许使用协变类型参数。

除了其他原因外，还添加了泛型以提供类型安全。例如，您不能将Elephant 添加到Apple 的列表中。如果ICollection<T> 扩展ICollection，那么您可以调用((ICollection)myApples).Add(someElephant) 而不会出现编译时错误，因为ICollection 有一个方法void Add(object obj)，它似乎允许您添加any对象到列表中，而实际上您只能添加 T 的对象。因此，ICollection<T> 不扩展 ICollection 和 IList<T> 不扩展 IList。

Anders Hejlsberg，C# 的创造者之一，explains it like this：

理想情况下，所有泛型集合接口（例如ICollection<T>、IList<T>）都将从它们的非泛型对应物继承，这样泛型接口实例既可以用于泛型代码也可以用于非泛型代码。

事实证明，唯一可行的通用接口是IEnumerable<T>，因为只有IEnumerable<T> 是反变体[sic¹]：在IEnumerable<T> 中，类型参数T 仅用于“输出”位置（返回值），而不用于“输入”位置（参数）。 ICollection<T> 和 IList<T> 在输入和输出位置都使用 T，因此这些接口是不变的。

¹) IEnumerable<T> 是co-变体

---

从 .Net 4.5 开始，就有了 IReadOnlyCollection<out T> 和 IReadOnlyList<out T> 协变接口。但是IList<T>、ICollection<T> 以及许多列表和集合类都没有实现或扩展它们。坦率地说，我发现它们不是很有用，因为它们只定义了 Count 和 this[int index]。

---

如果我可以从头开始重新设计 .Net 4.5，我会将列表接口拆分为只读协变接口IList<out T>，其中包括Contains 和IndexOf，以及一个可变不变接口IMutableList<T> .然后你可以将IList<Apple> 转换为IList<object>。我在这里实现了这个：

M42 Collections - 协变集合、列表和数组。

Answer 2

请注意，自 2012 年以来，在 .NET 4.5 及更高版本中，存在一个协变（out 修饰符）接口，

public interface IReadOnlyList<out T>

见its documentation。

List<YourClass>、Collection<YourClass> 和 YourClass[] 等通常的集合类型确实实现了 IReadOnlyList<YourClass>，并且由于协方差也可以用作 IReadOnlyList<SomeBaseClass> 并最终用作 IReadOnlyList<object>。

如您所料，您将无法通过IReadOnlyList<> 参考修改您的列表。

使用这个新界面，您也许可以同时避免非泛型IList。但是你仍然会遇到IReadOnlyList<T> 不是IList<T> 的基本接口的问题。

Answer 3

创建一个接口MyIList<T>，让它继承自IList<T>和IList：

public interface MyIList<T> : IList<T>, IList
{ }

现在创建一个类MySimpleList并让它实现MyIList<T>：

public class MySimpleList<T> : MyIList<T>
{
    public int Count
    {
        get { throw new NotImplementedException(); }
    }

    public bool IsFixedSize
    {
        get { throw new NotImplementedException(); }
    }

    public bool IsReadOnly
    {
        get { throw new NotImplementedException(); }
    }

    public bool IsSynchronized
    {
        get { throw new NotImplementedException(); }
    }

    public object SyncRoot
    {
        get { throw new NotImplementedException(); }
    }

    object IList.this[int index]
    {
        get
        {
            throw new NotImplementedException();
        }
        set
        {
            throw new NotImplementedException();
        }
    }

    public T this[int index]
    {
        get
        {
            throw new NotImplementedException();
        }
        set
        {
            throw new NotImplementedException();
        }
    }

    public void Add(T item)
    {
        throw new NotImplementedException();
    }

    public int Add(object value)
    {
        throw new NotImplementedException();
    }

    public void Clear()
    {
        throw new NotImplementedException();
    }

    public bool Contains(T item)
    {
        throw new NotImplementedException();
    }

    public bool Contains(object value)
    {
        throw new NotImplementedException();
    }

    public void CopyTo(T[] array, int arrayIndex)
    {
        throw new NotImplementedException();
    }

    public void CopyTo(Array array, int index)
    {
        throw new NotImplementedException();
    }

    public IEnumerator<T> GetEnumerator()
    {
        throw new NotImplementedException();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        throw new NotImplementedException();
    }

    public int IndexOf(T item)
    {
        throw new NotImplementedException();
    }

    public int IndexOf(object value)
    {
        throw new NotImplementedException();
    }

    public void Insert(int index, T item)
    {
        throw new NotImplementedException();
    }

    public void Insert(int index, object value)
    {
        throw new NotImplementedException();
    }

    public bool Remove(T item)
    {
        throw new NotImplementedException();
    }

    public void Remove(object value)
    {
        throw new NotImplementedException();
    }

    public void RemoveAt(int index)
    {
        throw new NotImplementedException();
    }
}

你现在可以很容易地看到，你必须双重实现一堆方法。一种用于类型 T，一种用于对象。在正常情况下，您希望避免这种情况。这是一个协方差和逆变的问题。

您能找到的最佳解释（对于 IList 和 IList 的这个具体问题，Jon 在问题的 cmets 中已经提到了 article from Brad。

Answer 4

已经给出了很好的答案。 不过关于 IList 的通知：

MSDN IList Remarks: “IList 实现分为三类：只读、固定大小和可变大小。（...）。有关此接口的通用版本，请参阅 System.Collections.Generic.IList<T>。”

这有点误导，因为在通用方面，我们将 IList<T> 设置为 variable-size，并将 IReadOnlyList<T> 从 4.5 开始设置为只读，但 AFAIK 没有固定大小的通用列表。