C# 对象类型转换

在日常开发时，经常需要将对象从一种类型转换为另一种类型。CLR允许将对象转换为它的（实际）类型或者它的任何基类型。

C#不要求任何特殊语法即可将对象转换为它的任何基类型，因为向基类型的转换被认为是一种安全的隐式转换。然而，将对象转换为它的某个派生类型时，C#要求开发人员只能进行显式转换，因为这种转换可能在运行时失败。可以理解为：父类强制转换成子类,子类隐式转换成父类

    internal class Employee
    {
    }

    class Program
    {
        static void Main(string[] args)
        {
        // 子类隐式转换成父类，不需要转换
        // 因为new返回一个Employee对象，而Object是Employee的基类
        Object o = new Employee();
        // 子类可以自动转父类 可以这么理解把子类的实例em的地址赋值给了o1, o1的地址就是em的地址
        // 这时就可以调用Employee 类的方法，点出Employee 类的属性
        Employee em = new Employee();
        Object o1 = em;

            // 父类强制转换成子类, 需要转换
            // 因为Employee派生自Object
            Employee e = (Employee)o;
        }
    }

在运行时，CLR会检查转型操作，确定总是转换为对象得实际类型或者它的任意类型。下面的代码虽然能通过编译，但会在运行时抛出InvalidCastException异常：

    internal class People
    {
    }

    internal class Employee : People
    {
    }

    internal class Manager : Employee
    {
    }

    class Program
    {
        static void Main(string[] args)
        {
            // 创建实例的时候没有将父类引用到子类对象,是无法转换的
            // PromoteEmployee不能运行成功
            People p = new People();
            PromoteEmployee(p);

            // 创建实例的时候将父类引用到子类对象,是可以转换的
            // PromoteEmployee能运行成功
            People p1 = new Employee();
            PromoteEmployee(p1);

            // Manager"属于"(IS-A)Employee对象
            // PromoteEmployee能运行成功
            Manager m = new Manager();
            PromoteEmployee(m);

            // DateTime不是从Employee派生的
            // PromoteEmployee不能运行成功
            DateTime newYears = new DateTime(2011, 10, 1);
            PromoteEmployee(newYears);
        }

        static void PromoteEmployee(Object o)
        {
            // 编译器在编译时无法准确地获知对象0引用的是什么类型，因此允许代码通过编译
            // 但在运行时，CLR知道了o引用的是什么类型（在每次执行转型的时候）
            // 所以它会核实对象的类型是不是Employee或者从Employee派生的任何类型
            Employee e = (Employee)o;
        }
    }

使用C#的is和as操作符来转型
在C#语言中进行转换的另一种方式是使用is操作符。is检查对象是否兼容于指定类型，返回Boolean值true或false。注意，is操作符永远不抛出异常，例如以下代码：

        static void Main(string[] args)
        {
            Object o = new Object();
            Boolean b1 = (o is Object);    //True
            Boolean b2 = (o is Employee);  //False
            Boolean b3 = (o is Nullable);  //False
        }

is操作符通常像下面这样使用：

        static void Main(string[] args)
        {
            Object o = new Employee();
            if( o is Employee )
            {
                Employee e = (Employee)o;
            }
        }

在上诉代码中，CLR实际检查两次对象类型。is操作符首先核实o是否兼容于Employee类型。如果是，在if语句内部转型时，CLR再次核实o是否引用一个Employee。CLR的类型检查增强了安全性，但无疑会对性能造成一定的影响。这是因为CLR首先必须判断变量(o)引用的对象的实际类型。然后CLR必须遍历继承层次结构，用每个基类型去核对指定的类型（Employee）。由于这是一个相当常用的编程模式，所以C#专门提供了as操作符，目的就是简化这种代码的写法，同时提升其性能。

        static void Main(string[] args)
        {
            Object o = new Employee();
            Employee e = o as Employee;
            if(e != null)
            {

            }
        }

在这段代码中，CLR核实o是否兼容于Employee类型；如果是，as放回对同一个对象的非null引用。如果o不兼容于Employee类型，as返回null。as操作符永远不抛出异常。注意，as操作符造成CLR只校验一次对象类型。if语句只检查e是否为NULL；这个检查的速度不校验对象的类型快得多。

测试代码：

namespace ConsoleApplicationTest
{
    internal class B{}

    internal class D : B{}

    class Program
    {
        static void Main(string[] args)
        {
            Object o1 = new Object(); //OK
            Object o2 = new B(); //OK
            Object o3 = new D(); //OK
            Object o4 = o3; //OK
            B b1 = new B(); //OK
            B b2 = new D(); //OK
            D d1 = new D(); //OK

            B b3 = new Object(); //编译时错误，正确：Object b3 = new B();
            D d2 = new Object(); //编译时错误，正确：Object b3 = new D();

            B b4 = d1; //OK，子类可以自动转父类
            D d3 = b2; //编译时错误，正确：D d3 = (D)b2;
            D d4 = (D)d1; //OK
            D d5 = (D)b2; //OK

            D d6 = (D)b1; //运行时错误，创建实例的时候没有将父类引用到子类对象
            B b5 = (B)o1; //运行时错误，创建实例的时候没有将父类引用到子类对象
            B b6 = (D)b2; //OK，创建实例的时候将父类引用到子类对象
        }
    }
}