C# 2.0
泛型（Generics）
泛型是CLR 2.0中引入的最重要的新特性，使得可以在類、方法中對使用的類型進行參數化。
例如，這里定義了一個泛型類：
class MyCollection<T>
{
T variable1; private void Add(T param)
{ }
}
使用的時候：
MyCollection<string> list2 = new MyCollection<string>();
MyCollection<Object> list3 = new MyCollection<Object>();
泛型的好處
- 編譯時就可以保證類型安全
- 不用做類型裝換，獲得一定的性能提升
泛型方法、泛型委托、泛型接口
除了泛型類之外，還有泛型方法、泛型委托、泛型接口：
//泛型委托 public static delegate T1 MyDelegate<T1, T2>(T2 item);
MyDelegate<Int32, String> MyFunc = new MyDelegate<Int32, String>(SomeMethd); //泛型接口 public class MyClass<T1, T2, T3> : MyInteface<T1, T2, T3> { public T1 Method1(T2 param1, T3 param2) { throw new NotImplementedException(); } } interface MyInteface<T1, T2, T3> { T1 Method1(T2 param1, T3 param2); } //泛型方法 static void Swap<T>(ref T t1, ref T t2) { T temp = t1; t1 = t2; t2 = temp; }
String str1 = "a"; String str2 = "b"; Swap<String>(ref str1, ref str2);
泛型約束（constraints）
可以給泛型的類型參數上加約束，可以要求這些類型參數滿足一定的條件
| 約束 |
說明 |
| where T: struct | 類型參數需是值類型 |
| where T : class | 類型參數需是引用類型 |
| where T : new() | 類型參數要有一個public的無參構造函數 |
| where T : <base class name> | 類型參數要派生自某個基類 |
| where T : <interface name> | 類型參數要實現了某個接口 |
| where T : U | 這里T和U都是類型參數，T必須是或者派生自U |
這些約束，可以同時一起使用：
class EmployeeList<T> where T : Employee, IEmployee, System.IComparable<T>, new()
{
// ...
}
default 關鍵字
這個關鍵可以使用在類型參數上：
default(T);
對於值類型，返回0，引用類型，返回null，對於結構類型，會返回一個成員值全部為0的結構實例。
迭代器（iterator）
可以在不實現IEnumerable就能使用foreach語句，在編譯器碰到yield return時，它會自動生成IEnumerable 接口的方法。在實現迭代器的方法或屬性中，返回類型必須是IEnumerable, IEnumerator, IEnumerable<T>，或 IEnumerator<T>。迭代器使得遍歷一些零碎數據的時候很方便，不用去實現Current, MoveNext 這些方法。
public System.Collections.IEnumerator GetEnumerator() { yield return -1; for (int i = 1; i < max; i++) { yield return i; } }
可空類型（Nullable Type）
可空類型System.Nullable<T>，可空類型僅針對於值類型，不能針對引用類型去創建。System.Nullable<T>簡寫為T ?。
int? num = null; if (num.HasValue == true) { System.Console.WriteLine("num = " + num.Value); } else { System.Console.WriteLine("num = Null"); }
如果HasValue為false，那么在使用value值的時候會拋出異常。把一個Nullable的變量x賦值給一個非Nullable的變量y可以這么寫：
int y = x ?? -1;
匿名方法（Anonymous Method）
在C#2.0之前，給只能用一個已經申明好的方法去創建一個委托。有了匿名方法后，可以在創建委托的時候直接傳一個代碼塊過去。
delegate void Del(int x); Del d = delegate(int k) { /* ... */ }; System.Threading.Thread t1 = new System.Threading.Thread (delegate() { System.Console.Write("Hello, "); } ); 委托語法的簡化// C# 1.0的寫法 ThreadStart ts1 = new ThreadStart(Method1); // C# 2.0可以這么寫 ThreadStart ts2 = Method1;
委托的協變和逆變（covariance and contravariance）
有下面的兩個類：
class Parent { } class Child: Parent { }
然后看下面的兩個委托：
public delegate Parent DelgParent();
public delegate Child DelgChild();
public static Parent Method1() { return null; }
public static Child Method2() { return null; }
static void Main() { DelgParent del1= Method1; DelgChild del2= Method2; del1 = del2; }
注意上面的，DelgParent 和DelgChild 是完全不同的類型，他們之間本身沒有任何的繼承關系，所以理論上來說他們是不能相互賦值的。但是因為協變的關系，使得我們可以把DelgChild類型的委托賦值給DelgParent 類型的委托。協變針對委托的返回值，逆變針對參數，原理是一樣的。
部分類（partial）
在申明一個類、結構或者接口的時候，用partial關鍵字，可以讓源代碼分布在不同的文件中。我覺得這個東西完全是為了照顧Asp.net代碼分離而引入的功能，真沒什么太大的實際用處。微軟說在一些大工程中可以把類分開在不同的文件中讓不同的人去實現，方便團隊協作，這個我覺得純屬胡扯。
部分類僅是編譯器提供的功能，在編譯的時候會把partial關鍵字定義的類和在一起去編譯，和CRL沒什么關系。
靜態類（static class）
靜態類就一個只能有靜態成員的類，用static關鍵字對類進行標示，靜態類不能被實例化。靜態類理論上相當於一個只有靜態成員並且構造函數為私有的普通類，靜態類相對來說的好處就是，編譯器能夠保證靜態類不會添加任何非靜態成員。
global::
這個代表了全局命名空間（最上層的命名空間），也就是任何一個程序的默認命名空間。
class TestApp { public class System { } const int Console = 7; static void Main() { //用這個訪問就會出錯，System和Console都被占用了 //Console.WriteLine(number); global::System.Console.WriteLine(number); } }
extern alias
用來消除不同程序集中類名重復的沖突，這樣可以引用同一個程序集的不同版本，也就是說在編譯的時候，提供了一個將有沖突的程序集進行區分的手段。
在編譯的時候，使用命令行參數來指明alias，例如：
/r:aliasName=assembly1.dll
在Visual Studio里面，在被引用的程序集的屬性里面可以指定Alias的值，默認是global。
然后在代碼里面就可以使用了：
extern alias aliasName; //這行需要在using這些語句的前面 using System; using System.Collections.Generic; using System.Text; using aliasName.XXX;
屬性Accessor訪問控制
public virtual int TestProperty { protected set { } get { return 0; } }
友元程序集（Friend Assembly）
可以讓其它程序集訪問自己的internal成員（private的還是不行），使用Attributes來實現，例如：
[assembly:InternalsVisibleTo("cs_friend_assemblies_2")]
注意這個作用范圍是整個程序集。
fixed關鍵字
可以使用fixed關鍵字來創建固定長度的數組，但是數組只能是bool, byte, char, short, int, long, sbyte, ushort, uint, ulong, float, double中的一種。
這主要是為了更好的處理一些非托管的代碼。比如下面的這個結構體：
public struct MyArray { public fixed char pathName[128]; }
如果不用fixed的話，無法預先占住128個char的空間，使用fixed后可以很好的和非托管代碼進行交互。
volatile關鍵字
用來表示相關的字可能被多個線程同時訪問，編譯器不會對相應的值做針對單線程下的優化，保證相關的值在任何時候訪問都是最新的。
#pragma warning
用來取消或者添加編譯時的警告信息。每個警告信息都會有個編號，如果warning CS01016之類的，使用的時候取CS后面的那個數字，例如：
#pragma warning disable 414, 3021
這樣CS414和CS3021的警告信息就都不會顯示了。
C# 3.0
類型推斷
申明變量的時候，可以不用直指定類型：
var i = 5;
var s = "Hello";
//兩種寫法是一樣的 int i = 5; string s = "Hello";
類型推斷也支持數組：
var b = new[] { 1, 1.5, 2, 2.5 }; // double[] var c = new[] { "hello", null, "world” }; // string[]
擴展方法
擴展方法必須被定義在靜態類中，並且必須是非泛型、非嵌套的靜態類。例如：
public static class JeffClass { public static int StrToInt32(this string s) { return Int32.Parse(s); } public static T[] SomeMethd<T>(this T[] source, int pram1, int pram2) { /**/ } }
上面一個是給string類型的對象添加了一個方法，另一個是給所有類型的數組添加了一個方法，方法有兩個整型參數。
擴展方法只在當前的命名空間類有效，如果所在命名空間被其它命名空間import引用了，那么在其它命名空間中也有效。擴展方法的優先級低於其它的常規方法，也就是說如果擴展方法與其它的方法相同，那么擴展方法不會被調用。
Lamda表達式
可以看成是對匿名方法的一個語法上的簡化，但是λ表達式同時可以裝換為表達式樹類型。
對象和集合的初始化
var contacts = new List<Contact> {
new Contact { Name = "Chris", PhoneNumbers = { "123455", "6688" } }, new Contact { Name = "Jeffrey", PhoneNumbers = { "112233" } } };
匿名類型
var p1 = new { Name = "Lawnmower", Price = 495.00 }; var p2 = new { Name = "Shovel", Price = 26.95 }; p1 = p2;
自動屬性
會自動生成一個后台的私有變量
public Class Point
{
public int X { get; set; } public int Y { get; set; } }
查詢表達式
這個其實就是擴展方法的運用，編譯器提供了相關的語法便利，下面兩端代碼是等價的：
from g in
from c in customers group c by c.Country select new { Country = g.Key, CustCount = g.Count() } customers. GroupBy(c => c.Country). Select(g => new { Country = g.Key, CustCount = g.Count() })
表達式樹
Func<int,int> f = x => x + 1; Expression<Func<int,int>> e = x => x + 1;
C# 4.0
協變和逆變
這個在C#2.0中就已經支持委托的協變和逆變了，C#4.0開始支持針對泛型接口的協變和逆變：
IList<string> strings = new List<string>(); IList<object> objects = strings;
協變和逆變僅針對引用類型。
動態綁定
看例子：
class BaseClass
{
public void print() { Console.WriteLine(); } }
Object o = new BaseClass();
dynamic a = o;
//這里可以調用print方法，在運行時a會知道自己是個什么類型。 這里的缺點在於編譯的時候無法檢查方法的合法性，寫錯的話就會出運行時錯誤。 a.print();
可選參數，命名參數
private void CreateNewStudent(string name, int studentid = 0, int year = 1)
這樣，最后一個參數不給的話默認值就是1，提供這個特性可以免去寫一些重載方法的麻煩。
調用方法的時候，可以指定參數的名字來給值，不用按照方法參數的順序來制定參數值：
CreateNewStudent(year:2, name:"Hima", studentid: 4); //沒有按照方法定義的參數順序
C# 5.0
1. 異步編程
在.Net 4.5中，通過async和await兩個關鍵字，引入了一種新的基於任務的異步編程模型（TAP）。在這種方式下，可以通過類似同步方式編寫異步代碼，極大簡化了異步編程模型。如下式一個簡單的實例：
static async void DownloadStringAsync2(Uri uri)
{
var webClient = new WebClient();
var result = await webClient.DownloadStringTaskAsync(uri);
Console.WriteLine(result);
}
而之前的方式是這樣的：
static void DownloadStringAsync(Uri uri)
{
var webClient = new WebClient();
webClient.DownloadStringCompleted += (s, e) =>
{
Console.WriteLine(e.Result);
};
webClient.DownloadStringAsync(uri);
}
也許前面這個例子不足以體現async和await帶來的優越性，下面這個例子就明顯多了：
public void CopyToAsyncTheHardWay(Stream source, Stream destination)
{
byte[] buffer = new byte[0x1000];
Action<IAsyncResult> readWriteLoop = null;
readWriteLoop = iar =>
{
for (bool isRead = (iar == null); ; isRead = !isRead)
{
switch (isRead)
{
case true:
iar = source.BeginRead(buffer, 0, buffer.Length,
readResult =>
{
if (readResult.CompletedSynchronously) return;
readWriteLoop(readResult);
}, null);
if (!iar.CompletedSynchronously) return;
break;
case false:
int numRead = source.EndRead(iar);
if (numRead == 0)
{
return;
}
iar = destination.BeginWrite(buffer, 0, numRead,
writeResult =>
{
if (writeResult.CompletedSynchronously) return;
destination.EndWrite(writeResult);
readWriteLoop(null);
}, null);
if (!iar.CompletedSynchronously) return;
destination.EndWrite(iar);
break;
}
}
};
readWriteLoop(null);
}
public async Task CopyToAsync(Stream source, Stream destination)
{
byte[] buffer = new byte[0x1000];
int numRead;
while ((numRead = await source.ReadAsync(buffer, 0, buffer.Length)) != 0)
{
await destination.WriteAsync(buffer, 0, numRead);
}
}
關於基於任務的異步編程模型需要介紹的地方還比較多，不是一兩句能說完的，有空的話后面再專門寫篇文章來詳細介紹下。另外也可參看微軟的官方網站：Visual Studio Asynchronous Programming，其官方文檔Task-Based Asynchronous Pattern Overview介紹的非常詳細， VisualStudio中自帶的CSharp Language Specification中也有一些說明。
2. 調用方信息
很多時候，我們需要在運行過程中記錄一些調測的日志信息，如下所示：
public void DoProcessing()
{
TraceMessage("Something happened.");
}
為了調測方便，除了事件信息外，我們往往還需要知道發生該事件的代碼位置以及調用棧信息。在C++中，我們可以通過定義一個宏，然后再宏中通過__FILE__和__LINE__來獲取當前代碼的位置，但C#並不支持宏，往往只能通過StackTrace來實現這一功能，但StackTrace卻有不是很靠譜，常常獲取不了我們所要的結果。
針對這個問題，在.Net 4.5中引入了三個Attribute：CallerMemberName、CallerFilePath和CallerLineNumber。在編譯器的配合下，分別可以獲取到調用函數（准確講應該是成員）名稱，調用文件及調用行號。上面的TraceMessage函數可以實現如下：
public void TraceMessage(string message,
[CallerMemberName] string memberName = "",
[CallerFilePath] string sourceFilePath = "",
[CallerLineNumber] int sourceLineNumber = 0)
{
Trace.WriteLine("message: " + message);
Trace.WriteLine("member name: " + memberName);
Trace.WriteLine("source file path: " + sourceFilePath);
Trace.WriteLine("source line number: " + sourceLineNumber);
}
另外，在構造函數，析構函數、屬性等特殊的地方調用CallerMemberName屬性所標記的函數時，獲取的值有所不同，其取值如下表所示：
| 調用的地方 |
CallerMemberName獲取的結果 |
| 方法、屬性或事件 |
方法，屬性或事件的名稱 |
| 構造函數 |
字符串 ".ctor" |
| 靜態構造函數 |
字符串 ".cctor" |
| 析構函數 |
該字符串 "Finalize" |
| 用戶定義的運算符或轉換 |
生成的名稱成員，例如， "op_Addition"。 |
| 特性構造函數 |
特性所應用的成員的名稱 |
例如，對於在屬性中調用CallerMemberName所標記的函數即可獲取屬性名稱，通過這種方式可以簡化 INotifyPropertyChanged 接口的實現。
C# 6.0
1、自動屬性的增強
1.1、自動屬性初始化 (Initializers for auto-properties)
C#4.0下的果斷實現不了的。
C#6.0中自動屬性的初始化方式
只要接觸過C#的肯定都會喜歡這種方式。真是簡潔方便呀。
1.2、只讀屬性初始化Getter-only auto-properties
先來看一下我們之前使用的方式吧
public class Customer { public string Name { get; } public Customer(string firstName,string lastName) { Name = firstName +" "+ lastName; } }
再來看一下C#6.0中
public class Customer
{
public string FirstName { get; }="aehyok";
public string LastName { get; }="Kris";
}
和第一條自動屬性初始化使用方式一致。
2、Expression bodied function members
2.1 用Lambda作為函數體Expression bodies on method-like members
public Point Move(int dx, int dy) => new Point(x + dx, y + dy);
再來舉一個簡單的例子：一個沒有返回值的函數
public void Print() => Console.WriteLine(FirstName + " " + LastName);
2.2、Lambda表達式用作屬性Expression bodies on property-like function members
public override string ToString()
{
return FirstName + " " + LastName;
}
現在C#6中
public class User
{
public string FirstName { get; set; }
public string LastName { get; set; }
public override string ToString() => string.Format("{0}——{1}", FirstName, LastName);
public string FullName => FirstName + " " + LastName;
}
3、引用靜態類Using Static
在Using中可以指定一個靜態類，然后可以在隨后的代碼中直接使用靜態的成員
4、空值判斷Null-conditional operators
直接來看代碼和運行結果
通過結果可以發現返回的都為null,再也不像以前那樣繁瑣的判斷null勒。
5、字符串嵌入值
在字符串中嵌入值
之前一直使用的方式是
現在我們可以簡單的通過如下的方式進行拼接
6、nameof表達式nameof expressions
在方法參數檢查時，你可能經常看到這樣的代碼（之前用的少，這次也算學到了）
public static void AddCustomer(Customer customer)
{
if (customer == null)
{
throw new ArgumentNullException("customer");
}
}
里面有那個customer是我們手寫的字符串，在給customer改名時，很容易把下面的那個字符串忘掉，C#6.0 nameof幫我們解決了這個問題，看看新寫法
public static void AddCustomer(Customer customer)
{
if (customer == null)
{
throw new ArgumentNullException(nameof(customer));
}
}
7、帶索引的對象初始化器Index initializers
直接通過索引進行對象的初始化，原來真的可以實現
通過這種方式可以發現字典中只有三個元素，所以也就只有這三個索引可以訪問額，其他類型的對象和集合也是可以通過這種方式進行初始化的，在此就不進行一一列舉了。
8、異常過濾器 (Exception filters)
先來看一個移植過來的方法
try
{
var numbers = new Dictionary<int, string> {[7] = "seven",[9] = "nine",[13] = "thirteen" };
}
catch (ArgumentNullException e)
{
if (e.ParamName == "customer")
{
Console.WriteLine("customer can not be null");
}
}
在微軟的文檔中還給出了另一種用法，這個異常會在日志記錄失敗時拋給上一層調用者
private static bool Log(Exception e)
{
///處理一些日志
return false;
}
static void Main(string[] args)
{
try
{
///
}
catch (Exception e){if (!Log(e))
{
}
}
Console.ReadLine();
}
9、catch和finally 中的 await —— Await in catch and finally blocks
在C#5.0中，await關鍵字是不能出現在catch和finnaly塊中的。而在6.0中
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.
}
10、無參數的結構體構造函數—— Parameterless constructors in structs
C# 7.0
1. out 變量（out variables）
以前我們使用out變量必須在使用前進行聲明，C# 7.0 給我們提供了一種更簡潔的語法 “使用時進行內聯聲明” 。如下所示：
1 var input = ReadLine();
2 if (int.TryParse(input, out var result))
3 {
4 WriteLine("您輸入的數字是：{0}",result);
5 }
6 else
7 {
8 WriteLine("無法解析輸入...");
9 }
上面代碼編譯后：
1 int num;
2 string s = Console.ReadLine();
3 if (int.TryParse(s, out num))
4 {
5 Console.WriteLine("您輸入的數字是：{0}", num);
6 }
7 else
8 {
9 Console.WriteLine("無法解析輸入...");
10 }
原理解析：所謂的 “內聯聲明” 編譯后就是以前的原始寫法，只是現在由編譯器來完成。
備注：在進行內聯聲明時，即可直接寫明變量的類型也可以寫隱式類型，因為out關鍵字修飾的一定是局部變量。
2. 元組（Tuples）
元組（Tuple）在 .Net 4.0 的時候就有了，但元組也有些缺點，如：
1）Tuple 會影響代碼的可讀性，因為它的屬性名都是：Item1，Item2.. 。
2）Tuple 還不夠輕量級，因為它是引用類型（Class）。
備注：上述所指 Tuple 還不夠輕量級，是從某種意義上來說的或者是一種假設，即假設分配操作非常的多。
C# 7 中的元組（ValueTuple）解決了上述兩個缺點：
1）ValueTuple 支持語義上的字段命名。
2）ValueTuple 是值類型（Struct）。
1. 如何創建一個元組？
1 var tuple = (1, 2); // 使用語法糖創建元組
2 var tuple2 = ValueTuple.Create(1, 2); // 使用靜態方法【Create】創建元組
3 var tuple3 = new ValueTuple<int, int>(1, 2); // 使用 new 運算符創建元組
4
5 WriteLine($"first：{tuple.Item1}, second：{tuple.Item2}, 上面三種方式都是等價的。");
原理解析：上面三種方式最終都是使用 new 運算符來創建實例。
2. 如何創建給字段命名的元組？
1 // 左邊指定字段名稱
2 (int one, int two) tuple = (1, 2);
3 WriteLine($"first：{tuple.one}, second：{tuple.two}");
4
5 // 右邊指定字段名稱
6 var tuple2 = (one: 1, two: 2);
7 WriteLine($"first：{tuple2.one}, second：{tuple2.two}");
8
9 // 左右兩邊同時指定字段名稱
10 (int one, int two) tuple3 = (first: 1, second: 2); /* 此處會有警告：由於目標類型（xx）已指定了其它名稱，因為忽略元組名稱xxx */
11 WriteLine($"first：{tuple3.one}, second：{tuple3.two}");
注：左右兩邊同時指定字段名稱，會使用左邊的字段名稱覆蓋右邊的字段名稱（一一對應）。
原理解析：上述給字段命名的元組在編譯后其字段名稱還是：Item1, Item2...，即：“命名”只是語義上的命名。
3. 什么是解構？
解構顧名思義就是將整體分解成部分。
4. 解構元組，如下所示：
1 var (one, two) = GetTuple();
2
3 WriteLine($"first：{one}, second：{two}");
1 static (int, int) GetTuple()
2 {
3 return (1, 2);
4 }
原理解析：解構元組就是將元組中的字段值賦值給聲明的局部變量（編譯后可查看）。
備注：在解構時“=”左邊能提取變量的數據類型（如上所示），元組中字段類型相同時即可提取具體類型也可以是隱式類型，但元組中字段類型
不相同時只能提取隱式類型。
5. 解構可以應用於 .Net 的任意類型，但需要編寫 Deconstruct 方法成員（實例或擴展）。如下所示：
1 public class Student
2 {
3 public Student(string name, int age)
4 {
5 Name = name;
6 Age = age;
7 }
8
9 public string Name { get; set; }
10
11 public int Age { get; set; }
12
13 public void Deconstruct(out string name, out int age)
14 {
15 name = Name;
16 age = Age;
17 }
18 }
使用方式如下：
1 var (Name, Age) = new Student("Mike", 30);
2
3 WriteLine($"name：{Name}, age：{Age}");
原理解析：編譯后就是由其實例調用 Deconstruct 方法，然后給局部變量賦值。
Deconstruct 方法簽名：
1 // 實例簽名 2 public void Deconstruct(out type variable1, out type variable2...) 3 4 // 擴展簽名 5 public static void Deconstruct(this type instance, out type variable1, out type variable2...)
總結：1. 元組的原理是利用了成員類型的嵌套或者是說成員類型的遞歸。2. 編譯器很牛B才能提供如此優美的語法。
使用 ValueTuple 則需要導入: Install - Package System.ValueTuple
3. 模式匹配（Pattern matching）
1. is 表達式（is expressions），如：
1 static int GetSum(IEnumerable<object> values)
2 {
3 var sum = 0;
4 if (values == null) return sum;
5
6 foreach (var item in values)
7 {
8 if (item is short) // C# 7 之前的 is expressions
9 {
10 sum += (short)item;
11 }
12 else if (item is int val) // C# 7 的 is expressions
13 {
14 sum += val;
15 }
16 else if (item is string str && int.TryParse(str, out var result)) // is expressions 和 out variables 結合使用
17 {
18 sum += result;
19 }
20 else if (item is IEnumerable<object> subList)
21 {
22 sum += GetSum(subList);
23 }
24 }
25
26 return sum;
27 }
使用方法：
1 條件控制語句（obj is type variable）
2 {
3 // Processing...
4 }
原理解析：此 is 非彼 is ，這個擴展的 is 其實是 as 和 if 的組合。即它先進行 as 轉換再進行 if 判斷，判斷其結果是否為 null，不等於 null 則執行
語句塊邏輯，反之不行。由上可知其實C# 7之前我們也可實現類似的功能，只是寫法上比較繁瑣。
2. switch語句更新（switch statement updates），如：
1 static int GetSum(IEnumerable<object> values)
2 {
3 var sum = 0;
4 if (values == null) return 0;
5
6 foreach (var item in values)
7 {
8 switch (item)
9 {
10 case 0: // 常量模式匹配
11 break;
12 case short sval: // 類型模式匹配
13 sum += sval;
14 break;
15 case int ival:
16 sum += ival;
17 break;
18 case string str when int.TryParse(str, out var result): // 類型模式匹配 + 條件表達式
19 sum += result;
20 break;
21 case IEnumerable<object> subList when subList.Any():
22 sum += GetSum(subList);
23 break;
24 default:
25 throw new InvalidOperationException("未知的類型");
26 }
27 }
28
29 return sum;
30 }
使用方法：
1 switch (item)
2 {
3 case type variable1:
4 // processing...
5 break;
6 case type variable2 when predicate:
7 // processing...
8 break;
9 default:
10 // processing...
11 break;
12 }
原理解析：此 switch 非彼 switch，編譯后你會發現擴展的 switch 就是 as 、if 、goto 語句的組合體。同 is expressions 一樣，以前我們也能實
現只是寫法比較繁瑣並且可讀性不強。
總結：模式匹配語法是想讓我們在簡單的情況下實現類似與多態一樣的動態調用，即在運行時確定成員類型和調用具體的實現。
4. 局部引用和引用返回 (Ref locals and returns)
我們知道 C# 的 ref 和 out 關鍵字是對值傳遞的一個補充，是為了防止值類型大對象在Copy過程中損失更多的性能。現在在C# 7中 ref 關鍵字得
到了加強，它不僅可以獲取值類型的引用而且還可以獲取某個變量（引用類型）的局部引用。如：
1 static ref int GetLocalRef(int[,] arr, Func<int, bool> func)
2 {
3 for (int i = 0; i < arr.GetLength(0); i++)
4 {
5 for (int j = 0; j < arr.GetLength(1); j++)
6 {
7 if (func(arr[i, j]))
8 {
9 return ref arr[i, j];
10 }
11 }
12 }
13
14 throw new InvalidOperationException("Not found");
15 }
Call：
1 int[,] arr = { { 10, 15 }, { 20, 25 } };
2 ref var num = ref GetLocalRef(arr, c => c == 20);
3 num = 600;
4
5 Console.WriteLine(arr[1, 0]);
Print results：
使用方法：
1. 方法的返回值必須是引用返回：
a) 聲明方法簽名時必須在返回類型前加上 ref 修飾。
b) 在每個 return 關鍵字后也要加上 ref 修飾，以表明是返回引用。
2. 分配引用（即賦值），必須在聲明局部變量前加上 ref 修飾，以及在方法返回引用前加上 ref 修飾。
注：C# 開發的是托管代碼，所以一般不希望程序員去操作指針。並由上述可知在使用過程中需要大量的使用 ref 來標明這是引用變量（編譯后其
實沒那么多），當然這也是為了提高代碼的可讀性。
總結：雖然 C# 7 中提供了局部引用和引用返回，但為了防止濫用所以也有諸多約束，如：
1. 你不能將一個值分配給 ref 變量，如：
1 ref int num = 10; // error：無法使用值初始化按引用變量
2. 你不能返回一個生存期不超過方法作用域的變量引用，如：
1 public ref int GetLocalRef(int num) => ref num; // error: 無法按引用返回參數，因為它不是 ref 或 out 參數
3. ref 不能修飾 “屬性” 和 “索引器”。
1 var list = new List<int>(); 2 ref var n = ref list.Count; // error: 屬性或索引器不能作為 out 或 ref 參數傳遞
原理解析：非常簡單就是指針傳遞，並且個人覺得此語法的使用場景非常有限，都是用來處理大對象的，目的是減少GC提高性能。
5. 局部函數（Local functions）
C# 7 中的一個功能“局部函數”，如下所示：
1 static IEnumerable<char> GetCharList(string str)
2 {
3 if (IsNullOrWhiteSpace(str))
4 throw new ArgumentNullException(nameof(str));
5
6 return GetList();
7
8 IEnumerable<char> GetList()
9 {
10 for (int i = 0; i < str.Length; i++)
11 {
12 yield return str[i];
13 }
14 }
15 }
使用方法：
1 [數據類型,void] 方法名（[參數]）
2 {
3 // Method body；[] 里面都是可選項
4 }
原理解析：局部函數雖然是在其他函數內部聲明，但它編譯后就是一個被 internal 修飾的靜態函數，它是屬於類，至於它為什么能夠使用上級函
數中的局部變量和參數呢？那是因為編譯器會根據其使用的成員生成一個新類型（Class/Struct）然后將其傳入函數中。由上可知則局部函數的聲
明跟位置無關，並可無限嵌套。
總結：個人覺得局部函數是對 C# 異常機制在語義上的一次補充（如上例），以及為代碼提供清晰的結構而設置的語法。但局部函數也有其缺點，
就是局部函數中的代碼無法復用（反射除外）。
6. 更多的表達式體成員（More expression-bodied members）
C# 6 的時候就支持表達式體成員，但當時只支持“函數成員”和“只讀屬性”，這一特性在C# 7中得到了擴展，它能支持更多的成員：構造函數
、析構函數、帶 get，set 訪問器的屬性、以及索引器。如下所示：
1 public class Student
2 {
3 private string _name;
4
5 // Expression-bodied constructor
6 public Student(string name) => _name = name;
7
8 // Expression-bodied finalizer
9 ~Student() => Console.WriteLine("Finalized!");
10
11 // Expression-bodied get / set accessors.
12 public string Name
13 {
14 get => _name;
15 set => _name = value ?? "Mike";
16 }
17
18 // Expression-bodied indexers
19 public string this[string name] => Convert.ToBase64String(Encoding.UTF8.GetBytes(name));
20 }
備注：索引器其實在C# 6中就得到了支持，但其它三種在C# 6中未得到支持。
7. Throw 表達式（Throw expressions）
異常機制是C#的重要組成部分，但在以前並不是所有語句都可以拋出異常的，如：條件表達式（？ ：）、null合並運算符（??）、一些Lambda
表達式。而使用 C# 7 您可在任意地方拋出異常。如：
1 public class Student
2 {
3 private string _name = GetName() ?? throw new ArgumentNullException(nameof(GetName));
4
5 private int _age;
6
7 public int Age
8 {
9 get => _age;
10 set => _age = value <= 0 || value >= 130 ? throw new ArgumentException("參數不合法") : value;
11 }
12
13 static string GetName() => null;
14 }
8. 擴展異步返回類型（Generalized async return types）
以前異步的返回類型必須是：Task、Task<T>、void，現在 C# 7 中新增了一種類型：ValueTask<T>，如下所示：
1 public async ValueTask<int> Func()
2 {
3 await Task.Delay(3000);
4 return 100;
5 }
總結：ValueTask<T> 與 ValueTuple 非常相似，所以就不列舉： ValueTask<T> 與 Task 之間的異同了，但它們都是為了優化特定場景性能而
新增的類型。
使用 ValueTask<T> 則需要導入： Install - Package System.Threading.Tasks.Extensions
9. 數字文本語法的改進（Numeric literal syntax improvements）
C# 7 還包含兩個新特性：二進制文字、數字分隔符，如下所示：
1 var one = 0b0001; 2 var sixteen = 0b0001_0000; 3 4 long salary = 1000_000_000; 5 decimal pi = 3.141_592_653_589m;
注：二進制文本是以0b（零b）開頭，字母不區分大小寫；數字分隔符只有三個地方不能寫：開頭，結尾，小數點前后。
總結：二進制文本，數字分隔符 可使常量值更具可讀性。
2-6 處處： http://www.cnblogs.com/zq20/p/6323205.html
7 出處：http://www.cnblogs.com/VVStudy/