澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

澳门新萄京官方网站0语法糖剖析,0新增语法糖

2019-05-18 作者:www.8455.com   |   浏览(126)

阅读目录:

扩展自动属性语法

活动属性发轫化表明式。

public class Example
{
    // 6.0新增语法糖
    public string FirstName { get; set; } = "Monkey";

    // 6.0之前的写法
    //private string _firstName = "Monkey";
    //public string FirstName
    //{
    //    get { return _firstName; }
    //    set { _firstName = value; }
    //}

    public Example()
    {

    }
}

自动属性能够不定义 set 访问器。

public class Example
{
    public string FirstName { get; } = "Monkey";

    public string LastName { get; }

    public Example()
    {

    }
}

只读属性能够在项目构造函数中起初化。

public class Example
{
    public string FirstName { get; } = "Monkey";

    public string LastName { get; } 

    public Example(string lastName)
    {
        LastName = lastName;
    }
}

由于种类进级到了.NetFramework 四.六.一,开拓工具转向了vs20一五,趁机尝试下C#6.0.结实在网络搜的一部分课程总计的不是太完整,有的代码随着vs正式版的公布也存有修改.那多少个个科目也没更新.
所以把团结上学到的记录一下.

  1. 自动属性暗中同意开头化
  2. 机动只读属性默许初叶化
  3. 表明式为主体的函数
  4. 表明式为宗旨的品质(赋值)
  5. 静态类导入
  6. Null条件运算符
  7. 字符串格式化
  8. 索引伊始化
  9. 相当过滤器when
  10. catch和finally代码块内的Await
  11. nameof表达式
  12. 推而广之方法
  13. 总结

Null 条件运算符

用以在试行成员访问 (?.) 或索引 (?[) 操作在此之前,测试是还是不是存在 NULL。 可援助理编辑写越来越少的代码来管理 null 检查。

分子访问 (?.) :

public static string Truncate(string value, int length)
{
    return value?.Substring(0, Math.Min(value.Length, length));

    // C# 6.0 之前的写法
    //string result = value;
    //if (value != null)
    //{
    //    result = value.Substring(0, Math.Min(value.Length, length));
    //}
    //return result;
}

索引 (?[) 操作:

List<Example> examples = null;
Example example = examples?[0]; 
// 上述相当于 Example? item = (examples != null) ? examples[0] : null

Console.WriteLine(example == null); // 输出 True

一.自行属性开端化(Auto-property initializers)

    public class Account
    {

        public string Name { get; set; } = "summit";

        public int Age { get; set; } = 22;

        public IList<int> AgeList
        {
            get;
            set;
        } = new List<int> { 10,20,30,40,50 };

    }

 对于只读属性也足以如此直白初步化(C#5.0不支持),也足以直接在构造函数里开头化

public class Customer
{
    public string Name { get; }
    public Customer(string first, string last)
    {
        Name = first   " "   last;
    }
}

机关属性暗中认可起头化

行使方式:

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

为了有利于精晓使用贰.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)

允许访问类型的静态成员,而没有须要限定使用项目名称进行访问:

//静态导入Console
using static System.Console;
using static System.Math;
using static System.DayOfWeek;

class Program
{ 
        static void Main()
        { 
                //直接使用方法而不用Console.WriteLine 
                WriteLine(Sqrt(3*3   4*4)); 
                WriteLine(Friday - Monday); 
        }
}

二.字符串嵌入值(String interpolation)

在事先版本的String.Format中有微微个参数就要写多少个占位符还必须比照顺序,否则就报错.参数壹多,那样搞的话确实头痛.新本子中在字符串前用$来标记前边的字符能够运用{对象}来作为占位符.看个例子.

Console.WriteLine($"年龄:{account.Age}  生日:{account.BirthDay.ToString("yyyy-MM-dd")}");
Console.WriteLine($"年龄:{account.Age}");
Console.WriteLine($"{(account.Age<=22?"小鲜肉":"老鲜肉")}");

倘诺想出口{或}符号,写多少个就可以,如$"{{".
留神这么些$符号,网络的N多教程都以尚未这么些东东的.是一直"{ account.Age }",这种格局在新版本里已经被丢掉了.

自动只读属性默许开头化

运用方式:

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

由于起首化暗中认可值实在构造函数中赋值的,所以跟属性只读不妨。

字符串格式化

// 字符串格式化可以这样写:
var s1 = $"{p.Name} is {p.Age} year{{s}} old";

var s2 = $"{p.Name,20} is {p.Age:D3} year{{s}} old";

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

三.导入静态类(Using Static)

像在此以前使用Math那个静态类的时候要起始入System命名空间后手艺动用它.未来能够一贯导入那一个静态,然后代码中央直属机关接行使其函数.

using static System.Math;//注意这里不是命名空间哦

Console.WriteLine($"之前的使用方式: {Math.Pow(4, 2)}");
Console.WriteLine($"导入后可直接使用方法: {Pow(4,2)}");

瞩目这里是using static ...
一经有些命名空间下有n个方法,用这种艺术一向引进单个静态类而不用引用全数办法照旧挺方便的.

表达式为爱慕的函数

动用办法:

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

nameof 表达式

WriteLine(nameof(DayOfWeek.Friday));  // 输出 Friday

static void Main(string[] args)
{
    throw new ArgumentNullException(nameof(args), "ArgumentNullException");
}

地点示例代码运营结果:
未经管理的优良: System.ArgumentNullException: ArgumentNullException
参数名: ** args**

4.空值运算符(Null-conditional operators)

事先写过众多个这么的决断代码

if (*** != null)
{
     //不为null的操作
}
return null;

于今选用能够简化那样格局.

var age = account.AgeList?[0].ToString();

Console.WriteLine("{0}", (person.list?.Count ?? 0));

借使account.AgeList为空则整个表明式重临空,不然前面包车型大巴表明式的值.

表达式为主题的性质(赋值)

利用情势:

public string Name2 => "hello world";

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

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

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

字典伊始化器

static void Main(string[] args)
{
    var strings = new Dictionary<string, string>()
    {
        ["ABC"] = "abc",
        ["DEF"] = "def"
    };

    foreach (var s in strings)
    {
        WriteLine(s.Key   ": "   s.Value);
    }

    WriteLine();

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

    foreach (var n in numbers)
    {
        WriteLine(n.Key   ": "   n.Value);
    }

    ReadKey();
}

地方示例代码输出结果为:

ABC: abc
DEF: def

7: seven
9: nine
13: thirteen

伍.目的开始化器(Index Initializers)

这种情势能够给字典或任何对象通过索引赋值先导化.

IDictionary<int, string> dict = new Dictionary<int, string>() {
       [1]="first",
       [2]="second"
};
foreach(var dic in dict)
{
    Console.WriteLine($"key: {dic.Key} value:{dic.Value}");
}

output:
key: 1 value:first
key: 2 value:second

静态类导入

本条性子能够3回性导入某项目的有所静态成员,使静态成员在后面包车型客车代码中从未项目限制一直行使,像使用本类型上面包车型地铁静态方法同样。

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

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

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

节约了品种名称的重新编写。

可怜过滤器

catch (ArgumentNullException e) when (e.ParamName == “…”)  
{  
}  

尽管括号表明式(when)的结果为 true 时,才实行对应 catch 块中的语句,不然继续搜索处理程序。

static void Main(string[] args)
{
    try
    {
        throw new ArgumentNullException(nameof(args), "ArgumentNullException");
    }
    catch (ArgumentNullException ex) when (ex.ParamName == "arges")
    {
        WriteLine("ArgumentNullException");
    }
    catch (Exception ex) when (ex.InnerException == null)
    {
        WriteLine("Exception");
    }
}

演示代码输出结果为:
Exception

陆.百般过滤器(Exception filters)

private static bool Log(Exception e)
{
    Console.WriteLine("log");
    return true;
}
static void TestExceptionFilter()
{
    try
    {
        Int32.Parse("s");
    }
    catch (Exception e) when (Log(e))
    {
        Console.WriteLine("catch");
        return;
    }
}

当when()里面返回的值不为true,将持续抛出异常,不会执行catch里面的方法.

澳门新萄京官方网站0语法糖剖析,0新增语法糖。Null条件运算符

应用格局:

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

等同于:

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

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

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

还足以贰个联合用:

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

也足以方法调用:

customer?.Face();

其一语法糖的目标是在指标使用前检查是或不是为null。只要目的为空,则赋值给变量为空值,所以例子中须要二个可感到空的int类型、即int?。

假设指标不为空,则调用对象的积极分子取值,并赋值给变量。

在 catch 和 finally 块使用首要字 await

C# 陆.0 在此之前catch和finally块中是无法用 await 关键词的。现在大家能够再那八个地点选用await了。

public async void Info()
{
    try
    {
        //Do something
    }
    catch (Exception)
    {
        await SumPageSizesAsync();
    }
    finally
    {
        await SumPageSizesAsync();
    }
}

private async Task SumPageSizesAsync()
{
    string url = "http://api.xxxx.com/";
    HttpClient client = new HttpClient();
    Task<byte[]> getContentsTask = client.GetByteArrayAsync(url);
    byte[] urlContents = await getContentsTask;
}

7.nameof表达式 (nameof expressions)

在对方法参数进行检查时经常这样写:
private static void Add(Account account)
{
     if (account == null)
         throw new ArgumentNullException("account");
}

如果某天参数的名字被修改了,下面的字符串很容易漏掉忘记修改.
使用nameof表达式后,编译的时候编译器将检查到有修改后自动导航与重构(-_-! 不知道翻译的对不对)
private static void Add(Account account)
{
     if (account == null)
         throw new ArgumentNullException(nameof(account));
}

字符串格式化

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

8.在cath和finally语句块里采纳await(Await in catch and finally blocks)

c#5.0里是不支持这么写.

Resource res = null;
try
{
    res = await Resource.OpenAsync(…);       // You could do this.
    …
} 
catch(ResourceException e)
{
    await Resource.LogAsync(res, e);         // Now you can do this …
}
finally
{
    if (res != null) await res.CloseAsync(); // … and this.
}

索引开始化

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;

玖.在性质里应用Lambda表明式(Expression bodies on property-like function members)

public string Name =>string.Format("姓名: {0}", "summit");

public void Print() => Console.WriteLine(Name);

特别过滤器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语法就可以一贯定位到错误源。 

10.在措施成员上行使拉姆da表明式

static int LambdaFunc(int x, int y) => x*y;

public void Print() => Console.WriteLine(First   " "   Last);

 

关于C#6.0新增的言语特征近些日子甘休也就那样多.未有怎么新职能,更多的是语法糖的创新.开辟更舒服更飞快. 
末段附上github上关于c#六.0的有关介绍链接:点自个儿点自个儿

  

 

catch和finally代码块内的Await

Await异步管理是在c#伍.0建议的,但无法在catch和finally代码块Nelly用,此次在C#陆.0立异上支撑了。

应用办法:

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

编写翻译器把catch和finally的await生成到状态机里面包车型地铁MoveNext()里面。原来里面只有TaskAwaiter,未来多了3个。状态机里面包车型大巴代码和原先的同等,只是更复杂了下,有乐趣的童鞋能够先看下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。

因为扩大方法即便是叁个静态方法,但是语法规定它作为2个实例方法运用(打点),所以不能够在大局功效域里当静态方法用,因而var odd = Where(range, i => i % 二 == 1)是不当的。

只是static却能把品种的庞大方法作为扩充方法本身剧中人物的效益导入进去,所以var even = range.Where(i => i % 二 == 0)是ok的。

这里也许某个有一点点绕,lz尽量写清楚,static新用法有二个职能:

  1. 把静态成员导入,但扩展方法对比奇特、排除在外。那时static是c# 陆.0的新功用。
  2. 1致把扩充方法的命名空间导入,所以在集中上得以看护调用扩充方法。那是事先就有的职能,而不是把扩充方法转成单纯的静态方法导入使用。

总结

观察园子里有介绍的篇章,不常来兴趣了,下班后装置个社区版就钻研分享下。 固然微软直接出新东西,但都以由下至上迭代的,所以读书起来是拾叁分快的。

 

参考

探索C#之种种导航

本文由澳门新萄京官方网站发布于www.8455.com,转载请注明出处:澳门新萄京官方网站0语法糖剖析,0新增语法糖

关键词: