威尼斯人线上娱乐

【威尼斯人线上娱乐】0语法糖剖析,0新增语法糖

5 4月 , 2019  

阅读目录:

读书目录:

机关属性暗中认可开首化

使用办法:

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

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

恢宏自动属性语法

机动属性伊始化表明式。

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;
    }
}
  1. 机动属性私下认可初阶化
  2. 机关只读属性暗中认可初始化
  3. 表明式为本位的函数
  4. 表明式为基点的属性(赋值)
  5. 静态类导入
  6. Null条件运算符
  7. 字符串格式化
  8. 索引初阶化
  9. 【威尼斯人线上娱乐】0语法糖剖析,0新增语法糖。卓殊过滤器when
  10. catch和finally代码块内的Await
  11. nameof表达式
  12. 壮大方法
  13. 总结
  1. 机动属性暗中同意初始化
  2. 电动只读属性默认伊始化
  3. 表达式为重点的函数
  4. 表达式为主导的性质(赋值)
  5. 静态类导入
  6. Null条件运算符
  7. 字符串格式化
  8. 索引开头化
  9. 那几个过滤器when
  10. catch和finally代码块内的Await
  11. nameof表达式
  12. 扩展方法
  13. 总结

自动只读属性暗许开始化

运用格局:

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

从扭转的代码中也可以看看编写翻译器是在实例化构造函数时,初叶化属性音信的。

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

电动属性暗许早先化

接纳办法:

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

 从变化代码中得以看看编写翻译器是在实例构造函数时,起始化属性音讯的。

自动属性私下认可早先化

利用格局:

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

 从转变代码中得以看出编写翻译器是在实例构造函数时,先导化属性音信的。

表明式为本位的函数

运用办法:

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

导入静态类 (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); 
        }
}

自动只读属性暗中认可发轫化

使用情势:

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

由于起先化暗许值实在构造函数中赋值的,所以跟属性只读不要紧。

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

使用办法:

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

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

表明式为主体的品质(赋值)

应用办法:

public string Name2 => "hello world";

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

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

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

字符串格式化

// 字符串格式化可以这样写:
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";

表明式为核心的函数

应用办法:

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

表达式为基点的函数

动用格局:

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

静态类导入

这么些相比较易于掌握,正是3回性导入某项指标保有静态成员,然后在背后的代码中央直机关接选择,比如:

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

nameof 表达式

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

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

地点示例代码运维结果:
未经处理的越发: System.ArgumentNullException: ArgumentNullException
参数名: ** args**

表达式为主导的习性(赋值)

使用方法:

public string Name2 => "hello world";

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

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

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

表明式为主导的品质(赋值)

威尼斯人线上娱乐 ,使用情势:

public string Name2 => "hello world";

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

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

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

Null 条件运算符

选择方法:

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

等同于:

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

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

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

还足以叁个体协会同用

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

以此语法糖目标是在目的使用前检查是还是不是为null,假如目的为空,则赋值给变量为宿舍,所以例子中要求二个得以为空的Int类型,即int?
比方指标不为空,则调用对象的积极分子取舍,并赋值给变量

字典初叶化器

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

静态类导入

其一特点能够叁遍性导入某项指标全部静态成员,使静态成员在后头的代码中并未有项目限制一贯行使,像使用本类型上面包车型地铁静态方法一样。

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

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

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

节约了花色名称的双重编写。

静态类导入

以此特点能够贰回性导入某项目标具有静态成员,使静态成员在前面包车型客车代码中从未项目限制平昔动用,像使用本类型上边包车型客车静态方法壹样。

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

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

private static void Main(string[] args)
 {
 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";

正如有意思的是,新格式方法还支持其余表明式的第1手赋值:

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

至极过滤器

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

Null条件运算符

动用格局:

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

等同于:

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

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

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

还是能1个共同用:

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

也足以方法调用:

customer?.Face();

其一语法糖的目标是在目的使用前检查是或不是为null。一经目的为空,则赋值给变量为空值,所以例子中须求一个能够为空的int类型、即int?。

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

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

假定目的不为空,则调用对象的分子取值,并赋值给变量。

目录的初阶化

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

在 catch 和 finally 块使用首要字 await

C# 6.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;
}

字符串格式化

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

字符串格式化

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

尤其过滤器 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语法就足以平素定位到错误源。

索引开头化

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;

索引发轫化

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;

nameof表达式

偶然会须要程序中有的分子的字符串名称,比如抛出ArgumentNullException非常的时候,想清楚ArgumentNullException类型的字符串名称,那时候就能够用nameof获取字符

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

string name = "";
Console.WriteLine(nameof(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语法就能够直接定位到错误源。 

老大过滤器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语法就足以一向定位到错误源。 

catch和finally代码块内的Await

Await异步处理是在c#5.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,以后多了1个。状态机里面包车型大巴代码和原来的一律,只是更扑朔迷离了下,有趣味的童鞋能够先看下Async、Await剖析再去追究。

catch和finally代码块内的Await

Await异步处理是在c#伍.0提议的,但不能在catch和finally代码块内选取,这一次在C#陆.0立异上支撑了。

选取办法:

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

编写翻译器把catch和finally的await生成到状态机里面包车型客车MoveNext()里面。原来里面唯有TaskAwaiter,未来多了二个。状态机里面包车型地铁代码和原来的同一,只是更复杂了下,有趣味的童鞋能够先看下Async、Await剖析再去探索。

nameof表达式

运用格局:

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

决定台出口 “name”。

偶尔会须要程序中有个别成员的字符串名称,比如抛出ArgumentNullException格外的时候,想领悟ArgumentNullException类型的字符串名称,那时候就能够用nameof获取字符

串“ArgumentNullException”。未来做法都以手动复制一下,但重构改名的时候便于忘记变更字符串,使用nameof就可以制止了。

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

nameof(person.Address.ZipCode)

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

Console.WriteLine("name");

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 % 二 == 一)是大错特错的。

而是static却能把品种的增添方法作为扩大方法自己剧中人物的效用导入进去,所以var
even = range.Where(i => i % 2 == 0)是ok的。

那边也许有个别有点绕,lz尽量写清楚,static新用法有1个功效:

  1. 把静态成员导入,但扩张方法比较特殊、排除在外。那时static是c#
    陆.0的新效率。
  2. 同等把扩展方法的命名空间导入,所以在集聚上得以打点调用扩展方法。那是前面就部分职能,而不是把增加方法转成单纯的静态方法导入使用。

壮大方法

    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 == 一)是一无所能的。

唯独static却能把项目标恢宏方法作为扩张方法本身剧中人物的效应导入进去,所以var
even = range.Where(i => i % 2 == 0)是ok的。

此间或然有点有点绕,lz尽量写清楚,static新用法有叁个职能:

  1. 把静态成员导入,但扩展方法比较特殊、排除在外。那时static是c#
    陆.0的新功用。
  2. 1致把扩张方法的命名空间导入,所以在聚集上得以打点调用扩张方法。这是后面就一些效益,而不是把扩张方法转成单纯的静态方法导入使用。

总结

见状园子里有介绍的篇章,暂时来兴趣了,下班后安装个社区版就研商分享下。
固然微软一向出新东西,但都以由下至上迭代的,所以读书起来是丰硕快的。

 

参考

总结

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

 

参考

探索C#之多种导航

探索C#之七种导航


相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图