第七节：语法总结(1)(自动属性、out参数、对象初始化器、var和dynamic等)

一. 语法糖简介

  　   语法糖也译为糖衣语法，是由英国计算机科学家彼得·约翰·兰达（Peter J. Landin）发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。通常来说使用语法糖能够增加程序的可读性，从而减少程序代码出错的机会。

      需要声明的是“语法糖”这个词绝非贬义词，它可以给我带来方便，是一种便捷的写法，编译器会帮我们做转换；而且可以提高开发编码的效率，在性能上也不会带来损失。

      在编译器发展早期，编译器科学家门一直在想方设法的优化编译器生成的代码，这个时候，编译器做的主要是对机器优化，因为那个时候机器的时间非常宝贵，机器运算速度也不快，今天我们有了足够好的机器了(但并不是说我们可以不关注性能的编写程序)，而且作为编写软件的人来说，比机器的时间宝贵得多，所以今天的编译器也在向人优化了，从编程语言的发展之路来讲，今天的编程语言比昨天的语言更高级，也更人性化了，我们只要编写更少的代码，更符合人的思维的代码，而只要关注我们值的关注的地方。体力活儿就交给编译器吧。

二. 常用语法糖

1. 自动属性

(1).  传统的方式在类中声明一个属性，需要先声明一个私有变量的字段，然后在配合公有属性，如下面的：userId属性。

(2). 利用自动属性：不需要字段，声明一个空属性，直接get,set（快捷键：prop）,编译时编译器为我们生成存取数据的字段. 如下面的：userName属性。

 public class userInfor
    {
        //私有字段
        private string _userId;
        //公有属性
        public string userId
        {
            get
            {
                return _userId;
            }
            set
            {
                _userId = value;
            }
        }

        public string useName { get; set; }


        /// <summary>
        /// 为了后面的反射调用
        /// </summary>
        public void Test()
        {
            Console.WriteLine("我是一个方法");
        }

    }

2. var和dynamic

(1). var类型：声明变量的时候可以不指定类型，由编译器编译的时候来指定类型。

　　①：必须在定义的时候初始化

　　②：必须是局部变量

　　③：一旦初始化完成,不能再给变量赋与初始值不同类型的值了,但是可以赋相同类型的不同值.

　　④：var在效率是和使用强类型方式定义变量是一样的

(2). dynamic类型：编译期间不做任何检查,运行期间才确定类型。

　　①：定义的时候可以不必初始化

　　②：可以是全局变量,也可以是局部变量

 　　dynamic在反射中的应用：通过反射拿到类后，赋值给dynamic类型,该类型的对象可以直接点来调用方法

 　　缺点：dynamic在运行的时候才进行检测,导致编译的时候即使有错误也不会被发现; 不能用dynamic类型给确定类型的变量进行赋值

 public class CompareTwo
    {
        //2. 可使用的范围
        // var b1 = 1;        //报错，var必须定义在方法呃逆
        // dynamic b2 = 2;    //正常
        public static void Show()
        {
            {
                //1. 初始化比较
                //var a1;         //报错，定义的时候必须初始化
                //dynamic a2;     //正常
            }
            {
                //3. 赋值问题
                var c1 = 2;
                //c1 = "2";   //报错,初始化完成不能赋值不同类型的变量
                c1 = 3;    //正常,初始化完成可以赋值相同类型的变量的不同值

                dynamic d1 = 2;
                d1 = "2";      //正常,运行时检查进行类型指定，所以在编译的时候不会报错
                d1 = 3;       //正常


                var userInfor = new userInfor();
                userInfor.useName = "1";
                userInfor.userId = "2";
                // userInfor.fk123();    //报错，编译不通过

                dynamic userInfor2 = new userInfor();
                userInfor2.userId = "1";
                userInfor2.useName = "ypf";
                //调用不存在的方法  (因为编译的时候根本不检查，所以不会报错，运行的时候报错)
                //userInfor2.fk123();    //编译期间不报错，运行的时候报错

            }
            {
                //4. dynamic在反射中的应用
                //4.1 常规反射调用方法
                Type type1 = typeof(userInfor);
                object oStudent = Activator.CreateInstance(type1);
                MethodInfo method = type1.GetMethod("Test");
                method.Invoke(oStudent,null);

                //4.2 利用dynamic简化调用
                //定义和编译的时候可以是任何类型，运行的时候进行转换
                dynamic oStudent2 = Activator.CreateInstance(type1);
                oStudent2.Test();

            }
        }
    }

3. 可选参数

给方法的参数可以指定默认值,如果在调用该方法的时候,不传入该参数，则走默认值，传入的话，则覆盖默认参数.

(1).  有默认值的参数必须定义在没有默认值的参数之后

(2).  默认参数必须是常量,不能是变量

(3).  ref和out参数不能指定默认值

  public class OptionalParas
    {
        public static void Test(string useName,string userPwd,int userAge=16,string userSex="男")
        {
            Console.WriteLine("userName:{0},userPwd:{1},userAge:{2},userSex:{3}", useName, userPwd, userAge, userSex);
        }
    }

 　　　　　　//3.可选参数
            Console.WriteLine("----------------------3.可选参数-------------------------");
            OptionalParas.Test("ypf1", "123456");
            OptionalParas.Test("ypf2", "654321", 56, "女");

4. 对象(集合)初始化器

 public class ObjectInitilize
    {
        public static void Test()
        {
           
                //一.对象初始化
                //1. 传统初始化对象的方式
                userInfor uInfor1 = new userInfor();
                uInfor1.userId = "1";
                uInfor1.useName = "ypf1";

                //2.对象初始化器
                userInfor uInfor2 = new userInfor()
                {
                    userId="2",
                    useName="ypf2"
                };
                userInfor uInfor3 = new userInfor()
                {
                    userId = "3",
                    useName = "ypf3"
                };
            
                //二. 集合初始化
                //1. 传统方式
                List<userInfor> uList = new List<userInfor>();
                uList.Add(uInfor1);
                uList.Add(uInfor2);

                //2. 集合初始化器
                List<userInfor> uList2 = new List<userInfor>(){
                    uInfor1,
                    uInfor2,
                    new userInfor(){
                        userId="4",
                        useName="ypf4"
                    }
                };
                
        }
    }

5. ref和out

二者共同的使用场景，将ref或out参数传入方法中，执行完方法后，可以直接使用ref或out参数值。

　　(1). ref必须在使用前赋值，即传入方法前进行定义并赋值

　　(2). out必须在方法中赋值然后使用,在调用方法前声明两个未实例化的变量，用来传入和接收使用

举例：有两个int类型的值num1和num2，分别使用ref和out传入对应的方法中，进行值交换。

 public class CompareRO
    {
        /// <summary>
        /// ref的使用
        /// </summary>
        public static void TestRef()
        {
            int num1 = 5;
            int num2 = 10;
            Func1(ref num1, ref num2);
            Console.WriteLine("num1的值为:{0},num2的值为:{1}", num1, num2);
        }

        public static void TestOut()
        {
            int num1;
            int num2;
            Func2(out num1, out num2);
            Console.WriteLine("num1的值为:{0},num2的值为:{1}", num1, num2);
        }

        #region ref版参数值交换
        public static void Func1(ref int n1, ref int n2)
        {
            int a = n1;
            n1 = n2;
            n2 = a;
        }
        #endregion

        #region out版参数值交换
        public static void Func2(out int n1,out int n2)
        {
            n1 = 5;
            n2 = 10;
            int a = n1;
            n1 = n2;
            n2 = a;
        }
        #endregion

    }

6. 匿名类/匿名方法

 　　详见：.Net进阶系列(3)-匿名类、匿名方法、扩展方法

7. 扩展方法

 　　详见：.Net进阶系列(3)-匿名类、匿名方法、扩展方法