C#部分特殊符號和關鍵字使用小技巧

　　在程序中需要進行判斷的時候，我們經常使用分支結構，如if-else和switch-case分支結構，當然，有時候我們也和循環體聯合、多重分支結構嵌套使用以實現復雜判斷。

　　當然，如大多數朋友所熟知，如果只有簡單的判斷（即情況只有‘是’和‘否’兩種），且需要通過判斷進行變量賦值時，我們可以使用“三段式”（即在變量賦值語句中使用如下語法）完成。

using System;

namespace EGForSomeSmallSkills
{
    class Test1
    {
        static void Main(string[] args)
        {
            // 在如下代碼中完成字符串"strTest"的賦值
　　　　　　  // 語句由 類型 變量名 = 判斷條件 ? 可賦值1 : 可賦值2; 組成
　　　　　　  // 如果判斷條件成立變量被賦值為可賦值1，反之為可賦值2
            string strTest = 1 > 2 ? "1大於2成立" : "1大於2不成立";
            Console.WriteLine(strTest);
            Console.ReadKey();
            // 輸出結果為 "1大於2不成立"
　　　　　　　// 如下寫法錯誤
　　　　　　　// 1 > 2 ? Console.WriteLine("1大於2成立") : Console.WriteLine("1大於2不成立");
        }
    }
}

　　通過這種“三段式”，可以簡化我們程序的編碼，也是思路和邏輯更加清晰。

　　在實際編碼中，我們為了減少異常拋出率，增加程序的健壯性（即代碼的嚴謹性），時常在引用類型的使用之前進行是否為空的判斷，在以前使用if-else判斷，使代碼顯得冗余或者麻煩，那么現在我們可以使用“三段式”進行判斷。

using System;

namespace EGForSomeSmallSkills
{
    class Test2
    {
        static void Main(string[] args)
        {
            string strTest1 = null;
            string strTest2 = strTest1 == null ? "將要被賦的值為空" : "將要被賦的值不為空";
            // 以下的寫法也可以，調用string類的靜態方法判斷參數字符串是否為空、空字符串或以空白字符組成
　　　　　　　// 也可以用string.IsNullOrEmpty(string value)方法，可以判斷參數字符串是否為空、空字符串組成
13　　　　　　　 //string strTest2 = string.IsNullOrWhiteSpace(strTest1) ? "將要被賦的值為空" : "將要被賦的值不為空";
            Console.WriteLine(strTest2);
            Console.ReadKey();
            // 輸出結果為 "將要被賦的值為空"

　　　　　　　// 條件簡單時，可以不將條件用括號提升優先級、保證完整
　　　　　　　// 當然，也可以在為空的情況下為變量賦默認值
　　　　　　　// 如下
　　　　　　　// string strTest2 = (strTest1 == null) ? "將要被賦的值為空，這是默認值" : strTest1;
　　　　　　　// 輸出結果為 "將要被賦的值為空，這是默認值"
        }
    }
}

　　但是這樣看起來沒有顯著地減少代碼量是吧？別急，當然有符號可以滿足我們對代碼更簡練的要求，它可以在判斷為空並賦默認值的時候大發神威哦，比如下面的示例。

using System;

namespace EGForSomeSmallSkills
{
    class Test3
    {
        static void Main(string[] args)
        {
            string strTest1 = null;
            string strTest2 = strTest1 ?? "將要被賦的值為空，這是默認值";
            // 以上語句完全等同於如下代碼
　　　　　　　// string strTest2 = strTest1 == null ? "將要被賦的值為空，這是默認值" : strTest1;
            Console.WriteLine(strTest2);
            Console.ReadKey();
            // 輸出結果為 "將要被賦的值為空"
        }
    }
}

　　是不是很方便？為變量賦值時在等號右邊給出兩個可選值，用??隔開，如果??左邊的值不為空，則將??左邊的值賦給變量，否則就將右邊的值賦給變量，即賦默認值。

　　當然，我經常在公開屬性里使用此語句，如下。

using System;
using System.Collections.Generic;

namespace EGForSomeSmallSkills
{
    class Test4
    {
        private string _name;

        public string Name
        {
            // 在訪問器的讀取器中使用，如果_name為空值，返回默認的值
            get { return _name ?? "Johness"; }
            set { _name = value; }
        }

        // 此語句在如下訪問器中尤其有效
        private List<string> _list;

        public List<string> List
        {
            // 對於比較不細心的朋友來說
　　　　　　　// 這里加上一句話有助於減少異常
            get { return _list ?? new List<string>(); }
            set { _list = value; }
        }

        // 當然，這是治標不治本的方法
29　　　　　// 最好的解決辦法是在構造方法實體內對引用類型進行必要的初始化
　　　　 // 如下
        public Test4()
        {
            _list = new List<string>();
            // 我一般即時在類內部也盡量使用字段的對外屬性
　　　　　　　// 即這樣書寫 
　　　　　　　// List = new List<string>();
　　　　　　　// 通過構造方法參數等對引用類型屬性進行初始化
　　　　　　　// ……
        }
    }
}

　　下面我們要介紹另一個強大的符號，?。使用它，我們可以在需要的情況下使值類型可空引用，即使值類型的值可以引用空，可以判斷是否為空，請看下面的代碼。

using System;

namespace EGForSomeSmallSkills
{
    class Test5
    {
        public static void Main(string[] args) 
        {
            // int i = null;
　　　　　　　// 一般情況下，以上代碼是違反C#（其他大部分語言是一樣）規范的
　　　　　　　// 編譯無法通過會產生“無法將 Null 轉換成“int”，因為它是一種不可以為 null 值的類型”的錯誤
12　　　　　　　　// 但是一下代碼是可以的！
            int? i = null;
            // 在值類型聲明時在聲明的類型后添加?，時被聲明值類型擁有部分引用類型的特質
15　　　　　　　 // 比如可為空、可比較為空

            Console.WriteLine(i == null);
            // 輸出“True”

　　　　　　  // 但是，在這樣做了之后，又有了一個難題：int?類型並不是int了，原來取得其值的方法（如下）
　　　　　　  // int j = i;
　　　　　　  // 就會發生錯誤，這是因為類型不同了
　　　　　　  // 我們希望取得int?型的值可以用如下表達式
            int j = i.Value;
            // 當然，如果int?為空的話，它對應的value也是為空
　　　　　　  // 現在如果使用j，會發生異常
        }
    }
}

　　通過以下例子，看看System.Nullable<T>，即值類型加?的實際應用（注：參考http://msdn.microsoft.com/zh-cn/library/b3h38hb0.aspx(Nullable(Of T)結構

)）。

using System;

namespace EGForSomeSmallSkills
{
    class Test6
    {
        public static void Main(string[] args)
        {
            Test(0.3, 100);
            // 輸出 “是會員 應付金額：30”
            Test(null,100);
            // 輸出 "不是會員 應付金額：100"
        }

        /// <summary>
　　　　 /// 一下方法演示通過傳遞的“折扣”是否為空判斷方法調用者是否為VIP
　　　 　/// </summary>
　　　 　/// <param name="discount">折扣，在本示例中表示VIP的折扣
　　 　　/// 為0到1的小數
　　 　　/// 如果傳遞null，則表示為普通用戶，沒有打折
　　 　　/// </param>
　　　　 /// <param name="money">原價</param>
        public static void Test(double? discount, double money)
        {
            double discountR = discount ?? 1;   // 保存折扣，如果不是VIP則折扣率為1
            double pay = money * discountR;     // 實際應付金額
            string outPutStr = (discount == null ? "不是會員" : "是會員") + " 應付金額：" + pay;    // 連接語句並輸出
            Console.WriteLine(outPutStr);
            Console.ReadKey();
        }
    }
32 
}

　　接下來我們說一說new，這個東西我們平時用來創建對象新示例的關鍵字其實還可以作為修飾符使用，而我們現在主要研究一下new作為修飾符使用，先看看下面的例子。

　　總所周知，在類的繼承里，JAVA奉行所有的父類方法都可以被子類覆蓋重寫，即所有方法都是C#里對應的虛方法。那么這樣其實可能會造成效率的損失，而在C#里有實例方法，但是我們如何在父類示例方法的基礎上進行擴展，即覆蓋重寫父類實例方法呢？

using System;

namespace EGForSomeSmallSkills
{
    class Test7_Pro
    {
        public static void Main(string[] args)
        {
            Test7_Child child = new Test7_Child();  // 創建子類對象
            Test7_Base bas = child;    // 用父類引用保存子類對象
            Test7_Base basR = new Test7_Base();   // 創建父類對象

            basR.ViMethod();    // 調用父類對象的虛方法
            bas.ViMethod(); // 調用父類引用保存子類對象的重寫的虛方法（沒有重寫即調用父類虛方法）
            (bas as Test7_Child).ViMethod();    // 調用子類重寫自父類的虛方法 即 child.ViMethod();

            basR.EnMethod();    // 調用父類實例方法
            bas.EnMethod(); // 調用父類實例方法（不會涉及到子類的方法）
            (bas as Test7_Child).EnMethod();    // 調用子類與父類實例方法重名的方法

　　　　　　  // 輸出結果
            /* 執行了父類的虛方法！
            執行了子類重寫自父類的虛方法！
            執行了子類重寫自父類的虛方法！
            執行了父類實例方法！
            執行了父類實例方法！
            執行了子類與父類實例方法同名的方法！*/
        }
    }

    class Test7_Base 
    {
        // 父類虛方法，用於實現多態，可以被子類重寫
        public virtual void ViMethod()
        {
            Console.WriteLine("執行了父類的虛方法！");
        }
        // 父類示例方法，屬於父類而不屬於其派生類
        public void EnMethod() 
        {
            Console.WriteLine("執行了父類實例方法！");
        }
    }

    class Test7_Child : Test7_Base 
    {
        // 重寫父類虛方法
        public override void ViMethod()
        {
            Console.WriteLine("執行了子類重寫自父類的虛方法！");
        }
        // 使用new修飾符向父類隱藏與父類沖突的實例方法
　　　　 // new和public的順序可以交換
        public new void EnMethod() 
        {
            Console.WriteLine("執行了子類與父類實例方法同名的方法！");
        }
    }

}

　　new作為修飾符主要是向父類隱藏同名成員，在接口也可以用。

　　在作為對象聲明時，new關鍵字還有着更為重要的作用，上一次隨筆我就匿名委托（或匿名方法）做了淺淺的分析，這次介紹.NET3.0和4.0的新特性：匿名類型和動態類型。（注：參考http://msdn.microsoft.com/zh-cn/library/bb397696.aspx(匿名類型（C# 編程指南）)http://msdn.microsoft.com/zh-cn/library/dd264736.aspx(使用類型 dynamic（C# 編程指南）)）

using System;

namespace EGForSomeSmallSkills
{
    class Test8
    {
        public static void Main(string[] args)
        {
            var v = new { Name = "Johness" };   // 定義匿名類型變量
            Console.WriteLine("Hello," + v.Name);   // 使用該對象
　　　　　　  // 輸出“Hello,Johness”
　　　　　　  // 在.NET4.0的Linq查詢中會大量使用匿名類型
        }
    }
}

　　在我們的編碼中也可以使用匿名類型的屬性賦值方式，如下：

using System;

namespace EGForSomeSmallSkills
{
    class Test9_Pro
    {
        public static void Main(string[] args)
        {
            Test9 t91 = new Test9(19, "Johness");
            // 相比參數較多帶來的傳遞不便，下面的代碼簡潔且清晰
            Test9 t92 = new Test9 { Name = "Johness", Age = 19 };
            // 也可以顯示調用帶參構造方法並在其后使用類似匿名類型聲明方式完成屬性初始化
　　　　　　  // 注意：只讀域不能在如下{}中聲明，但可以在構造方法體中初始化，如下
            Test9 t93 = new Test9(5) { Name = "Johness", Age = 19 };
            Console.WriteLine(string.Format("年齡：{0} 姓名：{1}", t91.Age, t91.Name));
            Console.WriteLine(string.Format("年齡：{0} 姓名：{1}", t92.Age, t92.Name));
            Console.WriteLine(string.Format("年齡：{0} 姓名：{1}", t93.Age, t93.Name));
            // 輸出
　　　　　　  // 年齡：19 姓名：Johness
　　　　　　  // 年齡：19 姓名：Johness 
　　　　　　  // 年齡：19 姓名：Johness 
        }
    }

    class Test9
    {
        private readonly int i;
        public int Age { get; set; }
        public string Name { get; set; }
        // ……

        public Test9(int age, string name)  // 在屬性較多並且需要在構造對象時初始化的情況下，我們可能會對構造方法進行重載
        {                                  // 但是即時經過重載，我們傳遞較多參數時仍可能混淆先后次序，造成不便
            this.Age = age;
            this.Name = name;
        }

        public Test9(int i) // 傳遞只讀屬性初始值進行只讀域初始化
        {
            this.i = i;
        }

        public Test9()
        {

        }
    }
}

　　動態類型和匿名類型的差別有兩點：一是匿名類型的真正類型只能指定一次，而動態類型不是，二是匿名類型是.NET3.0新特性，而動態類型是.NET4.0新特性……開玩笑的，不過在以下實例中可以真正看到他們的第二點不同：

using System;

namespace EGForSomeSmallSkills
{
    class Test10
    {
        public static void Main(string[] args)
        {
            // 可以將匿名類型轉化為對象類型返回
            object obj1 = GetSomeObjectByVar();
            // 但系統無法識別它的真正類型
　　　　　　  //Console.WriteLine(obj1.Name);

            dynamic obj2 = GetSomeObjectByDynamic();
            Console.WriteLine(obj2.Name);

            // 輸出“Johness”
        }

        public static object GetSomeObjectByVar() 
        {
            var someObj = new { Name = "Johness", Age = 19 };
            return someObj;
        }

        // 由於是動態類型，返回值可以為object、dynamic
        public static dynamic GetSomeObjectByDynamic() 
        {
            // dynamic 也可以替換為var、object
            dynamic someObj = new { Name = "Johness", Age = 19 };
            return someObj;
        }
    }
}

　　這次的小技巧就到這兒。