class Program
    {
        static void Main(string[] args)
        {
            init();
            System.Console.ReadKey();
        }


        #region 接口
        /// <summary>
        /// 接口成员是公共的，不能加其他修饰符,如static,public,virtual等
        /// </summary>
        public interface IA
        {
            string IStr { get; set; }
            void IMethod();
        }

        public interface IB
        {
            string IStr { get; set; }
            void IMethod();
        }

        #endregion

        #region B

        public class B
        {
            public virtual void Do()
            {
                System.Console.WriteLine("B -Do");
            }

            public virtual void Go()
            {
                System.Console.WriteLine("B -Go");
            }

            public void Say()
            {
                System.Console.WriteLine("B -Say");
            }
        }
        #endregion

        #region C
        public abstract class C : B
        {
            #region 私有成员
            private int i = 0;
            #endregion

            #region 构造函数

            public C()
            {
                System.Console.WriteLine("C()");
            }

            public C(int i)
            {
                this.i = i;
                System.Console.WriteLine("C(int i)");
            }

            #endregion

            /// <summary>
            /// 覆盖
            /// </summary>
            public override void Do()
            {
                System.Console.WriteLine("C -Do");
            }
            /// <summary>
            /// 隐藏
            /// </summary>
            public new void Say()
            {
                System.Console.WriteLine("C -Say");
            }

            /// <summary>
            /// 覆盖和密封，sealed必须和override一起使用
            /// </summary>
            public override sealed void Go()
            {
                System.Console.WriteLine("C -Go");
            }


            /// <summary>
            /// 只读抽象属性,虚方法和抽象方法不能为private,抽象成员所属类只能是抽象类
            /// </summary>
            public abstract string AbStr { get; }
            public abstract string AbMethod();
            protected abstract void AbProtected();

        }
        #endregion

        #region D
        /// <summary>
        /// 类单继承，接口多实现
        /// </summary>
        public class D : C, IA, IB, IComparable, IComparer
        {
            #region 私有成员
            private int i = 0;
            private int timeCount = 0;
            /*默认是私有的*/
            System.Timers.Timer aTimer;
            #endregion

            #region 构造函数 this base
            /*
             * 在一开始掉用该类时，初始化一次
             */
            /// <summary>
            /// 静态构造函数,只能为私有的,不能有参数,不能被外部所更改
            /// </summary>
            static D()
            {
                System.Console.WriteLine("Static D()");
            }

            /*
             * 实例化是:从之类到父类传递值，并从父类到之类的实例化过程
             */
            public D()
                : this(1)
            {
                System.Console.WriteLine("D()");
            }

            public D(int i)
                : base(i)
            {
                //this关键字指向本类实例
                this.i = i;
                System.Console.WriteLine("D(int i)");
            }

            #endregion

            #region 方法的覆盖、隐藏、密封 sealed new
            public override void Do()
            {
                System.Console.WriteLine("D -do");
            }

            public new void Say()
            {
                System.Console.WriteLine("D -Say");
            }


            #endregion

            #region 实现父类抽象成员 override
            /// <summary>
            /// 基础父类抽象成员
            /// </summary>
            public override string AbStr
            {
                get
                {
                    return "AbStr";
                }
            }
            /// <summary>
            /// 基础父类抽象成员
            /// </summary>
            public override string AbMethod()
            {
                return "AbMethod";
            }
            /// <summary>
            /// 访问级别只能小于等于保护级别，不能高于基类的访问级别
            /// </summary>
            protected override void AbProtected()
            {
            }
            #endregion

            #region 索引器
            /// <summary>
            /// 索引器
            /// </summary>
            /// <param name="i"></param>
            /// <returns></returns>
            public string this[int i]
            {
                get
                {
                    return "this[int i] " + i;
                }
            }

            /// <summary>
            /// 索引器2
            /// </summary>
            /// <param name="i"></param>
            /// <returns></returns>
            public string this[string i]
            {
                get
                {
                    string r = string.Empty;
                    switch (i)
                    {
                        case "A":
                            r = "this[string i] A";
                            break;
                        case "B":
                            r = "this[string i] B";
                            break;
                        default:
                            break;
                    }
                    return r;
                }
            }
            #endregion

            #region IA IB 接口成员
            /// <summary>
            /// 隐式调用，多个接口同名成员可用一个成员实现,访问级别必须为public
            /// </summary>
            public string IStr
            {
                get
                {
                    return "";
                }
                set
                {

                }
            }
            /*接口二义性 分开实现同名接口成员,显示实现，不能用public等修饰符，通过实例转换为接口类型来调用相应的私用方法
             例如：D d = new D();
                 ((IA)d).IMethod();
                 ((IB)d).IMethod();
             */
            /// <summary>
            /// 显示实现IA接口，
            /// </summary>
            void IA.IMethod()
            {
                System.Console.WriteLine("IA.IMethod()");
            }
            /// <summary>
            /// 显示实现IB接口，分开实现同名接口成员
            /// </summary>
            void IB.IMethod()
            {
                System.Console.WriteLine("IB.IMethod()");
            }

            #endregion

            #region 委托和事件 delegate event
            //使用委托和事件比较典型的例子是：观察者模式
            /*1.单独使用委托，代码封装性易用性较差。
             *2.委托返回一般为void,根据委托链，返回最后一个方法执行的返回值
             */
            public delegate string DgNoEvent(string str);
            public DgNoEvent dgNoEvent;

            /*2.将委托与事件结合
             * 一方面是为了封装性、易用性
             * 另外一方面是防止通过调用委托变量,在外部调用该委托方法。方法应该在封装的方法内被触发
             */
            public delegate string DgEventHandler(string str);
            public event DgEventHandler dgEvent;


            public void DgGo()
            {
                if (dgEvent != null)
                {
                    //同步调用
                    dgEvent("dgEvent");
                    //异步调用,部分代码执行时间过长，可能会影响程序执行。观察者用异步，这样就不影响发布者。
                    AsyncCallback callBack = new AsyncCallback(OnAddComplete);
                    //IAsyncResult iAsyncResult = dgEvent.BeginInvoke("AsyncdgEvent", callBack, null);
                }
                if (dgNoEvent != null)
                    dgNoEvent("dgNoEvent");
            }

            void OnAddComplete(IAsyncResult asyncResult)
            {
                IAsyncResult result = (IAsyncResult)asyncResult;
                string data = (string)asyncResult.AsyncState;
                System.Console.WriteLine(data);
            }


            #endregion

            #region 多线程互斥锁 lock
            /*
             * 多线程的资源争用情况，使用互斥锁，让线程等待
             */
            public void OnStart()
            {
                try
                {
                    aTimer = new System.Timers.Timer();
                    //同步调用
                    aTimer.Elapsed += OnTimedEvent;
                    aTimer.Interval = 1000;
                    aTimer.Enabled = true;

                }
                catch (Exception ex)
                {
                    System.Console.WriteLine("异常");
                }
            }

            void OnTimedEvent(object source, ElapsedEventArgs e)
            {

                lock (this)
                {
                    //只循环两次
                    if (timeCount >= 2)
                    {
                        aTimer.Enabled = false;
                        aTimer.Elapsed -= OnTimedEvent;
                        return;
                    }
                    timeCount++;
                    for (int i = 0; i < 5; i++)
                    {
                        Thread.Sleep(2000);
                        System.Console.WriteLine("线程" + Thread.CurrentThread.ManagedThreadId + "停止" + i + "秒");
                    }

                }
            }
            #endregion

            #region lambda表达式、匿名方法
            /*
             * lambda 表达式是一个可用于创建委托对象或表达式树类型的匿名函数
             (input parameters) => {statement;} 
             */
            delegate bool Lambda1NoEventHandler(string str);
            delegate string Lambda2NoEventHandler(string str, int i);
            delegate void Lambda0NoEventHandler();
            public void LambdaAndAnonmous()
            {
                //lambda方式
                Lambda0NoEventHandler l0 = () => System.Console.WriteLine("Lambda0");
                Lambda1NoEventHandler l1 = (str) => str.Equals("A");
                Lambda2NoEventHandler l2 = (str, i) => { System.Console.WriteLine(str); return ""; };
                l0();
                l1("A");
                l2("lambda2", 0);
                //匿名方法，匿名类型
                /*
                 * var变量，编译器会去判断该类型
                 */
                var a = new { s = "", d = "" };
                l2 = delegate(string str, int i)
                {
                    System.Console.WriteLine(str);
                    return "";
                };
                l2("anonmous", 0);
            }
            #endregion

            #region 迭代器 GetEnumerator
            /*实现该迭代器之后，可对该对象进行foreach遍历*/
            public IEnumerator GetEnumerator()
            {
                yield return "1";
                yield return "2";
                yield return "3";
            }

            #endregion

            #region 比较  IComparer is typeof
            #region IComparer Members

            public int Compare(object x, object y)
            {
                D d1 = (D)x;
                D d2 = (D)y;
                if (d1.i > d2.i)
                    return 1;
                if (d1.i == d2.i)
                    return 0;
                return -1;

            }

            #endregion

            #region IComparable Members

            public int CompareTo(object obj)
            {
                D d1 = (D)obj;
                if (i > d1.i)
                    return 1;
                if (i == d1.i)
                    return 0;
                return -1;
            }

            #endregion

            /*类型比较*/
            public void CompareType()
            {
                D d = new D();
                /*类型需完全一致*/
                if (d.GetType() == typeof(C))
                {
                    System.Console.WriteLine("d.GetType() == typeof(C)");
                }
                /*is 判断是否可以转换为指定类型*/
                if (d is B)
                {
                    System.Console.WriteLine("d is B");
                }
            }

            #endregion

            #region 运算符重载
            /*加号两边参数要按顺序调用*/
            public static string operator +(D d1, D d2)
            {
                string str = d1.GetType().ToString() + d2.GetType().ToString();
                System.Console.WriteLine("operator +(D d1, D d2)");
                return "str";
            }
            public static string operator +(D d, C c)
            {
                string str = c.GetType().ToString() + d.GetType().ToString();
                System.Console.WriteLine("operator +(D d, C c)");
                return "str";
            }
            public static string operator +(C c, D d)
            {
                string str = c.GetType().ToString() + d.GetType().ToString();
                System.Console.WriteLine("operator +(C c, D d)");
                return "str";
            }
            /*隐式的转换运算符 D d=0; */
            public static implicit operator D(int i)
            {
                D d = new D();
                d.i = i;
                return d;
            }
            /*显示的转换运算符 D d=(D)"0";*/
            public static explicit operator D(string str)
            {
                D d = new D();
                d.IStr = str;
                return d;
            }
            #endregion

            #region 可空类型和??空接合运算符
            public void Nullable()
            {
                int? i = null;
                int j = i ?? 0;
            }
            #endregion

            #region 泛型default和各种约束
            /*
             * T:有一个无参数构造函数 
             * K:必须是值类型 
             * L:必须是引用类型
             * M1-M2:M1和M2必须类型相同，或者M1继承至M2
             * N:N和C必须类型相同，或者继承至C
             * N2:N2必须实现IA接口
             */
            public T Tnew<T, K, L, M1, M2, N, N2>()
                where T : new()
                where K : struct
                where L : class
                where M1 : M2
                where N : C
                where N2 : IA
            {
                /*赋予默认值，数值型为0,类为null等*/
                return default(T);
            }
            #endregion

            #region 变体：协变(out)和抗变(in)
            /*
             * 协变和抗变只能用在引用类型上面，不能用在值类型上面。
             * 协变和抗变只能用在泛型委托和泛型接口上面。
             */
            public interface IIndex<out T>
            {
                T this[int index] { get; }
                int Count { get; }
            }
            public class RectangleBase { public int ID { get; set; } }
            public class Rectangle : RectangleBase { public string Name { get; set; } }
            public class RectangleCollection : IIndex<Rectangle>
            {
                List<Rectangle> list = new List<Rectangle>();
                public Rectangle this[int index]
                {
                    get
                    {
                        if (index < 0 || index > Count)
                            throw new ArgumentOutOfRangeException("index");
                        return list[index];
                    }
                }
                public int Count { get { return list.Count; } }
                public void Add(Rectangle value) { list.Add(value); }
            }
            public void Variance()
            {
                D d = new D();
                var list = new RectangleCollection();
                list.Add(new Rectangle { ID = 1, Name = "111" });
                list.Add(new Rectangle { ID = 2, Name = "222" });
                list.Add(new Rectangle { ID = 3, Name = "33" });
                //使用了out关键字，可以转换为base类型
                IIndex<RectangleBase> Bas = list;
                IIndex<Rectangle> Basa = list;
                for (int i = 0; i < Bas.Count; i++)
                {
                    System.Console.WriteLine(Bas[i].ID);
                }
                System.Console.Read();
            }

            #endregion

            #region 初始化器、匿名类型、类型查找Var
            /*
             *  不用新建一个多个参数的构造函数
             */
            public void InitMethod()
            {
                /*类初始化器*/
                D d = new D()
                {
                    i = 0,
                    IStr = "a"
                };
                /*集合*/
                //普通方法
                int[] s3 = new int[2];
                s3[0] = 1;
                s3[1] = 0;
                //集合初始化器
                int[] s = new int[] { 
                    1,0,1,2,2,3
                };
                int[] s2 =  { 
                    1,0,1,2,2,3
                };
                /*匿名类型*/
                var a = new { s = "", d = "" };
                var ass = new[] { new { s = "", d = "" }, new { s = "", d = "" } };
                string str = a.s;
            }

            #endregion

            #region 动态查找 dynamic
            public dynamic Getdynamic()
            {
                if (i == 0)
                    return new B();
                else
                    return new D();
            }
            #endregion

            #region 高级方法参数：可选参数、参数不固定、传递值类型的引用 out ref
            //可选值只能位于方法的末尾，不能放置于没有默认值的参数之前
            void HightlevelArg(int i, bool b = true, bool c = false)
            {
                HightlevelArg(1);
                HightlevelArg(1, false);
                //也可以这么调用，跳过中间参数
                HightlevelArg(1, c: true);
            }
            /*参数数组，可变个数的参数*/
            void Args(params int[] i)
            {
                int length = i.Count();
                //这么调用
                Args(1, 1, 1, 1);
            }
            /*
             * out:必须在方法体内初始化
             * ref:必须在外部初始化
             */
            void ArgsOutIn(out int i, ref int j)
            {
                //out 在方法体内初始化
                i = 0;
            }

            #endregion

            #region 扩展方法,表达式树
            /*静态类 静态方法 第一个参数 this string obj */
            public void Expression()
            {
                Expression<Func<int, int, int>> expression = (a, b) => a * b + 2;
                dynamic f = Getdynamic();
            }
            #endregion

        }
        #endregion

        #region init()
        public static void init()
        {
            /*1.抽象，继承，封装，覆盖，隐藏，密封，实例化，静态构造函数，实现*/
            B b = new B();
            b.Do();
            b.Say();
            b.Go();

            D d = new D();
            d.Do();
            d.Say();
            d.Go();

            b = d;
            b.Do();
            b.Say();
            b.Go();

            /*2.调用私有的显示实现接口的成员*/
            ((IA)d).IMethod();
            string abStr = d.AbStr;

            /*3.索引器*/
            System.Console.WriteLine(d["A"]);
            System.Console.WriteLine(d["B"]);
            System.Console.WriteLine(d[0]);

            /*4.委托和事件*/
            d.dgNoEvent = new D.DgNoEvent(GGG);
            //可以直接调用，失去了委托意义，是不符合正道的。
            d.dgNoEvent("dgNoEvent outSide the Delegate");
            //这样才是正道
            d.dgEvent += GGG;

            /*5.lambda表达式建立对象 
             () => SomeMethod()
             */
            d.dgEvent += strParam =>
            {
                System.Console.WriteLine(strParam + " by lambda ");
                return "";
            };
            /*6.匿名方法，建立委托对象 */
            //  通过使用匿名方法，由于您不必创建单独的方法，因此减少了实例化委托所需的编码系统开销。 
            var a = new { s = "", d = "" };
            d.dgEvent += delegate(string str)
            {
                System.Console.WriteLine(str + " by 匿名委托对象 ");
                return "";
            };
            d.DgGo();

            /*7.多进程互斥锁*/
            d.OnStart();
        }

        private static string GGG(string str)
        {
            System.Console.WriteLine(str);
            return "";
        }
        #endregion
    }