C#6.0，C#7.0新特性

https://www.cnblogs.com/1175429393wljblog/p/9598864.html

 

 

C#6.0新特性

---

Auto-Property enhancements(自动属性增强)

Read-only auto-properties （真正的只读属性）

// 以前
// 只是限制了属性在类外部只读，而在类内部任何地方都可设置
public string Name { get; private set; } public void SetName(string name) { Name = name; } // c#6.0 // 1.通过只使用一个getter来声明真正只读 // 2.这样的属性，只能在构造器中初始化(含属性声明时)，而类内部其他地方也不可再设置 public string Name { get; } = "小米喂大象"; // 允许 public User(string Name, string password, int age) { Name = name; // 允许 Password = password; Age = age; } public void SetName(string name) { Name = name; // 报错 }

Auto-Property Initializers （自动属性的初始化）

// 以前
// 需要属性有setter，通过setter来初始化backing field
public string Name { get; set; } public User(string name) { Name = "小米喂大象"; } // C#6.0 // 可以在属性声明的同时初始化 public string Name { get; } = "小米喂大象"; public int Age { get; set; } = 18;

Expression-bodied function members （表达式方法体）

// C#6.0
// 1. 类成员方法体是一句话的，都可以改成使用表达式，使用Lambda箭头来表达
// 2. 只适用于只读属性和方法 public string Name => "小米喂大象"; // 只读属性 public void SetAge(int age) => Age = age; // 方法 public void Log(string msg) => System.Console.WriteLine($"{Name} : {msg}");

using static （导入类静态方法）

// c#6.0
// 1.使用using static 语法，可以将一个类中的所有静态方法导入到当前上下文，
// 包括这个类中的嵌套类型，不包括实例方法，也不包括const字段 // 2.这样引用这个类的方法，就可以直接引用，而不用再加前缀（形似C函数）。 using static System.Math; using static System.String; public Double Calc(int angle) { var tmp = Sin(angle) + Cos(ange); ... }

Null-conditional operators （一元空值检查操作符?.）

// 以前
// 一个引用的null检查和使用是分开的
User user;
. . .
if (user != null) { user.SetAge(19); } // C#6.0 // 1. 直接使用?.代替.操作符即可 // 2. ?.操作符确保其左边表达式只计算一次 // 2. 如果引用是null，这直接返回类型匹配的null， 下面的name被推断为string? user?.SetAge(19); var name = user?.Name;

String Interpolation （字符串插值）

// 以前
public override string ToString() { return string.Format("{0}:{1:D2}", Name, Age); } // C#6.0 // 1. 使用$开头，花括号里直接放入表达式 // 2. 格式化字符串，可直接在花括号里表达式后面加上:，然后加上格式化字符串 // 3. 插值表达式里可以嵌套插值表达式 public override string ToString() { return $"{Name}:{Age:D2}"; }

nameof Expressions （nameof 表达式）

// C#6.0
// 1. nameof表达式返回一个变量、属性或字段的名称
// 2. 当需要一个符号的名称时很有用，一可以避免手工打错，二可以便于重构 // 3. 如果是一个限定了前缀的完整名称，如nameof(User.Age), // nameof操作符也只是返回"Age"，而不是"User.Age" public string Name { get => name; set { name = value; PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Name))); } } public int Age { get => age; set { age = value; PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(User.Age))); } }

Index Initializers（索引初始化器）

// c#6.0
// 允许使用[]操作符来初始化，这样字典可以像其他序列容器一样的语法初始化了
public Dictionary<string, User> Users = new Dictionary<string, User> { ['小米喂大象'] = new User(), ['Jack'] = new User(), }

Exception Filters (异常过滤器)

// C#6.0
// 1. catch字句后面可以带一个 when表达式（早期是if，后被when替换） // 2. 如果when括号内表达式(下面代码?部分)为真则Catch块就执行，否则不执行 // 3. 利用这个表达式可以做很多事，包括过滤指定异常、调试、打印日志等。 try { } catch (Excepation e) when (?) { }

Await in Catch and Finally blocks （Catch,Finally语句块中可用await）

// C#6.0
// 1. C#5.0中添加了async、await, 但是在哪里放await表达式，这个有一些限制
// 2. C#6.0中解决了这些限制中的其中一个，就是await可以放在catch、finally语句块中了。 try { var result = await SomeTask; return result; } catch (Exception e) { await Log(e); } finally { await Cleanup(); }

Extension Add methods in collection initializers （在集合初始化器中使用扩展的Add方法）

// c#6.0
public class User { public string Name { get; set; } public int Age { get; set; } public User(string name, int age) { Name = name; Age = age; } } public class ActiveUsers : IEnumerable<User> { List<User> users = new List<User>(); //public void Add(User user) { // users.Add(user); //} public void Append(User user) { users.Add(user); } public IEnumerator<User> GetEnumerator() { throw new NotImplementedException(); } IEnumerator IEnumerable.GetEnumerator() { throw new NotImplementedException(); } } // 添加一个扩展的静态方法Add public static class ActiveUsersExtensions { public static void Add(this ActiveUsers users, User u) => users.Append(u); } public class Test { // 1. 为了能够像下面这样使用集合初始化器，ActiveUsers必须拥有一个Add()方法 // 2. 现在，如果ActiveUsers 类只有一个Append()方法，没有Add()方法，而你也 // 无法修改这个类，这时候下面的代码就无法工作了。 // 3. C#6.0中允许你添加一个扩展的静态方法Add来完成工作。 ActiveUsers users = new ActiveUsers { new User("xm01", 18), new User("xm02", 19), new User("xm03", 20), }; }

Improved overload resolution （改进的重载解析）

// C#6.0
// 1. 下面代码，C#6.0以前，当编译器看到Foo(Bar)，会去匹配一个最合适的方法，但是，
// 编译器最终会报告失败。因为编译器在匹配函数签名的时候，并没有将函数返回值作为 // 一部分，所以编译器不能明确该调用哪个Foo方法。 // 2. 同样，C#6.0以前，编译器不能区分Task.Run(Action)和Task.Run(Func<Task>()) // 3. C#6.0解决了此问题 int Bar() { return 1; } void Foo(Action f) { } void Foo(Func<int> f) { } void Main() { Foo(Bar); }

C#7.0新特性

---

out variables （out 变量）

// 以前
// out变量的声明和初始化是分开的
int age; if (int.TryParse("18", out age)) { Console.WriteLine("age: " + age); } // C#7.0 // 1. C#7.0允许直接在方法的调用列表中声明一个out变量 // 2. 这个变量可以声明成var这种隐式类型 // 3. 这个变量的作用域范围伸展到if语句块的外部范围 if (int.TryParse("18", out int age)) { Console.WriteLine("age: " + age); } if (int.TryParse("90", out var score)) { // 隐式类型也可以用 Console.WriteLine("score: " + score); } age += 1; // 这时候age仍然有效

Tuples （元组）

// c#7.0
// 1. C#7.0以前就已经有tuple, 但不是语言层面支持的，而且使用起来没效率
// 2. C#7.0中使用tuple，需要引入 System.ValueTuple（如果平台不包含的话） // 3. 元组成员名可指定，不指定默认Item1,Item2,... // 4. 元组是值类型，其元素是公开字段，可修改 // 5. 元组中元素都相等，则元组相等 // 6. 元组可用于函数返回多个独立变量，这样不用定义一个struct或class // 7. 元组使用场合： // 元组成员名默认Item1, Item2 var name = ("Jack", "Ma"); (string, string) name1 = ("Jack", "Ma"); // 指定成员名称为firstName, lastName (string firstName, string lastName) name2 = ("Jack", "Ma"); // 指定成员名称为f, l var name3 = (f: "Jack", l: "Ma"); // 左右同时指定成员名称，右边的忽略 (string firstName, string lastName) name4 = (f: "Jack", l: "Ma"); // 返回一个元组 private (string FirstName, string LastName) GetName() { return ("Jack", "Ma"); } var name5 = GetName(); name5.FirstName = "Jack2"; name5.LastName = "Ma2"; // 析构元组成员到变量firstName, lastName (string firstName, string lastName) = GetName(); firstName = "Jack2"; lastName = "Ma2"; // 析构元组成员到变量f, l (string f, string l) = name5; f = "Jack2"; l = "Ma2"; // 析构元组成员到变量f2, l2 var (f2, l2) = name5;

Discards （占位符）

// C#7.0
// 1. 增加一个占位符_(下划线字符)来表示一个只写的变量，这个变量只能写，不能读。
// 当想丢弃一个值的时候，可以使用。 // 2. 他不是实际变量，没有实际存储空间，所以可以多处使用。 // 3. 一般用于解构元组、调用带out参数的方法、模式匹配，例如: // > 调用一个方法，这个方法带有一个out参数，你根本不使用也不关心这个参数； // > 一个包含多个字段的元组，你只关心其中部分成员，不关心的成员可以使用占位符； // > 模式匹配中, _可以匹配任意表达式； // 4. 注意：_也是一个有效的变量标识符，在合理的情景下，_也会作为一个有效变量 private (string FirstName, string LastName) GetName() { return ("Jack", "Ma"); } private void GetName(out string FirstName, out string LastName) { FirstName = "Jack"; LastName = "Ma"; } // 只关心FirstName， LastName丢弃 var(firstName, _) = GetName(); GetName(out var firstName2, out _); // 有效变量_ public void Work(int _) { _ += 4; }

Pattern matching （模式匹配）

// C#7.0
// 模式匹配：匹配一个值是否具有某种特征（例如：是否是某个常量、某个类型、某个变量），
// 如果是，顺便可将这个值提取到对应特征的新变量中 // C#7.0中，利用已有的关键字is和switch来扩展，实现模式匹配 // 具有模式匹配的is表达式：不仅能匹配类型，还能匹配表达式 public static void TestIs(object o) { const string IP = "127.0.0.1"; // 匹配常量 if (o is IP) { Console.WriteLine("o is IP"); } if (o is null) { Console.WriteLine("o is null"); } // 匹配类型 if (o is float) { Console.WriteLine($"o is float"); } // 匹配类型，并提取值。检测为true，这时候i会被明确赋值 if (o is int i) { Console.WriteLine($"o is int {i}"); } else { return; } // i仍然有效 // i变量称为模式变量，和out变量一样，统称为表达式变量，作用域都扩展到了外围 // 表达式变量的范围扩展到了外围，只有在前面的模式匹配为true是才有效 // 表达式变量为true时，才给变量明确赋值，这样避免了模式不匹配时访问这些变量 i++; Console.WriteLine($"i is {i}"); if (o is 4 * 4) { Console.WriteLine("o is 4*4"); } } // 可以模式匹配的switch // 1. 原来的switch限制为仅仅是string和数字类型的常量匹配，现在解除了 // 2. switch按照文本顺序匹配，所以需要注意顺序； // （原来switch的分支只匹配一个所以不需要顺序；而现在可以匹配多个，行为变了） // 3. case子句后面可以带模式匹配的表达式 // 4. default最后执行，也就是其他都不匹配时才执行，不管default语句放在什么位置。 // 5. 如没有default分支，其他也不匹配，则不执行任何switch块代码，直接执行其后面代码 // 6. case后带var形式变量的匹配，近似于default // 7. case 子句引入的模式变量只在switch块内有效 public static void TestSwitch(object o) { switch (o) { case "127.0.0.1": Console.WriteLine("o is IP"); break; case float f: Console.WriteLine($"o is float {f}"); break; case int i when i == 4: Console.WriteLine($"o is int {i} == 4"); break; case int i: Console.WriteLine($"o is int {i}"); break; case string s when s.Contains("127"): Console.WriteLine("o is string, contains 127 "); break; case string s when s.Contains("abc"): Console.WriteLine("o is string, contains 127 "); break; case var a when a.ToString().Length == 0: Console.WriteLine($"{a} : a.ToString().Length == 0"); break; case null: Console.WriteLine($"o is null"); break; default: Console.WriteLine("default"); break; } }

Ref locals and returns （ref局部变量和返回ref变量）

// C#7.0
// C#7.0以前的ref只能用于函数参数，现在可以用于本地引用和作为引用返回
// 1. 需要添加关键字ref，定义引用时需要，返回引用时也需要 // 2. 引用声明和初始化必须在一起，不能拆分 // 3. 引用一旦声明，就不可修改，不可重新再定向 // 4. 函数无法返回超越其作用域的引用 // 需要添加关键字ref，表示函数返回一个ref int public static ref int GetLast(int[] a) { if (a == null || a.Length < 1) { throw new Exception(""); } int number = 18; // 错误声明: 引用申明和初始化分开是错误的 //ref int n1; //n1 = number; // 正确声明: 申明引用时必须初始化，声明和初始化在一起 // 添加关键字ref表示n1是一个引用, ref int n1 = ref number; // n1指向number，不论修改n1或number，对双方都有影响，相当于双方绑定了。 n1 = 19; Console.WriteLine($"n1:{n1}, number:{number}"); number = 20; Console.WriteLine($"n1:{n1}, number:{number}"); // 语法错误，引用不可被重定向到另一个引用 //n1 = ref a[2]; // 语法正确，但本质是将a[2]的值赋值给n1引用所指，n1仍指向number n1 = a[2]; Console.WriteLine($"n1:{n1}, number:{number}, a[2]:{a[2]}"); number = 21; Console.WriteLine($"n1:{n1}, number:{number}, a[2]:{a[2]}"); // --------------------- 引用返回 ------------------------ // 错误：n1引用number，但number生存期限于方法内，故不可返回 // return ref n1; // 正确：n2引用a[2]，a[2]生存期不仅仅限于方法内，所以可以返回。 ref int n2 = ref a[a.Length-1]; return ref n2; // 需要ref返回一个引用 return ref a[a.Length-1]; // 也可以直接返回一个引用 } public static void Main(string[] args) { int[] a = { 0, 1, 2, 3, 4, 5}; // x不是一个引用，函数将值赋值给左侧变量x int x = GetLast(a); Console.WriteLine($"x:{x}, a[2]:{a[a.Length-1]}"); x = 99; Console.WriteLine($"x:{x}, a[2]:{a[a.Length-1]} \n"); // 返回引用，需要使用ref关键字，y是一个引用，指向a[a.Lenght-1] ref int y = ref GetLast(a); Console.WriteLine($"y:{y}, a[2]:{a[a.Length-1]}"); y = 100; Console.WriteLine($"y:{y}, a[2]:{a[a.Length-1]}"); Console.ReadKey(); }

Local functions （本地方法）

// C#7.0
// 1. 定义在一个方法体内的函数，称为本地方法
// 2. 本地方法只在其外部方法体内有效 // 3. 本地方法可定义在其外部方法的任何地方 // 4. 外部方法其作用域内参数或变量，都可用于本地方法 // 5. 本地方法实质被编译为当前类的一个私有成员方法， // 但被语言层级限制为只能在其外部方法内使用 // 6. 由于(5)，所以本地方法和类方法一样，没有特殊限制，异步、泛型、Lambda等都可用 // 7. 常见用例：给迭代器方法和异步方法提供参数检查，因为这两类方法报告错误比较晚 public static IEnumerable<int> SubsetOfIntArray(int start, int end) { if (start < end) { throw new ArgumentException($"start({start}) < end({end})"); } return Subset(); IEnumerable<int> Subset() { for (var i = start; i < end; i++) yield return i; } }

More expression-bodied members（更多的 表达式方法体 成员）

// C#7.0
// 1. 类成员方法体是一句话的，都可以改成使用表达式，使用Lambda箭头来表达
// 2. C#6.0中，这种写法只适用于只读属性和方法 // 3. C#7.0中，这种写法可以用于更多类成员，包括构造函数、析构函数、属性访问器等 public string Name => "小米喂大象"; //只读属性 public void SetAge(int age) => Age = age; //方法 public void Log(string msg) => System.Console.WriteLine($"{Name} : {msg}"); public void Init(string name, string password, int age) { Name = name; Password = password; Age = age; } public User(string name) => Init(name, "", 18); //构造函数 public User(string name, string password) => Init(name, password, 18); public ~User() => System.Console.WriteLine("Finalized"); //析构函数（仅示例） public string password; public int Password{ //属性访问器 get => password; set => SetPassword(value); }

Throw expressions （异常表达式）

// C#7.0
// 1. c#7.0以前，throw是一个语句，因为是语句，所以在某些场合不能使用。
// 包括条件表达式、空合并表达式、Lambda表达式等。 // 2. C#7.0可以使用了, 语法不变，但是可以放置在更多的位置 public string Name { get => name; set => name = value ?? throw new ArgumentNullException("Name must not be null"); }

Generalized async return types（更泛化的异步返回类型）

// C#7.0
// 1. 7.0以前异步方法只能返回void、Task、Task<T>，现在允许定义其他类型来返回
// 2. 主要使用情景：从异步方法返回Task引用，需要分配对象，某些情况下会导致性能问题。 // 遇到对性能敏感问题的时候，可以考虑使用ValueTask<T>替换Task<T>。

Numeric literal syntax improvements（数值字面量语法改进）

// C#7.0
// c#7.0为了增加数字的可读性，增加了两个新特性：二进制字面量(ob开头)、数字分隔符(_)
int b = 123_456_789; // 作为千单位分隔符 int c = 0b10101010; // 增加了表示二进制的字面量, 以0b开头 int d = 0b1011_1010; // 二进制字面量里加入数字分割符号_ float e = 3.1415_926f; // 其他包括float、double、decimal同样可以使用 double f = 1.345_234_322_333_567_222_777d; decimal g = 1.618_033_988_749_894_586_834_365_638_117_720_309_179M; long h = 0xff_42_90_b8; // 在十六进制中使用

---

C#7.1新特性

C#7.1是c#的第一个带小数点的版本，意味着快速迭代与发布 
一般需要在编译器里设置语言版本才能使用

Async main （异步Main方法）

// C#7.0中async不能用于main方法，7.1可以

// 以前
static int Main() { return DoAsyncWork().GetAwaiter().GetResult(); } // 现在 static async Task<int> Main() { return await DoAsyncWork(); } static async Task Main() { // 没有返回 await SomeAsyncMethod(); }

Default literal expressions （default字面量表达式）

// 1. C#7.1以前给一个变量设置缺省值，需要使用default(T), C#7.1因为可以推断表达式
//    的类型，所以可以直接使用default字面量，编译器推断出与default(T)一样的值
// 2. default字面量可用于以下任意位置： // 变量初始值设定项 // 变量赋值 // 声明可选参数的默认值 // 为方法调用参数提供值 // 返回语句 // expression in an expression bodied member // （使用表达式方法体的成员中的表达式） public class User { public string Name { get; set; } = default; public int Age { get; set; } = default; public int Score => default; } public static int Test(string name, int age, int score = default) { // 以前 string s1 = default(string); var s2 = default(string); int i = default(int); User u = default(User); // 现在 string s3 = default; string s4 = "hello"; s4 = default; return default; } Test(default, default);

Inferred tuple element names（tuple元素名可推导）

// c#7.0引入tuple，7.1增强了tuple中元素的命名，可通过推导来完成tuple中元素的命名
// 使用变量来初始化tuple时，可以使用变量名给tuple中元素命名
var name = "xm01"; var age = 18; var p = (name:name, age:18); // 以前，显式命名 var p2 = (name, age); // 现在，可以推导来命名 p2.age = 19;

Reference assembly generation

编译器添加了两个新的选项用于控制引用程序集的生成：-refout 和 -refonly 
一个表示只引用，一个表示需要输出引用(故需要指定路径)

---

C#7.2

Reference semantics with value types（只读引用）

1. 使用值类型变量时，通过可避免堆分配，但需要进行一次复制操作；
2. 为了取得折中效果， C#7.2提供了一个机制：似值类型不可被修改，但按引用传递。

// 这几种情况可以：
// 1. in修饰符修饰的参数，不可被调用的方法修改；
// 2. ref readonly方式返回一个值，不能被修改； // 3. readonly struct声明一个结构，可以作为in参数传递 // 4. ref struct 声明一个结构，指示直接访问托管内存，始终分配有堆栈。

 

Non-trailing named arguments（命名参数不需要在最后）

1. C#7.2以前，命名参数后面不能再跟位置参数
2. C#7.2以后，只要命名参数位置正确，可以和位置参数混用
3. 这样做的目的是： 使用名字参数的调用，一眼可以看出来这个参数的含义， 
   例如参数是一个boolean型的参数，写代码时直接传true，根本看不出什么含义，这时候写上名字可以明确调用接口

Leading underscores in numeric literals（数字字面量的前导分隔符）

// 1. C#7.0中提供了下划线来分割数字字面量，以提高可读性，
//    但是 下划线分割符(_) 不可作为字面量的第一个字符。
// 2. c#7.2中允许十六进制字面量和二进制字面量以_开头 // 以前 int x = 0b1011_1010; long y = 0xff_42_90_b8; // 现在 int x = 0b_1011_1010; long y = 0x_ff_42_90_b8;

private protected access modifier （private protected 访问修饰符）

1. C#7.2添加了一个private protected 访问修饰符
2. 表示： 
   1）只有自己访问； 
   2）派生类也可以访问，但仅限于在同一个程序集的派生类

原文链接：https://blog.csdn.net/wsh31415926/article/details/79907545

龙腾一族至尊龙骑

转载于:https://www.cnblogs.com/kelelipeng/p/10514979.html