你所不知道的 C# 中的細節
阿新 • • 發佈：2020-03-31
## 前言
有一個東西叫做鴨子型別，所謂鴨子型別就是，只要一個東西表現得像鴨子那麼就能推出這玩意就是鴨子。
C# 裡面其實也暗藏了很多類似鴨子型別的東西，但是很多開發者並不知道，因此也就沒法好好利用這些東西，那麼今天我細數一下這些藏在編譯器中的細節。
## 不是隻有 `Task` 和 `ValueTask` 才能 `await`
在 C# 中編寫非同步程式碼的時候，我們經常會選擇將非同步程式碼包含在一個 `Task` 或者 `ValueTask` 中，這樣呼叫者就能用 `await` 的方式實現非同步呼叫。
西卡西，並不是只有 `Task` 和 `ValueTask` 才能 `await`。`Task` 和 `ValueTask` 背後明明是由執行緒池參與排程的，可是為什麼 C# 的 `async`/`await` 卻被說成是 `coroutine` 呢？
因為你所 `await` 的東西不一定是 `Task`/`ValueTask`，在 C# 中只要你的類中包含 `GetAwaiter()` 方法和 `bool IsCompleted` 屬性，並且 `GetAwaiter()` 返回的東西包含一個 `GetResult()` 方法、一個 `bool IsCompleted` 屬性和實現了 `INotifyCompletion`，那麼這個類的物件就是可以 `await` 的 。
因此在封裝 I/O 操作的時候，我們可以自行實現一個 `Awaiter`，它基於底層的 `epoll`/`IOCP` 實現，這樣當 `await` 的時候就不會創建出任何的執行緒，也不會出現任何的執行緒排程，而是直接讓出控制權。而 OS 在完成 I/O 呼叫後通過 `CompletionPort` (Windows) 等通知使用者態完成非同步呼叫，此時恢復上下文繼續執行剩餘邏輯，這其實就是一個真正的 `stackless coroutine`。
```csharp
public class MyTask
{
public MyAwaiter GetAwaiter()
{
return new MyAwaiter();
}
}
public class MyAwaiter : INotifyCompletion
{
public bool IsCompleted { get; private set; }
public T GetResult()
{
throw new NotImplementedException();
}
public void OnCompleted(Action continuation)
{
throw new NotImplementedException();
}
}
public class Program
{
static async Task Main(string[] args)
{
var obj = new MyTask();
await obj;
}
}
```
事實上，.NET Core 中的 I/O 相關的非同步 API 也的確是這麼做的，I/O 操作過程中是不會有任何執行緒分配等待結果的，都是 `coroutine` 操作：I/O 操作開始後直接讓出控制權，直到 I/O 操作完畢。而之所以有的時候你發現 `await` 前後執行緒變了，那只是因為 `Task` 本身被排程了。
UWP 開發中所用的 `IAsyncAction`/`IAsyncOperation` 則是來自底層的封裝，和 `Task` 沒有任何關係但是是可以 `await` 的，並且如果用 C++/WinRT 開發 UWP 的話，返回這些介面的方法也都是可以 `co_await` 的。
## 不是隻有 `IEnumerable` 和 `IEnumerator` 才能被 `foreach`
經常我們會寫如下的程式碼：
```csharp
foreach (var i in list)
{
// ......
}
```
然後一問為什麼可以 `foreach`，大多都會回覆因為這個 `list` 實現了 `IEnumerable` 或者 `IEnumerator`。
但是實際上，如果想要一個物件可被 `foreach`，只需要提供一個 `GetEnumerator()` 方法，並且 `GetEnumerator()` 返回的物件包含一個 `bool MoveNext()` 方法加一個 `Current` 屬性即可。
```csharp
class MyEnumerator
{
public T Current { get; private set; }
public bool MoveNext()
{
throw new NotImplementedException();
}
}
class MyEnumerable
{
public MyEnumerator GetEnumerator()
{
throw new NotImplementedException();
}
}
class Program
{
public static void Main()
{
var x = new MyEnumerable();
foreach (var i in x)
{
// ......
}
}
}
```
## 不是隻有 `IAsyncEnumerable` 和 `IAsyncEnumerator` 才能被 `await foreach`
同上，但是這一次要求變了，`GetEnumerator()` 和 `MoveNext()` 變為 `GetAsyncEnumerator()` 和 `MoveNextAsync()`。
其中 `MoveNextAsync()` 返回的東西應該是一個 `Awaitable`，至於這個 `Awaitable` 到底是什麼，它可以是 `Task`/`ValueTask`，也可以是其他的或者你自己實現的。
```csharp
class MyAsyncEnumerator
{
public T Current { get; private set; }
public MyTask MoveNextAsync()
{
throw new NotImplementedException();
}
}
class MyAsyncEnumerable
{
public MyAsyncEnumerator GetAsyncEnumerator()
{
throw new NotImplementedException();
}
}
class Program
{
public static async Task Main()
{
var x = new MyAsyncEnumerable();
await foreach (var i in x)
{
// ......
}
}
}
```
## `ref struct` 要怎麼實現 `IDisposable`
眾所周知 `ref struct` 因為必須在棧上且不能被裝箱，所以不能實現介面，但是如果你的 `ref struct` 中有一個 `void Dispose()` 那麼就可以用 `using` 語法實現物件的自動銷燬。
```csharp
ref struct MyDisposable
{
public void Dispose() => throw new NotImplementedException();
}
class Program
{
public static void Main()
{
using var y = new MyDisposable();
// ......
}
}
```
## 不是隻有 `Range` 才能使用切片
C# 8 引入了 Ranges，允許切片操作，但是其實並不是必須提供一個接收 `Range` 型別引數的 indexer 才能使用該特性。
只要你的類可以被計數（擁有 `Length` 或 `Count` 屬性），並且可以被切片（擁有一個 `Slice(int, int)` 方法），那麼就可以用該特性。
```csharp
class MyRange
{
public int Count { get; private set; }
public object Slice(int x, int y) => throw new NotImplementedException();
}
class Program
{
public static void Main()
{
var x = new MyRange();
var y = x[1..];
}
}
```
## 不是隻有 `Index` 才能使用索引
C# 8 引入了 Indexes 用於索引，例如使用 `^1` 索引倒數第一個元素，但是其實並不是必須提供一個接收 `Index` 型別引數的 indexer 才能使用該特性。
只要你的類可以被計數（擁有 `Length` 或 `Count` 屬性），並且可以被索引（擁有一個接收 `int` 引數的索引器），那麼就可以用該特性。
```csharp
class MyIndex
{
public int Count { get; private set; }
public object this[int index]
{
get => throw new NotImplementedException();
}
}
class Program
{
public static void Main()
{
var x = new MyIndex();
var y = x[^1];
}
}
```
## 給型別實現解構
如何給一個型別實現解構呢？其實只需要寫一個名字為 `Deconstruct()` 的方法，並且引數都是 `out` 的即可。
```csharp
class MyDeconstruct
{
private int A => 1;
private int B => 2;
public void Deconstruct(out int a, out int b)
{
a = A;
b = B;
}
}
class Program
{
public static void Main()
{
var x = new MyDeconstruct();
var (o, u) = x;
}
}
```