第十六节：语法总结(3)(C#6.0和C#7.0新语法)

一. C# 6.0 新语法

1. 自动属性初始化可以赋值

    /// <summary>
    /// 自动属性初始化
    /// </summary>
    public class UserInfor
    {
        public string userId { get; set; } = "123456";

        public string userName { get; set; } = "lmr";

    }
   {
       Console.WriteLine("------------------------- 1. 自动属性初始化可以赋值----------------------------");
       UserInfor uInfor = new UserInfor();
       Console.WriteLine($"id={uInfor.userId},userName={uInfor.userName}");
   }

2. 字符串嵌入值【$配合{}使用】

　　特别注意：{}中如果有业务计算需要配合()使用

   {
                Console.WriteLine("------------------------- 2. 字符串嵌入值【$配合{}使用】----------------------------");
                UserInfor uInfor2 = new UserInfor();
                Console.WriteLine($"名字为：{uInfor2.userName}");
                //代表要输入一个括号{}
                Console.WriteLine($"名字为：{{{uInfor2.userName}}}");
                //{}中如果有业务计算需要配合()使用
                Console.WriteLine($"{(uInfor2.userName != "lmr" ? "小鲜肉" : "老鲜肉")}");
   }

3. 可以在命名空间出使用static声明静态类

 

{
                Console.WriteLine($"-------------------------3.可以在命名空间出使用static声明静态类-------------------------");
                Console.WriteLine($"之前的使用方式: {Math.Pow(4, 2)}");
                Console.WriteLine($"导入后可直接使用方法: {Pow(4, 2)}");
}

4. 空值运算符(?)

　　不需要判断是否为空了.

 {
                Console.WriteLine($"-------------------------4. 空值运算符-------------------------");
                int? iValue = 10;
                Console.WriteLine(iValue?.ToString());//不需要判断是否为空
                string name = null;
                Console.WriteLine(name?.ToString());
}

5. 对象初始化

　　可以直接给字典类型通过类似“索引”的形式赋值 (原先是通过Add方法赋值)

 {
                Console.WriteLine($"-------------------------5. 字典对象初始化-------------------------");
                Dictionary<string, string> dicList = new Dictionary<string, string>()
                {
                    ["1"] = "ypf1",
                    ["2"] = "ypf2",
                    ["3"] = "ypf3"
                };
                Dictionary<string, string> dicList2 = new Dictionary<string, string>()
                 {
                     { "1","lmr1"},
                     { "2","lmr2"},
                     { "3","lmr3"}
                 };
                foreach (var item in dicList)
                {
                    Console.WriteLine("key:{0},value:{1}", item.Key.ToString(), item.Value.ToString());
                }
                foreach (var item in dicList2)
                {
                    Console.WriteLine("key:{0},value:{1}", item.Key.ToString(), item.Value.ToString());
                }
            }

6. 异常过滤器增加when判断条件

　　只有符合when里的条件，才能进入catch,如果不满足的话，直接代码报错，不能抛异常

  {
                Console.WriteLine("-------------------------6. 异常过滤器增加when判断条件-------------------------");
                int epCheck = 100;
                try
                {
                    int.Parse("ypf");
                }
                catch (Exception e) when (epCheck > 11)
                {
                    Console.WriteLine(e.Message);
                }
}

7. nameof表达式

　　把实例转换成同名的字符串

 {
                Console.WriteLine("-------------------------7. nameof表达式-------------------------");
                UserInfor userInfor = new UserInfor();
                Console.WriteLine(nameof(userInfor));
}

8. 在catch和finally语句块里使用await(暂不介绍，不常用)

9. 在属性或方法上使用Lambada表达式

　　①：方法针对于只有一行的方法

　　②：属性通过Lambda的形式进行赋值

   public class UserInfor
    {
        public string userId { get; set; } = "123456";

        public string userName { get; set; } = "lmr";

        /// <summary>
        /// Lambda类型的方法
        /// </summary>
        public void LambdaPrint() => Console.WriteLine("我是Lambda类型的方法");

        public string userSex => string.Format("男");
    }
 {
                Console.WriteLine("-------------------------9.在属性或方法上使用Lambada表达式-------------------------");
                UserInfor userInfor = new UserInfor();
                userInfor.LambdaPrint();
                Console.WriteLine($"userSex的值为：{userInfor.userSex}");
}

二. C# 7.0 新语法

1. out参数的改进

　　在C#7.0之前, out参数使用前必须先声明，然后传入方法中，在C#7.0后可以直接在传入方法的时候进行声明。

        /// <summary>
        /// out参数的改进
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        public void DoNoting(out int x, out int y)
        {
            x = 1;
            y = 2;
        }
        {
            Console.WriteLine("--------------------1-out参数的改进------------------------");
            SevenEdition s = new SevenEdition();
            s.DoNoting(out int x, out int y);
            Console.WriteLine(x + y);
         }

2. 元组(Tuples)

　　①：需要通过nuget安装这个System.ValueTuple包

　　②：元组创建的三种方式：语法糖、Create静态方法、构造函数 (默认情况下是通过Item1、Item2 。。。)

　　③：指定元祖命名：可以通过左边指定，也可以通过右边指定

　　④：将元祖应用于方法中返回值，即一个方法可以返回多种不同类型的值，不需要封装实体即可以实现。

        /// <summary>
        /// 默认元组命名
        /// </summary>
        /// <returns></returns>
        public (int, string, string) TupleWay1()
        {
            return (1, "ypf1", "ypf2");
        }
        /// <summary>
        /// 指定元祖命名
        /// </summary>
        /// <returns></returns>
        public (int m, string n, string k) TupleWay2()
        {
            return (1, "ypf1", "ypf2");
        }
           {
                Console.WriteLine("--------------------2-元组(Tuples)------------------------");
                //1. 创建元组的三种形式
                Console.WriteLine("--------------------1. 创建元组的三种形式------------------------");
                var tuple1 = (1, 2);   //语法糖
                var tuple2 = ValueTuple.Create("ypf", "lmr");  //Create静态方法
                var tuple3 = new ValueTuple<int, string>(12, "ypf12");  //构造函数
                Console.WriteLine($"tuple1的两个值为：{tuple1.Item1}和{tuple1.Item2}");
                Console.WriteLine($"tuple1的两个值为：{tuple2.Item1}和{tuple2.Item2}");
                Console.WriteLine($"tuple1的两个值为：{tuple3.Item1}和{tuple3.Item2}");

                //2. 指定元祖命名
                Console.WriteLine("--------------------2. 指定元祖命名------------------------");
                (int m, string n) tuple4 = (100, "erp");  //左边命名
                Console.WriteLine($"tuple4的两个值为：{tuple4.m}和{tuple4.n}");
                var tuple5 = (one: 250, two: "spz");     //右边命名
                Console.WriteLine($"tuple5的两个值为：{tuple5.one}和{tuple5.two}");

                //3. 元祖应用于方法中返回值
                Console.WriteLine("--------------------3. 元祖应用于方法中返回值------------------------");
                SevenEdition s = new SevenEdition();
                //默认命名
                var result1 = s.TupleWay1();
                Console.WriteLine($"返回值有：{result1.Item1}、{result1.Item2}、{result1.Item3}");
                //指定命名
                var result2 = s.TupleWay2();
                Console.WriteLine($"返回值有：{result2.m}、{result2.n}、{result2.k}");

            }

3. 局部函数

　　即在{}中声明一个函数，只有{}中能使用

  {
                Console.WriteLine("--------------------3-局部函数------------------------");
                DoSome();
                void DoSome()
                {
                    Console.WriteLine("我是局部函数");
                }
  }

4. 模式的比较和匹配

　　①：is的新模式。

　　　　首先补充一个概念：拆箱和装箱

　　　　拆箱是将引用类型→值类型 （object ，class均为引用类型）

　　　　装箱是将值类型→引用类型

　　案例：有一个object类型的变量a，如果它是int类型，则+10赋值给m，并输出m的值，下面看新老用法比较。

 {
                    Console.WriteLine("--------------------4-模式比较(is)------------------------");
                    object a = 9;
                    //老写法
                    if (a is int)
                    {
                        int b = (int)a;  //拆箱
                        int c = b + 10;
                        Console.WriteLine($"老写法c的值为：{c}");
                    }
                    //新写法
                    if (a is int m)   //这里的a直接拆箱为m
                    {
                        int c = m + 10;
                        Console.WriteLine($"新写法c的值为：{c}");
                    }
}

　　②：switch-case中可以自定义参数类型

　　传统情况，所有的case中必须是同类型的；而在C# 7.0 新版本中，case中可以不同类型，即Swich中可以传入任何类型，然后通过case中进行对应匹配，这就叫做模式匹配。

 /// <summary>
        /// 单一类型
        /// </summary>
        /// <param name="m"></param>
        /// <returns></returns>
        public dynamic SwitchWay1(string m)
        {
            dynamic data;
            switch (m)
            {
                case "ypf1":
                    data = m + "lmr1";
                    break;
                case "ypf2":
                    data = m + "lmr2";
                    break;
                default:
                    data = "spz00000";
                    break;
            }
            return data;
        }

        /// <summary>
        /// 多种类型
        /// </summary>
        /// <param name="m"></param>
        /// <returns></returns>
        public dynamic SwitchWay2(object m)
        {
            dynamic data;
            switch (m)
            {
                case int a when a > 10:
                    data = a + 10;
                    break;
                case int b:
                    data = b + 100;
                    break;
                case String c:
                    data = c + "mmmmmmmmmmmmmmm";
                    break;
                default:
                    data = "spz00000";
                    break;
            }
            return data;
        }

   {
                    Console.WriteLine("--------------------4-模式匹配(switch-case)------------------------");
                    SevenEdition sE = new SevenEdition();
                    //老用法
                    var data1 = sE.SwitchWay1("ypf1");
                    Console.WriteLine($"类型为：{data1.GetType()},值为：{data1}");
                    //新用法
                    var data2 = sE.SwitchWay2(1);
                    Console.WriteLine($"类型为：{data2.GetType()},值为：{data2}");

                    var data3 = sE.SwitchWay2(11);
                    Console.WriteLine($"类型为：{data3.GetType()},值为：{data3}");

                    var data4 = sE.SwitchWay2("ypf1");
                    Console.WriteLine($"类型为：{data4.GetType()},值为：{data4}");

 }

 

5. 数字文本语法的改写

　　 比如10000000 可以写成10_000_000 ,方便识别。

 {
                Console.WriteLine("--------------------5-数字文本语法的改写------------------------");
                long a = 10000000;
                long b = 10_000_000;
                Console.WriteLine($"a的值为：{a}，b的值为：{b}");

 }

6. 补充一些特殊地方也可以写异常表达式 （不详细测试了）

 　　比如：条件表达式（？ ：）、null合并运算符（??）、一些Lambda

　　eg：private string _name = GetName() ?? throw new ArgumentNullException(nameof(GetName));