探索C#之6.0语法糖剖析

阅读目录：

  1. 自动属性默认初始化
  2. 自动只读属性默认初始化
  3. 表达式为主体的函数
  4. 表达式为主体的属性(赋值)
  5. 静态类导入
  6. Null条件运算符
  7. 字符串格式化
  8. 索引初始化
  9. 异常过滤器when
  10. catch和finally代码块内的Await
  11. nameof表达式
  12. 扩展方法
  13. 总结

自动属性默认初始化

使用方法:

public string Name { get; set; } = "hello world";

为了便于理解使用2.0语法展示，编译器生成代码如下：

 public class Customer
{
 [CompilerGenerated]
private string kBackingField = "hello world";
public Customer()
{
this.kBackingField = "hello world";
}

public string Name
{
    [CompilerGenerated]
    get
    {
        return this.<Name>k__BackingField;
    }
    [CompilerGenerated]
    set
    {
        this.<Name>k__BackingField = value;
    }
}
} 

从生成代码中可以看出编译器是在实例构造函数时，初始化属性信息的。

自动只读属性默认初始化

使用方法:

public string Name1 { get; } = "hello world";

编译器生成代码如下：

[CompilerGenerated]
private readonly string kBackingField;
public Customer()
{
 this.kBackingField = "hello world";
 }
public string Name1
{
 [CompilerGenerated]
get { return this.k__BackingField; }
 }

由于初始化默认值实在构造函数中赋值的，所以跟属性只读没关系。

表达式为主体的函数

使用方法:

Body Get(int x, int y) => new Body(1 + x, 2 + y);

编译器生成如下：

private Program.Body Get(int x, int y)
{
    return new Program.Body(1 + x, 2 + y);
}

简化了单行方法的编写，省去写大括号的功夫。

同时支持没有返回值的写法：

void OutPut(int x, int y) => Console.WriteLine("hello world");

也支持异步函数的编写：

async void OutPut(int x, int y) => await new Task(() => Console.WriteLine("hello wolrd"));

表达式为主体的属性(赋值)

使用方法:

public string Name2 => "hello world";

编译器生成代码如下：

public string Name2
{
get { return "mushroomsir"; }
 }

编译器只生成了个只读属性。

静态类导入

这个特性可以一次性导入某类型的所有静态成员，使静态成员在后面的代码中没有类型限制直接使用，像使用本类型下面的静态方法一样。

using static System.Console;
 class Program {
static void Main(string[] args)
{
 WriteLine("hello wolrd");
}
}

编译器生成代码如下：

private static void Main(string[] args)
 {
 Console.WriteLine("hello wolrd");
}

省去了类型名称的重复编写。

Null条件运算符

使用方法:

Customer customer = new Customer(); string name3 = customer?.Name;

等同于：

Customer customer = new Customer();
if (customer1 != null)
{
    string name = customer1.Name;
}

可以和??组合起来使用：

if (customer?.Face2()??false)

还可以2个一起用：

int? Length = customer?.Name?.Length;

也可以方法调用：

customer?.Face();

这个语法糖的目的是在使用前检查是否为null。如果返回为空，变量则为空，所以需要一个可以为空的int类型、即int？。

字符串格式化

String.Format有些不方便的地方：必须输入"String.Format"，使用{0}占位符、必须顺序来格式化、这点容易出错。

var s = String.Format("{0} is {1} year {{s}} old", p.Name, p.Age);

新的语法糖使用起来相对更轻松些：

var s = $"{p.Name} is {p.Age} year{{s}} old";

编译器生成如下，和之前没有区别：

var s = String.Format("{0} is {1} year{{s}} old", p.Name, p.Age);

有趣的是，新格式化方式还支持任何表达式的直接赋值：

var s = $"{p.Name} is {p.Age} year{(p.Age == 1 ? "" : "s")} old";

索引初始化

使用方法：

var numbers = new List { [7] = "seven", [9] = "nine", [13] = "thirteen" };

编译器生成代码如下：

List list = new List();
list[7] = "seven";
 list[9] = "nine";
list[13] = "thirteen";

异常过滤器when

使用方法：

 try
{
throw new ArgumentException("string error");
 }
 catch (ArgumentException e) when (myfilter(e))
 {
Console.WriteLine(e.Message);
 }

static bool myfilter(ArgumentException e)
 {
return false;
 }

这个语法糖作用是：在进入到catch之前、验证when括号里myfilter方法返回的bool，如果返回true继续运行，false不走catch直接抛出异常。

使用这个filter可以更好的判断一个错误是继续处理还是重新抛出去。按照以前的做法，在catch块内如需再次抛出去，需要重新throw出去，这时的错误源是吃掉后在抛的，而不是原先的，有了when语法

糖，可以直接定位错误源。

catch和finally代码块内的Await

Await异步处理是在c#5.0提出的，但不能在catch和finally代码块内使用，这次C#6.0更新上支持了。

使用方法：

    async void Solve()
    {
        try
        {
            await HttpMethodAsync();
        }
        catch (ArgumentException e)
        {
            await HttpMethodAsync();
        }
        finally
        {
            await HttpMethodAsync();
        }
    }

编译器把catch和finally的await生成到状态机里面的MoveNext()里面。原来里面只有 TaskAwaiter，现在多了2个。状态机里面的代码和原先的一样，只是更复杂了下，有兴趣的童鞋可以先看下Async、Await剖析再去深究。

nameof表达式

使用方法：

string name = "";
Console.WriteLine(nameof(name));

控制台输出 "name"。

有时候会需要程序中一些成员的字符串名称，比如抛出ArgumentNullException异常的时候，想知道ArgumentNullException类型的字符串名称，这时候就可以用nameof获取字符

串“ArgumentNullException”。现在做法都是手动复制一下，但重构改名的时候容易忘记变更字符串，使用nameof就可以避免了。

当如下使用的时候，编译器会只取最后的ZipCode。

nameof(person.Address.ZipCode)

编译器生成如下代码：

Console.WriteLine("name");

扩展方法

    using static System.Linq.Enumerable; //引入类型，而不是命名空间
    class Program
    {
        static void Main()
        {
            var range = Range(5, 17);                // Ok: 不是扩展方法
            var odd = Where(range, i => i % 2 == 1); // Error, 不在全局作用域里
            var even = range.Where(i => i % 2 == 0); // Ok
        }
    }

首先Enumerable是个静态类，里面是各种扩展方法，比如range。static的作用是把类型的静态成员一次性导入，rang虽然是静态方法，但不能导入，比如where。

因为扩展方法是作用域在实例成员上的(扩展方法第一个this实例参数)，不能把直接作用域到全局里面，所以var odd = Where(range, i => i % 2 == 1)是错误的。

但是static却能把类型的扩展方法作为扩展方法本身角色功能导入进去，所以var even = range.Where(i => i % 2 == 0)是ok的。

这里可能稍微有点绕，lz尽量写清楚，static新用法有2个功能：

  1. 把静态成员导入，但扩展方法比较特殊、排除在外。这时static是c# 6.0的新功能。
  2. 等同于把扩展方法的命名空间导入，所以在集合上可以打点可以调扩展方法。这是之前就有的功能，而不是把扩展方法转成成单纯的静态方法导入使用。

总结

看到园子里有介绍的文章，一时来兴趣了，下班后安装个社区版就研究分享下。 虽然微软一直出新东西，但都是由下至上迭代的，所以学习起来是非常快的。

参考https://github.com/dotnet/roslyn/wiki/New-Language-Features-in-C%23-6#expression-bodied-function-members

时间： 2024-10-08 18:44:34

探索C#之6.0语法糖剖析的相关文章

C#6.0语法糖剖析

1.自动属性默认初始化 使用代码 public string Id { get; set; } = "001"; 编译器生成的代码: public class Customer { [CompilerGenerated] private string kBackingField = "hello world"; public Customer() { this.kBackingField = "hello world"; } public str

C#4.0语法糖之第一篇:自动属性&amp;隐式类型

今天给大家分享一下C#语法糖的简单的两个知识点吧. 自动属性:在 C# 4.0 和更高版本中,当属性的访问器中不需要其他逻辑时,自动实现的属性可使属性声明更加简洁. 客户端代码还可通过这些属性创建对象. get and set accessors." id="mt3">如下面的示例所示声明属性时,编译器将创建一个私有的匿名支持字段,该字段只能通过属性的 get 和 set 访问器进行访问. 我们C#4.0以前的传统方式的属性是用来封装字段的,这里我简单的对比一下这两种方

C#4.0语法糖之第五篇: 匿名类 &amp; 匿名方法

今天时间有点早,所以上来在写一篇文章吧,继续上一篇的文章,在我们平时编程过程中有没有遇到过这样的一个情景,你定义的类只是用来封装一些相关的数据,但并不需要相关联的方法.事件和其他自定义的功能.同时,这个类仅仅在当前的应用程序中使用,而不需要在项目间重用.你所需要的只是一个“临时的”类型,现在我们来看看这个传统类的定义: 1 internal class oneClass 2  3 { 4  5      //定义若干私有数据成员 6  7      //通过属性来封装每个数据成员 8  9   

C#4.0语法糖之第三篇: 参数默认值和命名参数 对象初始化器与集合初始化器

今天继续写上一篇文章C#4.0语法糖之第二篇,在开始今天的文章之前感谢各位园友的支持,通过昨天写的文章,今天有很多园友们也提出了文章中的一些不足,再次感谢这些关心我的园友,在以后些文章的过程中不断的完善以及自我提高,给各位园友们带来更好,更高效的文章. 废话就说到这里,下面正式进入我们的今天的C#4.0语法糖,今天给大家分享一下参数默认值.命名参数.对象初始化器和集合初始化器. 参数默认值和命名参数:方法的可选参数是.net 4.0最新提出的新的功能,对应简单的重载可以使用可选参数和命名参数混合

C#4.0语法糖之第四篇: 扩展方法

今天继续分享C#4.0语法糖的扩展方法,这个方法也是我本人比较喜欢的方法.大家先想想比如我们以前写的原始类型不能满足现在的需求,而需要在该类型中添加新的方法来实现时大家会怎么做.我先说一下我没有学习到这个知识点之前做的方法: 最笨的办法就是修改原来的类型,然后添加一个方法来达到需求的变更,如下代码所示: 1 public class KuozFF 2 3 { 4 5 public void NormalMethod() 6 7 { 8 9 Console.WriteLine("我是原始方法&qu

看看C# 6.0中那些语法糖都干了些什么（终结篇）

终于写到终结篇了,整个人像在梦游一样,说完这一篇我得继续写我的js系列啦. 一:带索引的对象初始化器 还是按照江湖老规矩,先扒开看看到底是个什么玩意. 1 static void Main(string[] args) 2 { 3 Dictionary<string, string> dic = new Dictionary<string, string>() 4 { 5 ["Name"] = "ctrip", 6 ["Age&qu

看看C# 6.0中那些语法糖都干了些什么（中篇）

接着上篇继续扯,其实语法糖也不是什么坏事,第一个就是吃不吃随你,第二个就是最好要知道这些糖在底层都做了些什么,不过有一点 叫眼见为实,这样才能安心的使用,一口气上五楼,不费劲. 一:字符串嵌入值 我想String.Format方法就是化成灰大家都认识,比如下面代码: 1 class Bird 2 { 3 private string Name = "swallow"; 4 5 public void Fly() 6 { 7 var result = string.Format(&quo

[C#]剖析异步编程语法糖: async和await

一.难以被接受的async 自从C#5.0,语法糖大家庭又加入了两位新成员: async和await. 然而从我知道这两个家伙之后的很长一段时间,我甚至都没搞明白应该怎么使用它们,这种全新的异步编程模式对于习惯了传统模式的人来说实在是有些难以接受,不难想象有多少人仍然在使用手工回调委托的方式来进行异步编程.C#中的语法糖非常多,从自动属性到lock.using,感觉都很好理解很容易就接受了,为什么偏偏async和await就这么让人又爱又恨呢? 我想,不是因为它不好用(相反,理解了它们之后是非常

看看C# 6.0中那些语法糖都干了些什么（上篇）

今天没事,就下了个vs2015 preview,前段时间园子里面也在热炒这些新的语法糖,这里我们就来看看到底都会生成些什么样的IL? 一:自动初始化属性 确实这个比之前的版本简化了一下,不过你肯定很好奇,到底编译器给我们做了哪些东西呢? 1 class Student 2 { 3 public string Name { get; set; } = "ctrip"; 4 } 从这张图中可以看到,在ctor中<Name>k__backingfield=“ctrip“的赋值在b