接口简单问题

Question

一:ilist接口继承了ICollection, IEnumerable两个接口,
而ICollection又继承了IEnumerable,请问为什么ilist接口还要继承以上两个,只继承ICollection为什么不可以呢?
二:array继承了ICollection接口,但是没有写入Count属性,为什么可以呢?
谢谢

Answer 1

而ICollection又继承了IEnumerable
=============
那就是说ICollection实现了IEnumerable接口，但你自己并没有实现。就像你父亲找了份工作，但并不意味你也找了这份工作

Answer 2

我肯定要实现这个IEnumerable接口的功能的,现在是ICollection已经继承了IEnumerable接口的方法了,
我为什么还要继承IEnumerable接口

Answer 3

可能是要类型转换的时候能够支持被IEnumerable指向吧,单独实现ICollection只能通过ICollection指向

Answer 4

我肯定要实现这个IEnumerable接口的功能的,现在是ICollection已经继承了IEnumerable接口的方法了, 
我为什么还要继承IEnumerable接口
========================================换句话说，你父亲上过小学了，你为什么还要上小学？Array实现了Count属性，具体看MSDN。

Answer 5

换句话说，你父亲上过小学了，你为什么还要上小学？ 
~~~~~~~~~`谢谢Avoid的热心,我还想请教,
如果这样说的话那继承还有什么意义啊,继承本身不是拿父辈的东西可以用吗?

Answer 6

IList接口继承ICollection跟继承ICollection,IEnumerable是一样的，并没有区别。
这种情况可能是历史原因造成的，似乎以前.Net哪个版本ICollection是不继承IEnumerable的，可能MS也要考虑ICollection该不该继承IEnumerable吧，而不管怎样让IList继承ICollection,IEnumerable都不会错。

Answer 7

再就是我查过msdn和它的从元数据，没有count啊

Answer 8

拿父辈的东西可以用吗? 
=============
可以这么理解，但是只是拿父类自己的东西，而不是子类的东西。因为父类根本无法知道子类会怎么样。
Class A
{
private string sTest = "Hello";
public int Length()
{
return sTest.Length();
}
}Class B:A
{
private string sTest = "Hi";
}
看上面的代码，虽然子类继承了父类。
也有Length方法，但你能说这个Length是子类sTest的长度？

Answer 9

            int[] myIntArray = new int[5] { 1, 2, 3, 4, 5 };
            int count = ((System.Collections.ICollection)myIntArray).Count;
这个就是实现，ICollection.Count 始终等于 Length。
具体看Array类 所以成员 显式接口实现  

Answer 10

public class 父亲
{
   基因 JY;
   钱   money;
   private 吃饭（）
   {
   }
}public class 儿子 : 父亲
{
  private 吃饭（）
  {}
}儿子可以用父亲的钱，也继承了父亲的基因，但是父亲吃饭了，儿子还是要自己吃滴~

Answer 11

要讨论的是IList接口继承ICollection,IEnumerable跟只继承ICollection的区别……
显式接口实现也不能说明有什么区别

Answer 12

哦，明白了，子类其实一直都调用的父类的东西，这我还研究过，
一用起来咋就不知道了，谢谢，谢谢，那个显示接口我也查到了，
特别感谢Avoid，我再开个贴，问个问题，顺便多给些分

Answer 13

To 千金散尽还复来
你 1 楼说 ICollection 实现了 IEnumerable 接口？接口能实现接口？我还第一次听说。整个一个逻辑混乱。
你以为 ICollection 是个类？实现了 IEnumerable 的成员方法？
这种不经大脑思考的发言不要摆出来误人子弟了。
还父亲儿子的说个没完，难道你父亲长鼻子，你就不长鼻子了？关于多重继承接口的理由：
using System;
//using System.Collections.Generic;namespace ConsoleApplication74
{
    interface IEnumerable
    {
        void GetEnumerator();
    }
    interface ICollection : IEnumerable
    { }
    // 不采用多重继承的写法 interface IList : ICollection
    interface IList : ICollection, IEnumerable
    { }
    // 不采用多重继承的写法 class List : IList
    class List : IList, ICollection, IEnumerable
    {
        // 这里看似只显示实现了类 List 继承的那个 IEnumerable
        // 实际上来自接口 IList 和 ICollection 的 IEnumerable 也被一起实现了
        // 因为同一接口在一个类里的不会出现两种解释
        // 这是接口方法和虚方法的重要区别
        void IEnumerable.GetEnumerator()
        {
                Console.WriteLine("显式实现接口和隐式实现接口效果一样,同一接口在一个类里不会出现歧义");
        }
    }    class Program
    {
        static void Main(string[] args)
        {
            // new List() 生成的对象把继承自各个基接口中的 IEnumerable 都一次性统一的实现了，避免了歧义
            IList a = new List();
            a.GetEnumerator();
            ICollection b = a;
            b.GetEnumerator();
            IEnumerable c = b;
            c.GetEnumerator();            // 这句是关键，可以看出多重继承的好处
            // 试想一下用上面注释掉的两句“不采用多重继承的写法..”
            // 替换下边多重继承写法的语句，会是什么后果？
            // 毫无疑问，CLR 在后台做了很多次类型转换，才完成下边那一句
            // 即 new List() -> IList实例 -> ICollection实例 -> IEnumerable实例 d
            // 采用多重继承写法后，类型转换只有一次：new List() -> IEnumerable实例 d
            IEnumerable d = new List();
            d.GetEnumerator();
        }
    }
}

Answer 14

to ls
CLR 在后台做了很多次类型转换
你能肯定吗？

Answer 15

public interface IList : ICollection, IEnumerable
{
    // Methods
    int Add(object value);
    void Clear();
    bool Contains(object value);
    int IndexOf(object value);
    void Insert(int index, object value);
    void Remove(object value);
    void RemoveAt(int index);    // Properties
    bool IsFixedSize { get; }
    bool IsReadOnly { get; }
    object this[int index] { get; set; }
}一:ilist接口继承了ICollection,   IEnumerable两个接口, 
==================to:
Q_282898034 
看清楚再出来喷粪

Answer 16

千金散尽还复来
发表于：2007-12-25 10:32:23而ICollection又继承了IEnumerable 
============= 
那就是说ICollection实现了IEnumerable接口，但你自己并没有实现。 就像你父亲找了份工作，但并不意味你也找了这份工作
你把继承和实现混为一谈，确实逻辑混乱，我冤枉你了？你提到父亲找了份工作想比喻什么？ICollection继承了IEnumerable接口？那IList就没法实现继承自ICollection的IEnumerable了吗，还并不意味你也找了这份工作。这种水平少出来丢人了

Answer 17

interface IA
{ }
interface IB: IA
{ }
interface IC: IB
{ }class C: IC
{ }千金散尽还复来
你认为父亲 IB 实现了 IA，找到了工作，所以 IC 就找不到 IA 了，儿子找不到工作，非要写成 IC: IB, IA 才行？
 

Answer 18

To 17 楼，我不能确定是否进行了多次类型转换，因为从IL代码里看不出类型转换的操作。但我相信多重继承而来的接口，如果要转换成此接口，一定是一层一层地转换过去的，因为类声明的时候没有直接继承。

Answer 19

不知道 是否如Q_282898034 所说的
 // 即 new List() -> IList实例 -> ICollection实例 -> IEnumerable实例 d
            // 采用多重继承写法后，类型转换只有一次：new List() -> IEnumerable实例 d但如果IList接口只继承了ICollection时,同样也达到同样的效果