笔记：CLR var C# 第13章

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ClrVarCSharp.C13Interface
{
    class Program
    {
        public static void Main(string[] args)
        {
            //Test1();
            //Test2();
            //Test3();
            //Test4();
            //Test5();
            //Test6();
            //A.Test7();
            //B.Test7();
            //B.Test8();
            //Test9();
            //C.Test10();
            //D.Test10();
            //E.Test10();
        }

        //接口：
        //对一组方法签名进行了统一命名
        //定义了在类型之间进行沟通的标准方式

        //13.3 接口定义和实现
        //定义接口（该定义已包含在FCL中）
        //public interface IComparable<in T>  // in 逆变量，即允许 object -> string
        //{
        //    int CompareTo(T other);
        //}

        //实现接口
        public sealed class Point : IComparable<Point>
        {
            private int m_x, m_y;
            public Point(int x, int y)
            {
                m_x = x;
                m_y = y;
            }
            //1). 必须标记为public
            //2). 编译器总是将其标记为virtual，但派生类不能重写sealed类的接口方法
            //3). 但派生类可以重写继承同一接口，并为接口方法提供自己的实现
            //IL代码：.method public final hidebysig newslot virtual
            public int 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));
            }
        }

        //13.5 显示/隐式实现接口

        internal sealed class SimpleType : IDisposable
        {
            //隐式实现接口
            public void Dispose()
            {
                Console.WriteLine("Public Dispose");
            }
            //显示实现接口，不能定义访问修饰符，总是private
            //IL代码：.method private final hidebysig newslot virtual
            void IDisposable.Dispose()
            {
                Console.WriteLine("IDisposable Dispose");
            }
        }
        static void Test1()
        {
            SimpleType st = new SimpleType();
            st.Dispose();
            IDisposable d = st;
            d.Dispose();  //若为显示实现接口，结果为 Public Dispose
        }

        //13.6 泛型接口

        //非泛型接口
        static void Test2()
        {
            int x = 1, y = 2;
            IComparable c = x;
            c.CompareTo(y);  //发生装箱
            //c.CompareTo("2");  //运行时异常
        }
        //泛型接口
        static void Test3()
        {
            int x = 1, y = 2;
            IComparable<int> c = x;
            c.CompareTo(y);  //不发生装箱
            //c.CompareTo("2");  //编译错误
        }

        //实现同一个接口的多个泛型版本
        public sealed class Number : IComparable<int>, IComparable<string>
        {
            private int m_val = 5;
            public int CompareTo(int other)
            {
                return m_val.CompareTo(other);
            }
            public int CompareTo(string other)
            {
                return m_val.CompareTo(other);
            }
        }

        //13.7 约束方法的参数类型为实现指定接口的类型
        static void Test4()
        {
            int x = 5;
            Guid g = new Guid();
            M(x);  //int 同时实现了 IComparable 和 IConvertible
            //M(g);  //编译错误，guid没有实现IConvertible
        }
        static int M<T>(T t) where T : IComparable, IConvertible
        {
            return 0;
        }

        //13.8 一个类实现不同接口的重签名方法
        //1). 定义接口
        public interface IWindow
        {
            object GetMenu();
        }
        public interface IRestaurant
        {
            object GetMenu();
        }
        //2). 隐式实现接口
        public sealed class MarioPizzeria : IWindow, IRestaurant
        {
            public object GetMenu()   //书中“必须使用显式接口方法实现”说法是错误的，可同时实现两个接口！
            {
                Console.WriteLine("0");
                return "0";
            }
        }
        static void Test5()
        {
            MarioPizzeria mp = new MarioPizzeria();
            mp.GetMenu();
            IWindow window = mp;
            window.GetMenu();
            IRestaurant restaurant = mp;
            restaurant.GetMenu();
        }
        //3). 显式实现接口
        public sealed class MarioPizzeria2 : IWindow, IRestaurant
        {
            public object GetMenu()
            {
                Console.WriteLine("0");
                return "0";
            }
            object IWindow.GetMenu()
            {
                Console.WriteLine("1");
                return "1";
            }
            object IRestaurant.GetMenu()
            {
                Console.WriteLine("2");
                return "2";
            }
        }
        static void Test6()
        {
            MarioPizzeria2 mp = new MarioPizzeria2();
            mp.GetMenu();   //GetMenu()只是该类的一个普通方法，若未实现则出现编译错误
            IWindow window = mp;
            window.GetMenu();
            IRestaurant restaurant = mp;
            restaurant.GetMenu();
        }

        //13.9 用显式接口方法实现来增强编译时类型安全
        //原理是显式实现接口只能“显式”调用
        //1). 隐式实现接口可能发生装箱和运行时异常
        class A
        {
            public interface IComparable1
            {
                int CompareTo(object other);
            }
            struct SomeValueType : IComparable1
            {
                private int m_x;
                public SomeValueType(int x) { m_x = x; }
                public int CompareTo(object other)
                {
                    return m_x - ((SomeValueType)other).m_x;
                }
            }
            public static void Test7()
            {
                SomeValueType v = new SomeValueType(0);
                object o = new object();
                int n = v.CompareTo(v);   //装箱 SomeValueType -> Object
                //n = v.CompareTo(o);  //运行时异常
            }
        }
        //2). 显式实现接口不发生装箱和编译时类型安全
        class B
        {
            public interface IComparable1
            {
                int CompareTo(object other);
            }
            struct SomeValueType : IComparable1
            {
                private int m_x;
                public SomeValueType(int x) { m_x = x; }
                public int CompareTo(SomeValueType other)
                {
                    return m_x - other.m_x;
                }
                int IComparable1.CompareTo(object other)
                {
                    return CompareTo((SomeValueType)other);
                }
            }
            public static void Test7()
            {
                SomeValueType v = new SomeValueType(0);
                object o = new object();
                int n = v.CompareTo(v);   //不发生装箱
                //n = v.CompareTo(o);  //编译错误，因为显式接口只能显式调用
            }
            //3). 重新发生装箱和运行时异常
            public static void Test8()
            {
                SomeValueType v = new SomeValueType(0);
                IComparable1 c = v;  //装箱 struct -> 引用类型
                object o = new object();
                int n = c.CompareTo(v);  //装箱 引用类型 -> object
                //n = c.CompareTo(o);  //编译异常
            }
        }

        //13.10 显式实现接口缺陷
        public static void Test9()
        {
            int x = 5;
            //1). In32显式实现了IConvertible接口，但此处没有相关帮助
            //Single s = x.ToSingle(null);
            //2). Int32值型转换为IConvertible发生装箱
            Single s = ((IConvertible)x).ToSingle(null);
        }
        class C
        {
            public static void Test10()
            {
                var d1 = new Derived();
                var d2 = new Derived();
                d1.CompareTo(d2);
            }
            internal class Base : IComparable
            {
                int IComparable.CompareTo(object obj)
                {
                    Console.WriteLine("Base's CompareTo");
                    return 0;
                }
            }
            internal sealed class Derived : Base, IComparable
            {
                public int CompareTo(object o)
                {
                    Console.WriteLine("Derived's CompareTo");

                    //没有CompareTo方法
                    //base.CompareTo(o);

                    //IComparable c = this;  //this实现了IComparable接口
                    //c.CompareTo(o);  //所以此处在调用自身导致无穷递归

                    return 0;
                }
            }
        }
        class D
        {
            public static void Test10()
            {
                var d1 = new Derived();
                var d2 = new Derived();
                d1.CompareTo(d2);
            }
            internal class Base : IComparable
            {
                int IComparable.CompareTo(object obj)
                {
                    Console.WriteLine("Base's CompareTo");
                    return 0;
                }
            }
            internal sealed class Derived : Base/*, IComparable*/
            {
                public int CompareTo(object o)
                {
                    Console.WriteLine("Derived's CompareTo");

                    //没有CompareTo方法
                    //base.CompareTo(o);

                    //调用显式接口方法
                    IComparable c = this;
                    c.CompareTo(o);

                    return 0;
                }
            }
        }
        class E
        {
            public static void Test10()
            {
                var d1 = new Derived();
                var d2 = new Derived();
                d1.CompareTo(d2);
            }
            internal class Base : IComparable
            {
                int IComparable.CompareTo(object obj)
                {
                    Console.WriteLine("Base's CompareTo");
                    return 0;
                }
                public virtual int CompareTo(object o)
                {
                    Console.WriteLine("Base's virtual CompareTo");
                    return 0;
                }
            }
            internal sealed class Derived : Base, IComparable
            {
                public override int CompareTo(object o)
                {
                    Console.WriteLine("Derived's CompareTo");
                    //此处调用的是虚方法，而非接口的显式实现方法
                    return base.CompareTo(o);
                }
            }
        }

    }
}