探索C#之6.0语法糖剖析分分快三计划

作者:编程技术

读书目录:

自动只读属性暗中同意伊始化

行使方法:

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

编写翻译器生成代码:

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;
    }
}
}

从扭转的代码中也足以见到编写翻译器是在实例化构造函数时,开首化属性消息的。

  1. 自行属性暗许起始化
  2. 机动只读属性暗中认可早先化
  3. 表达式为宗旨的函数
  4. 表明式为本位的属性(赋值)
  5. 静态类导入
  6. Null条件运算符
  7. 字符串格式化
  8. 索引伊始化
  9. 丰硕过滤器when
  10. catch和finally代码块内的Await
  11. nameof表达式
  12. 增添方法
  13. 总结

静态类导入

那个相比便于精通,正是贰次性导入某项指标具有静态成员,然后在后面包车型客车代码中从来利用,举例:

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

表达式为重心的性质(赋值)

运用方法:

public string Name2 => "hello world";

编写翻译器生成代码如下:

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

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

不行过滤器 when

运用格局:

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

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

When语法作用是:在进入到catch在此之前、验证when括号里myfilter方法重临的bool,借使回到true继续运行,false不走catch直接抛出极度。

动用那个filter能够更好的推断一个不当是连续管理或然重新抛出去。遵照此前的做法,在catch块内如需再次抛出去,须求再度throw出去,那时的错误源是捕捉后在抛的,并不是原先的,有了when语法就足以直接固定到错误源。

总结

来看园子里有介绍的稿子,一时来兴趣了,下班后安装个社区版就钻研分享下。 固然微软一贯出新东西,但都是由下至上迭代的,所以读书起来是丰裕快的。

 

参考

Null 条件运算符

利用格局:

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

等同于:

Customer cust = new Customer();
string name = cust?.Name;

能够和??组合起来使用:

if (customer?.Face()?? false)

还能2个一齐用

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

本条语法糖指标是在对象使用前检查是还是不是为null,假若目的为空,则赋值给变量为宿舍,所以例子中需求一个方可为空的Int类型,即int?
假若目的不为空,则调用对象的分子取舍,并赋值给变量

静态类导入

那些特点可以三回性导入某项目标保有静态成员,使静态成员在末端的代码中绝非项目限制一向运用,像使用本类型下边包车型大巴静态方法一样。

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

编写翻译器生成代码如下:

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

节省了项目名称的再一次编写。

目录的起首化

行使List时,即使可以透过上面包车型地铁措施书写,能够编译通过,但要么会抛相当,使用办法:

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

编写翻译器生成代码:

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

Dictionary 能够实行,因为两个内部索引机制分化等:

var numbers = new Dictionary<int, string> {[7] = "seven",[9] = "nine",[13] = "thirteen";

表明式为主体的函数

应用办法:

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"));

字符串格式化

在下边包车型地铁例子中,String.Format 有个别不低价的地方是:必得输入“String.Format", 使用{0}点位符,必需按顺序来格式化,那一点比较轻易出错:

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

新的语法糖能够这么使用:

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

正如风趣的是,新格式方法还援救其余表达式的第一手赋值:

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

nameof表达式

运用办法:

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

调节台出口 "name"。

有的时候候会需求程序中有的成员的字符串名称,比方抛出ArgumentNullException非凡的时候,想掌握ArgumentNullException类型的字符串名称,那时候就能够用nameof获取字符

串“ArgumentNullException”。以后做法都以手动复制一下,但重构改名的时候轻松忘记改动字符串,使用nameof就足以制止了。

当如下使用的时候,编写翻译器会只取最终的ZipCode。

nameof(person.Address.ZipCode)

编译器生成如下代码:

Console.WriteLine("name");

表明式为重心的习性(赋值)

运用办法:

public string Name2 => "hello world";

编写翻译器生成代码如下:

public string Name2
{
     get { return "hello world"; }
}

编写翻译器只生成了个只读属性

字符串格式化

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";

表明式为入眼的函数

行使方法:

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 world"));

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表达式

突发性会要求程序中有的成员的字符串名称,比方抛出ArgumentNullException极度的时候,想通晓ArgumentNullException类型的字符串名称,那时候就能够用nameof获取字符

串“ArgumentNullException”。未来做法都是手动复制一下,但重构改名的时候便于忘记更换字符串,使用nameof就能够幸免了。

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

索引初阶化

List即使这么写能够编译通过,可是会抛十分的,使用格局:

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

编译器生成代码如下:

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

Dictionary能够进行,因为两岸内部索引机制不一样等:

 var numbers = new Dictionary<int, string> {[7] = "seven",[9] = "nine",[13] = "thirteen" };

编写翻译器生成代码:

 Dictionary<int, string> dictionary2 = new Dictionary<int, string>();
    dictionary2[7] = "seven";
    dictionary2[9] = "nine";
    dictionary2[13] = "thirteen";
    Dictionary<int, string> dictionary = dictionary2;

自行属性暗许初步化

选用办法:

public string Name { get; set; } = "Hello World";

编写翻译器生成代码:

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;
    }
}
}

从扭转代码中能够看来编写翻译器是在实例化构造函数时,起始化属性新闻的。

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?。

只要目的不为空,则调用对象的成员取值,并赋值给变量。

电动属性暗中同意初步化

运用办法:

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;
    }
}
} 

 从调换代码中得以看来编译器是在实例构造函数时,初步化属性音讯的。

推而广之方法

    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。

因为扩展方法固然是贰个静态方法,不过语准绳定它当做一个实例方法运用(照拂),所以不可能在全局成效域里当静态方法用,由此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. 一样把扩大方法的命名空间导入,所以在汇集上能够照管调用扩张方法。这是前边就一些效果与利益,并不是把扩张方法转成单纯的静态方法导入使用。

可怜过滤器when

应用方法:

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

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

When语法作用是:在步入到catch此前、验证when括号里myfilter方法再次回到的bool,如若回到true继续运维,false不走catch直接抛出特别。

选用这些filter可以更加好的推断二个荒唐是两次三番管理大概重新抛出去。根据原先的做法,在catch块内如需重新抛出去,须要重新throw出去,那时的错误源是捕捉后在抛的,实际不是原先的,有了when语法就能够直接固定到错误源。 

机关只读属性私下认可初步化

行使情势:

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; }
 }

鉴于初叶化私下认可值实在构造函数中赋值的,所以跟属性只读无妨。

探索C#之多样导航

本文由分分快三计划发布,转载请注明来源

关键词: 分分快三计划 ASP.NET