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;
        }
    }
}

　　这次的小技巧就到这儿。