C# 关键字 类型测试运算符（is、as、typeof、强制转换表达式）

一、类型测试运算符有is、as、typeof。

　　1、is运算符：用于检测表达式的运行时类型是否与给定的类型兼容。　　

　　2、as运算符：用于将表达式显示转换为给定的类型（如果其运行时类型与该类型兼容）。

　　3、typeof运算符：用于获取某个类型的System.Type实力。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Csharp关键字
{
    class Program
    {
        static void Main(string[] args)
        { 

            Program p = new Program();
            p.IsMark();
            p.AsMark();
            p.Exchange();
            p.TypeofMark();
            p.CompareIsAndTypeof();
        }

        public void IsMark()
        {
            //E is T
            /*
             * 其中E是一个返回值表达式，T是类型或类型参数的名称。E不得为匿名方法或者lambda表达式
             * 如果E的结果为非null且可以通过引用转换(继承或者接口实现)、装箱转换(将类型转换为Object)或取消装箱(将Object类型转换为其子类)转换为类型T，则E is T表达式返回true，
             * 否则返回false，is运算符不会考虑用户自定义的转换。
             */
            #region 引用转换(继承或者接口实现)
            Object b = new Base();
            Console.WriteLine(b is Base);//检查一个类转换为该类本身时，返回true;
            Console.WriteLine(b is Derived);//检查一个类转换为该类的子类时返回false;

            Object d = new Derived();
            Console.WriteLine(d is Base);//检查一个类转换为该类的父类时，返回true;
            Console.WriteLine(d is Derived);//检查一个类转换为该类本身时，返回true;
            Console.ReadKey();
            #endregion

            #region 装箱和拆箱转换（不考虑数值转换）
            int i = 27;
            Console.WriteLine(i is System.IFormattable);//true。这里不太清楚是什么操作。
            object iBoxed = i;
            Console.WriteLine(iBoxed is int);//将Object类型转换为int属于取消装箱操作。返回true;
            Console.WriteLine(iBoxed is long);//因为iBoxed是一个int类型的数字转换为Object，无法拆箱为long，返回false。
            Console.ReadKey();
            #endregion
            #region 有模式匹配的类型测试
            /*
             * 从 C# 7.0 开始，is 运算符还会对照某个模式测试表达式结果。 具体而言，它支持以下形式的类型模式：
             * E is T v
             * 其中，E 为返回值的表达式，T 为类型或类型参数的名称，v 为类型 T 的新局部变量。 
             * 如果 E 的结果为非 null 且可以通过引用、装箱或取消装箱转换来转换为 T，
             * 则 E is T v 表达式将返回 true，E 结果转换后的值将分配给变量 v。                          
             */

            int? jNullable = 7;
            if (iBoxed is int a && jNullable is int c)
            {
                Console.WriteLine(a + c);  // output 34
            }
            Console.ReadKey();
            #endregion
        }
        public void AsMark()
        {
            /*
             * as运算符将表达式结果显式转换为给定的引用或可以为null值的类型。
             * 如果无法进行转换，则as运算符返回null。 
             * 与强制转换表达式不同，as运算符永远不会引发异常。
             * 形式如下的表达式
             * E as T
             * 其中，E 为返回值的表达式，T 为类型或类型参数的名称，生成相同的结果，
             * E is T ? (T)(E) : (T)null
             * 不同的是 E 只计算一次。
             * as 运算符仅考虑引用、可以为 null、装箱和取消装箱转换。 
             * 不能使用 as 运算符执行用户定义的转换。 
             * 为此，请使用强制转换表达式。
             */
            IEnumerable<int> numbers = new[] { 10, 20, 30 };
            IList<int> indexable = numbers as IList<int>;
            if (indexable != null)
            {
                Console.WriteLine(indexable[0] + indexable[indexable.Count - 1]);  // output: 40
            }
            Console.ReadKey();
        }
        public void Exchange()
        {
            /*
             * 形式为 (T)E 的强制转换表达式将表达式 E 的结果显式转换为类型 T。 
             * 如果不存在从类型 E 到类型 T 的显式转换，则发生编译时错误。 
             * 在运行时，显式转换可能不会成功，强制转换表达式可能会引发异常。
             * 下面的示例演示显式数值和引用转换：
             */
            double x = 1234.7;
            int a = (int)x;
            Console.WriteLine(a);   // output: 1234

            IEnumerable<int> numbers = new int[] { 10, 20, 30 };
            IList<int> list = (IList<int>)numbers;
            Console.WriteLine(list.Count);  // output: 3
            Console.WriteLine(list[1]);  // output: 20
        }
        public void TypeofMark()
        {
            /*
             * typeof 运算符用于获取某个类型的 System.Type 实例。 
             * typeof 运算符的实参必须是类型或类型形参的名称，如以下示例所示：
             */
            void PrintType<T>() => Console.WriteLine(typeof(T));

            Console.WriteLine(typeof(List<string>));
            PrintType<int>();
            PrintType<System.Int32>();
            PrintType<Dictionary<int, char>>();
            // Output:
            // System.Collections.Generic.List`1[System.String]
            // System.Int32
            // System.Int32
            // System.Collections.Generic.Dictionary`2[System.Int32,System.Char]
            //===================================================================
            /*
             * 你还可以使用具有未绑定泛型类型的 typeof 运算符。 
             * 未绑定泛型类型的名称必须包含适当数量的逗号，且此数量小于类型参数的数量。 
             * 以下示例演示了具有未绑定泛型类型的 typeof 运算符的用法：
             */
            Console.WriteLine(typeof(Dictionary<,>));
            // Output:
            // System.Collections.Generic.Dictionary`2[TKey,TValue]
            // 表达式不能为 typeof 运算符的参数。 
            //若要获取表达式结果的运行时类型的 System.Type 实例，请使用 Object.GetType 方法。
            //
        }
        public void CompareIsAndTypeof()
        {
            /*
             * 使用 typeof 运算符来检查表达式结果的运行时类型是否与给定的类型完全匹配。 
             * 以下示例演示了使用 typeof 运算符和 is 运算符执行的类型检查之间的差异：
             */
            object b = new Giraffe();
            Console.WriteLine(b is Animal);  // output: True
            Console.WriteLine(b.GetType() == typeof(Animal));  // output: False

            Console.WriteLine(b is Giraffe);  // output: True
            Console.WriteLine(b.GetType() == typeof(Giraffe));  // output: True
        }
    }

    public class Base { }
    public class Derived : Base { }
    public class Animal { }
    public class Giraffe : Animal { }
}