值得推荐的C#不同版本语言特性

C#语言在不断地版本升级中，为我们提供了很多新的语言特性。其中，有很多使用的语言特性，我觉得在实际开发中用起来很方便，能够简化我们的代码，增强可读性，提高开发效率。

小编不才，在这里给大家整理了一些实际开发中用起来感觉不错的C#语言特性。

C# 3.0
1.类型推断 var
在申明变量的时候，我们可以不用指定类型，var类型会帮我们自动推断出变量类型。简化了变量声明

var num = 1;
var str = "hello";

效果等同于：

int num = 1;
string str = "hello";

注意点：var类型变量不支持赋值为NULL

2.扩展方法

扩展方法必须定义在静态类中，通常用this关键字修饰方法参数（this代表当前调用对象）

    public static class StringStatic
    {
        /// <summary>
        /// 获取首字母
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        public static string StringToFirst(this string s)
        {
            if (string.IsNullOrEmpty(s))
                return "";
            else
                return s.Substring(0, 1);
        }
    }

如上：为string类型的对象添加了获取首字母的扩展类型。

调用：

var str = "hello";
var strFirst = str.StringToFirst();//strFirst="h"

3.lambda表达式

通过lambda表达式，我们可以以一种更为简洁的方式编写函数处理代码，它形同于一个计算表达式，使用 Lambda运算符=>，该运算符读为“goes to”。

语法：

(input parameters) => {
   /*Your statement goes here*/
}

=>运算符左侧为输入参数或者无参数，运算符右侧为表达式体或者语句块，如果是语句块用{}包含。

在LINQ查询中，我们经常使用，比如：

lambda表达式：

//定义list
var list = new List<string>() { "a", "b", "c" };
//使用lambda表达式条件筛选
var str = list.Where(x => x == "a").FirstOrDefault();

lambda语句块：

//定义list
var list = new List<string>() { "a", "b", "c" };
//lambda语句块
list.ForEach(x =>
{
     Console.WriteLine(x);
});

lambda表达式在实际开发中已经应用的比较广泛了，代码简洁，开发效率高。给个五星好评，哈哈

C# 4.0
1.元组Tuple

元组可以当成是一个存储多个不同数据类型数据的的集合。当有多个(不同类型)数据临时存储或者作为方法返回值返回时，List和Dictionary已不能满足需求，这个时候我们又不想单独创建一个实体类用来管理集合，那么Tuple可以成为我们不错的选择。

格式：

Tuple<T1, T2, T3, T4, T5, T6, T7, TRest>

Tuple提供了8个成员，默认情况下1-7成员支持直接使用，每个成员可以是不同数据类型，如果成员有8个或者多于8个时可以通过扩展第8个成员的方式，增加成员数量。

比如：

Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T1,T2,...,TRest>>

创建元组

方式1：new

var tuple1 = new Tuple<int, string, string, string, string, string, string, Tuple<string,string>>(1, "2", "3", "4", "5", "6", "7", new Tuple<string, string>("8","9"));

方式2：Create

var tuple2 =Tuple.Create<int, string, string, string, string, string, string, string>(1, "2","3", "4", "5", "6", "7", "8");

注：这里第8个元素，虽然我们创建的是string类型，实际获取到类型是Tuple<string>,效果等同于：

var tuple2 =Tuple.Create<int, string, string, string, string, string, string, Tuple<string>>(1, "2","3", "4", "5", "6", "7", new Tuple<string>("8"));

元组成员调用

tuple1.Item1
tuple1.Item2
...
tuple1.Item7
tuple1.Rest

通过如上方式，分别获取第1-8成员。实际场景中需要我们使用的时候记住成员的位置。

元组在实际开发中场景应用起来比较方便，不需要我们额外的通过实体进行集合管理。通常用于方法有多个数据返回值的场景。

C# 5.0
1.异步编程（async和await）

在越来越多高并发，高性能的应用场景需求下，异步编程在一定程度上成为解决问题的一个突破口，现在.net core框架已经推荐使用Task+async+await进行异步编程，足以见得它的魅力所在。

之前我专门有个文章讲解过async+await异步编程，感兴趣的同学可以了解下，这里就不展开说了。
C# 6.0
1.NULL条件运算符（?.）

运算符"?."用于判断一个对象是否为空。

比如：

Object?.Tostring() 

Object对象如果不为空，则执行Tostring()方法并返回值；

Object对象如果为空，则直接返回NULL

运算符"?."简化了我们的判空操作，避免了Object为空时使用ToString()报错，效果等同于：

if (Object == null)
        return null;
else
        return Object.ToString();

2.空合并运算符（??）

语法格式如下：

string str = "adc";
var result = str ?? str.ToUpper();

如果??运算符左侧操作数str结果为NULL,则返回??运算符右侧操作数。

如果??运算符左侧操作数str结果不为NULL,则返回??运算符左侧操作数。

（通俗点就是，左侧不为空就返回左侧数据，为空就返回右侧数据）

3.字符串拼接（$）

回想一下我们比较常用的字符串拼接方式。

//+运算符 拼接
string str2 = str1 + "你好";
//字符串格式化拼接
string str3 = string.Format(@"{0}，你好", str1);

+运算符连接的方式，每+一次都会生成一个新的string对象，占用内存；

Format字符串格式化，占位符顺序需谨慎；

而C#6.0给我们带来了新的字符串拼接特性，格式如下:

string str4 = $"{str1},你好";

$操作符标记双引号“”中的字符串；其中，中括号{}可用于动态取值。这种形式更为简单且从语法上也更易被接受。

4.lambda表达升级使用

lambda表达式作为函数体，形如：

        /// <summary>
        /// 没有返回值函数
        /// </summary>
        public void ConsoleLog() => Console.WriteLine("没有返回值函数");
        /// <summary>
        /// 一个简单的有返回值函数
        /// </summary>
        /// <param name="StudentId"></param>
        /// <param name="StandardName"></param>
        /// <returns></returns>
        public Student GetStudent(int StudentId, string StandardName) => new Student { StandardId = StudentId, StudentName = StandardName };

lambda表达式直接作为函数体，这样代码更为高效简洁。

lambda表达式用作属性

public string TimeString => DateTime.Now.ToString("yyyyMMdd");

同样的方式，lambda表达式用作属性赋值也比较简单。

C# 7.0
1.out类型参数

C#7.0版本之前，我们使用out引用类型作为输出参数，必须要先申明，才能使用。如下：

int intValue = 0;
int.TryParse("100", out intValue);

有时候我可能并不关注这个out输出参数，但是确不得不声明一个变量存储它，烦躁。。。幸运的是7.0为我带来了一丝曙光。

我们可以“使用时内联声明”，无需提前单独声明：

int.TryParse("100", out int intValue);

这样是不是感觉一身轻松ღ( ´･ᴗ･` )

2.ValueTuple元组

C#4.0的时候新增了特性元组Tuple，但是用过的同学会觉得有些不足：

1）Tuple 成员的可读性差，只能通过Item1，Item2..坐标式的方式读取成员 。

2）Tuple 是引用类型，大量频繁的使用占内存。

于是C#7.0马上推出了ValueTuple类型元组，很显然它解决了上述两种不足。

1）ValueTuple 支持用名称定义成员。

2）ValueTuple 是值类型。

我们先来看看如何使用ValueTuple

创建的简单ValueTuple

            // 语法糖创建元组
            var tuple1 = (1, 2);
            // Create创建元组
            var tuple2 = ValueTuple.Create(1, 2);
            // new 运算符创建元组
            var tuple3 = new ValueTuple<int, int>(1, 2);

调用成员：这种方式和Tuple的使用基本一样，调用成员也是通过item1,item2...的方式。

创建的指定名称的ValueTuple

            // 左边指定字段名称
            (int first, int second) tuple1 = (1, 2);
            // 右边指定字段名称
            var tuple2 = (first: 1, second: 2);

调用成员：可通过定义的成员名称获取，tuple1.first  / tuple1.second，可读性更高。

C#8.0

1.NULL合并并赋值（??=）

C# 8.0 引入了 null 合并赋值运算符??=，是C#6.0中的空合并运算符（??）的升级

当左操作数计算为 null 时，才能使用运算符 ??= 将其右操作数的值分配给左操作数。

List<int> numbers = null;
int? i = null;

numbers ??= new List<int>();
numbers.Add(i ??= 17);
numbers.Add(i ??= 20);

Console.WriteLine(string.Join(" ", numbers));  // output: 17 17
Console.WriteLine(i);  // output: 17