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

一. C# 6.0 新语法

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

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

         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 = ;
                 Console.WriteLine(iValue?.ToString());//不需要判断是否为空
                 string name = null;
                 Console.WriteLine(name?.ToString());
 }

5. 对象初始化

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

  {
                 Console.WriteLine($"-------------------------5. 字典对象初始化-------------------------");
                 Dictionary<string, string> dicList = new Dictionary<string, string>()
                 {
                     [""] = "ypf1",
                     [""] = "ypf2",
                     [""] = "ypf3"
                 };
                 Dictionary<string, string> dicList2 = new Dictionary<string, string>()
                  {
                      { "","lmr1"},
                      { "","lmr2"},
                      { "","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 = ;
                 try
                 {
                     int.Parse("ypf");
                 }
                 catch (Exception e) when (epCheck > )
                 {
                     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; } = "";

        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 = ;
             y = ;
         }
         {
             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 (, "ypf1", "ypf2");
         }
         /// <summary>
         /// 指定元祖命名
         /// </summary>
         /// <returns></returns>
         public (int m, string n, string k) TupleWay2()
         {
             return (, "ypf1", "ypf2");
         }
            {
                 Console.WriteLine("--------------------2-元组(Tuples)------------------------");
                 //1. 创建元组的三种形式
                 Console.WriteLine("--------------------1. 创建元组的三种形式------------------------");
                 var tuple1 = (, );   //语法糖
                 var tuple2 = ValueTuple.Create("ypf", "lmr");  //Create静态方法
                 var tuple3 = new ValueTuple<int, string>(, "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 = (, "erp");  //左边命名
                 Console.WriteLine($"tuple4的两个值为：{tuple4.m}和{tuple4.n}");
                 var tuple5 = (one: , 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 = ;
                     //老写法
                     if (a is int)
                     {
                         int b = (int)a;  //拆箱
                         int c = b + ;
                         Console.WriteLine($"老写法c的值为：{c}");
                     }
                     //新写法
                     if (a is int m)   //这里的a直接拆箱为m
                     {
                         int c = m + ;
                         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 > :
                     data = a + ;
                     break;
                 case int b:
                     data = b + ;
                     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();
                     Console.WriteLine($"类型为：{data2.GetType()},值为：{data2}");

                     var data3 = sE.SwitchWay2();
                     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 = ;
                long b = 10_000_000;
                Console.WriteLine($"a的值为：{a}，b的值为：{b}");

 }

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

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

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