Java Socket RPC协议(Java Socket RPC protocol)

 让我们首先回答您的具体问题： 
 
 
 
 为什么我们需要一个IList<T>接口 
 
 
 它是唯一提供可变索引访问的接口 - List<T>和T[]契约 - 因此它们可以作为参数互换地传递给需要这种契约的函数。 
 
 更不用说，当你想推出自己的实现时。 例如，我想将一个File公开为IList<char> - 它可能不是最好的主意，但你得到了漂移。 
 
 我同意IList<T>是一个糟糕的接口选择，因为添加和删除元素不是数组自然支持的。 
 
 现在来看大局：你可能会忽略这一点，因为这是非常主观的 
 
 .NET框架在其集合接口方面做得很差。 它们不仅不在一个命名空间中，而且随着时间的推移而发展 - 这意味着有很多代码（包括在BCL中），它们在编写时使用“最佳”可用接口，这可能是从今天开始是一个糟糕的选择。 
 
 我相信他们应该从下面的接口开始 - 也许有更好的名字:) 
 
interface IEnumerable<T> {
    // just like we currently have
}

// currently called IReadOnlyCollection<T>
interface ICollection<T> : IEnumerable<T> {
    int Count { get; }
}

// currently called as IReadOnlyList<T>
interface IIndexedCollection<T> : ICollection<T> {
    T this[int index] { get; }
}

// currently called as ICollection<T>, but doesn't inherit from IReadOnlyCollection
interface IMutableCollection<T> : ICollection<T> {
    void Add(T item);
    bool Remove(T item);
    void Clear();
}

// We don't have this at all - OP's case
interface IArray<T> : IIndexedCollection<T> {
    T this[int index] { get; set; }
}

// currently exists as IList<T>, but inheritance is very different
interface IList<T> : IArray<T>, IMutableCollection<T> {
    void Insert(int index, T item);
    void RemoveAt(int index);
}

Let's start by answering your specific question:
 
 
 
Why do we need a IList<T> interface
 
 
It is the only interface that provides mutable indexed access - contract for List<T> and T[] - so they can be interchangeably passed as an argument to functions that need such a contract.
 
Not to mention, when you want to roll your own implementation. For example, I want to expose a File as an IList<char> - it might not be the best idea, but you get the drift.
 
I agree that IList<T> is a poor choice of interface, since adding and removing an element is not what an array naturally supports.
 
Now to the bigger picture: You may ignore this as this is very subjective
 
.NET framework has done a poor job with its collection interfaces. Not only they are not in a single namespace, but they have evolved over time - which means there is a lot of code out there (including in the BCL) which use the "best" available interface as of when it was written, which might be a bad choice as of today.
 
I believe they should have started with interfaces like below - perhaps with better names :)
 
interface IEnumerable<T> {
    // just like we currently have
}

// currently called IReadOnlyCollection<T>
interface ICollection<T> : IEnumerable<T> {
    int Count { get; }
}

// currently called as IReadOnlyList<T>
interface IIndexedCollection<T> : ICollection<T> {
    T this[int index] { get; }
}

// currently called as ICollection<T>, but doesn't inherit from IReadOnlyCollection
interface IMutableCollection<T> : ICollection<T> {
    void Add(T item);
    bool Remove(T item);
    void Clear();
}

// We don't have this at all - OP's case
interface IArray<T> : IIndexedCollection<T> {
    T this[int index] { get; set; }
}

// currently exists as IList<T>, but inheritance is very different
interface IList<T> : IArray<T>, IMutableCollection<T> {
    void Insert(int index, T item);
    void RemoveAt(int index);
}