C#框架阅读笔记--类和接口的继承

类和接口的继承
Framwork类库中几个接口的定义如下：

    public interface IDisposiable
    {
        void Dispose();
    }
    
    public interface IEnumerable
    {
        IEnumerator GetEnumerator();
    }
    
    public interface IEnumerable<T> : IEnumerable
    {
        IEnumerator<T> GetEnumerator();
    }
    
    public interface ICollection<T> : IEnumerable<T>, IEnumerable
    {
        void Add(T item);
        void Clear();
        Boolean Contains(T item);
        void Copyto(T[] array, Int32 arrayIndex);
        Boolean Remove(T item);
        Int32 Count
        {
            get;
        }
        
        Boolean IsReadOnly
        {
            get;
        }
    }
    
接口的继承：

System.IComparable<T>接口的定义如下：

    public interface IComparable<T>
    {
        Int32 CompareTo(T other);
    }

以下代码展示了如何定一个实现了该接口的类型，同时还展示了对两个point对象进行比较的代码：

    using System;
    
    //Point 继承自System.Object 并实现Point的IComparable<T>
    public sealed class Point : IComparable<Point>
    {
        private Int32 m_x;
        private Int32 m_y;
        
        public Point(Int32 x, Int32 y)
        {
            m_x = x;
            m_y = y;
        }
        
        //该方法实现了Point的IComparable<T>
        public Int32 compareTo(Point other)
        {
            return Math.Sign(Math.Sqrt(m_x * m_x + m_y * m_y) - Math.Sqrt(other.m_x * other.m_x + other.m_y * other.m_y));
        }
        
        public  override String ToString()
        {
            return String.Format("({0}, {1})", m_x, m_y);
        }
    }
        
    public static class Program
    {
        public static void Main()
        {
            Point[] points = new Point[] {new Point(3, 3), new Point(1, 2)};
            
            //下面是对Point的IComparable<T> CompareTo方法的调用
            if(points[0].CompareTo(points[1]) > 0)
            {
                Point tempPoint = points[0];
                points[0] = points[1];
                points[1] = tempPoint;
            }
            
            Console.WriteLine("Points from closest to (0,0) farther");
            foreach(Point p in points)
            {
                Console.WriteLine(p);
            }
        }
    }
    
    C#编译器要求将实现了接口的方法标记为public。CLR要求将接口方法标记为virtual.如果不在源代码中将接口方法显示标记为virtual,
编译器会把它们标记为virtual和sealed,这会阻止派生类重写接口方法。如果将方法显示标记为virtual,编译器会把方法标记为virtual(保留为unsealed),
这样一来，派生类就可以重写接口方法。

    如果接口方法为sealed, 派生类就不能重写这个方法。不过，派生类可以重新继承同一个接口，
并可以为该接口的方法提供自己的实现。在一个对象上调用一个接口的方法时，将调用与这个对象的类型关联的实现。
例子：

    using System;
    
    public  static class Program
    {
    
        public static  void Mina()
        {
            //第一个例子
            Base b = new Base();
            
            //用b的类型来调用Dispose:"Base's Dispose"
            ((IDisposable)b).Dispose();
            
            //第二个例子
            Derived d = new Derived();
            
            //对d的类型来调用Dispose:"Derived's Dispose"
            d.Dispose();
            
            //用d的对象类型来调用Dispose:"Derived's Dispose"
            ((IDisposable)d).Dispose();
            
            //第三个例子
            b = new Derived();
            
            //用b的类型来调用Dispose:"Base's Dispose"
            b.Dispose();
            
            //用b的对象的类型来调用Dispose:"Derived Dispose"
            ((IDisposable)b).Dispose();
        }
    }
    
    //这个类派生自Object,而且它实现了IDisposable接口
    internal class Base : IDisposable
    {
        //这个方法隐式标记为sealed, 不能被重写
        public void Dispose()
        {
            Console.WriteLine("Base's Dispose");
        }
    }
    
    //这个类派生自Base，而且他重新实现了IDisposable
    
    internal class Derived : Base, IDisposable
    {
        //这个方法不能从写Base 的 Dispose方法
        //'new' 用于表明该方法重新实现了IDisposable的Dispose方法
        new public void Dispose()
        {
            Console.WriteLine("Derived's dispose");
            
            //注意，下面这行代码展示了如何调用一个基类的实现（如果需要的话）
            //Base.Dispose();
        }
    }