读书目录:

阅读目录:

自行属性暗中认可先河化

接纳办法:

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

从扭转代码中得以观察编写翻译器是在实例化构造函数时,发轫化属性消息的。

扩展自动属性语法

0新增语法糖,0语法糖剖析。活动属性早先化表明式。

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. 可怜过滤器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"));

静态类导入

其1相比易于明白,正是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"; }
 }

金沙注册送58 ,编写翻译器只生成了个只读属性。

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

应用情势:

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,倘诺目标为空,则赋值给变量为宿舍,所以例子中须要3个足以为空的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"); 
}

节约了档次名称的重复编写。

静态类导入

以此特点能够2遍性导入某项目的兼具静态成员,使静态成员在末端的代码中尚无项目限制平素利用,像使用本类型上面包车型大巴静态方法1样。

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

比较有趣的是,新格式方法还帮忙任何表达式的直接赋值:

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)

还足以一个一块用:

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

也得以方法调用:

customer?.Face();

本条语法糖的目标是在目的使用前检查是还是不是为null。只要目的为空,则赋值给变量为空值,所以例子中须要3个足以为空的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# 陆.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}占位符、必须逐1来格式化、那点不难失误。

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

诙谐的是,新格式化格局还帮衬别的表明式的第1手赋值:

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能够越来越好的判定1个荒谬是持续处理或然重新抛出去。依照原先的做法,在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能够执行,因为两岸内部索引机制不1致:

 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#五.0提出的,但无法在catch和finally代码块内使用,此次在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代码块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剖析再去追究。

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。

因为增添方法尽管是二个静态方法,不过语法规定它当做一个实例方法应用(打点),所以不可能在大局成效域里当静态方法用,因而var
odd = Where(range, i => i % 贰 == 1)是不对的。

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

此地或者有点有点绕,lz尽量写清楚,static新用法有3个效益:

  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 % 二 == 一)是不对的。

而是static却能把项目标恢宏方法作为扩展方法本人角色的效率导入进去,所以var
even = range.Where(i => i % 二 == 0)是ok的。

那边或然有些有点绕,lz尽量写清楚,static新用法有2个效益:

  1. 把静态成员导入,但增加方法相比独特、排除在外。那时static是c#
    6.0的新效能。
  2. 无差距于把扩展方法的命名空间导入,所以在聚集上得以打点调用扩充方法。这是事先就有的职能,而不是把扩充方法转成单纯的静态方法导入使用。

总结

总的来看园子里有介绍的篇章,暂时来兴趣了,下班后装置个社区版就钻研分享下。
即便微软直接出新东西,但都以由下至上迭代的,所以读书起来是10分快的。

 

参考

总结

见状园子里有介绍的小说,权且来兴趣了,下班后装置个社区版就研讨分享下。
纵然微软直接出新东西,但都以由下至上迭代的,所以读书起来是越来越快的。

 

参考

探索C#之各个导航

探索C#之两种导航

相关文章

网站地图xml地图