C# 部分語法總結(入門經典)

 

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
    }