强转，高度大气上档次，隐转，低调奢华有内涵

甲：TM，又要建一个对象，真烦，就没有省事点的代码么？算啦，写吧：

            People people = new People();
            people.Name = "小胡";
            people.Age = 25;
            people.Profession = "程序员";
            people.Sex = "男";
            people.toDo();

乙：都啥年代了，还用这么Low的方法初始化对象，对于高频创建的类，你就不能给它写个构造方法，一行代码足以创建对象并且调用方法：

            new People("小胡", 25, "程序员", "男").toDo();

乙：或者直接使用初始化器，更加自由：

            new People() { Name = "小胡", Age = 25, Profession = "程序员", Sex = "男" }.toDo();

丙：既然说到是会高频创建的类，还有一种方式去创建它：

            ((People)"小胡,25,程序员,男").toDo();

甲、乙：厉害，怎么做到的？

丙：当然是强制转换啦，看红色的代码，这就是让类支持指定类型强行转换的秘诀：

    class People
    {
        string name;
        int age;
        string profession;
        string sex;

        public string Name { get => name; set => name = value; }
        public int Age { get => age; set => age = value; }
        public string Profession { get => profession; set => profession = value; }
        public string Sex { get => sex; set => sex = value; }

        public People()
        {

        }

        public People(string _name,int _age,string _profession,string _sex)
        {
            Name = _name;
            Age = _age;
            Profession = _profession;
            Sex = _sex;
        }

        public void toDo()
        {
            Console.WriteLine("我叫{0}，性别{1}，今年{2}岁，我的工作是{3}", Name, Sex, Age, Profession);
        }

        public static explicit operator People(string infoStr)
        {
            string[] infoArray = infoStr.Split(',');
            return new People(infoArray[0], int.Parse(infoArray[1]), infoArray[2], infoArray[3]);
        }
    }

丙：此方法必须为静态公开，入参类型便是你要进行强行转换的类型，至于怎么转，便可由你在方法体内自由定义。好了，以上便是强制转换的相关内容，接下来咱们再说说与之相对应的隐式转换。强转的关键是explisit operator，隐转的关键字则是implicit operator：

        public static implicit operator People(string infoStr)
        {
            string[] infoArray = infoStr.Split(',');
            return new People(infoArray[0], int.Parse(infoArray[1]), infoArray[2], infoArray[3]);
        }

支持隐式转换的类，则可以这样创建：

            People p = "小胡,25,程序员,男";
            p.toDo();

并且，隐式转换兼容强制转换，也就是说，你依然可以用强行转换的方式进行调用：

            ((People)"小胡,25,程序员,男").toDo();

总而言之，用转换的方式进行对象的创建，适用于程序员对类型创建非常频繁，并且对初始化格式非常熟悉的情况。当然用转换创建对象的方法也并非绝对的死板，可以根据入参的格式，来定义多种初始化，如下：

        public static implicit operator People(string infoStr)
        {
            string[] infoArray = infoStr.Split(',');
            switch(infoArray[0])
            {
                case "1":
                    return new People(infoArray[0], int.Parse(infoArray[1]), infoArray[2], infoArray[3]);
                case "2":
                //转换初始化方法2
                case "3":
                //转换初始化方法3
                default:
                //其他初始化方法
                    break;
            }
        }

那么我们就有多种创建对象的方式可供选择：

            //方式1
            ((People)"1,小胡,25,程序员,男").toDo();
            //方式2
            ((People)"2,小胡,25").toDo();
            //方式n
            ((People)"n,小胡,程序员").toDo();

甲、乙：转换还能这么用，学到了学到了。