標簽：sync 集成 直接 exception turn win 封裝 any range
有一個東西叫做鴨子類型，所謂鴨子類型就是，只要一個東西表現得像鴨子那麽就能推出這玩意就是鴨子。
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。
public class MyTask<T>
{
public MyAwaiter<T> GetAwaiter()
{
return new MyAwaiter<T>();
}
}
public class MyAwaiter<T> : 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<int>();
await obj;
}
}
事实上，.NET Core 中的 I/O 相关的异步 API 也的确是这么做的，I/O 操作过程中是不会有任何线程分配等待结果的，都是 coroutine 操作：I/O 操作开始后直接让出控制权，直到 I/O 操作完毕。而之所以有的时候你发现 await 前後線程變了，那只是因爲 Task 本身被調度了。
UWP 开发中所用的 IAsyncAction/IAsyncOperation<T> 则是来自底层的封裝，和 Task 沒有任何關系但是是可以 await 的，并且如果用 C++/WinRT 开发 UWP 的话，返回这些接口的方法也都是可以 co_await 的。
IEnumerable 和 IEnumerator 才能被 foreach經常我們會寫如下的代碼：
foreach (var i in list)
{
// ......
}
然後一問爲什麽可以 foreach，大多都會回複因爲這個 list 實現了 IEnumerable 或者 IEnumerator。
但是實際上，如果想要一個對象可被 foreach，只需要提供一個 GetEnumerator() 方法，並且 GetEnumerator() 返回的對象包含一個 bool MoveNext() 方法加一個 Current 屬性即可。
class MyEnumerator<T>
{
public T Current { get; private set; }
public bool MoveNext()
{
throw new NotImplementedException();
}
}
class MyEnumerable<T>
{
public MyEnumerator<T> GetEnumerator()
{
throw new NotImplementedException();
}
}
class Program
{
public static void Main()
{
var x = new MyEnumerable<int>();
foreach (var i in x)
{
// ......
}
}
}
IAsyncEnumerable 和 IAsyncEnumerator 才能被 await foreach同上，但是這一次要求變了，GetEnumerator() 和 MoveNext() 變爲 GetAsyncEnumerator() 和 MoveNextAsync()。
其中 MoveNextAsync() 返回的東西應該是一個 Awaitable<bool>，至于這個 Awaitable 到底是什麽，它可以是 Task/ValueTask，也可以是其他的或者你自己實現的。
class MyAsyncEnumerator<T>
{
public T Current { get; private set; }
public MyTask<bool> MoveNextAsync()
{
throw new NotImplementedException();
}
}
class MyAsyncEnumerable<T>
{
public MyAsyncEnumerator<T> GetAsyncEnumerator()
{
throw new NotImplementedException();
}
}
class Program
{
public static async Task Main()
{
var x = new MyAsyncEnumerable<int>();
await foreach (var i in x)
{
// ......
}
}
}
ref struct 要怎麽實現 IDisposable衆所周知 ref struct 因爲必須在棧上且不能被裝箱，所以不能實現接口，但是如果你的 ref struct 中有一個 void Dispose() 那麽就可以用 using 語法實現對象的自動銷毀。
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) 方法），那麽就可以用該特性。
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 參數的索引器），那麽就可以用該特性。
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 的即可。
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;
}
}
IEnumerable才能用 LINQLINQ是C#中常用的一種集成查詢語言，允許你這樣寫代碼：
from c in list where c.Id > 5 select c;
但是上述代碼中的 list 的類型不一定非得實現 IEnumerable，事實上，只要有對應名字的擴展方法就可以了，比如有了叫做 Select的方法就能用 select，有了叫做 Where的方法就能用 where 。
class Just<T> : Maybe<T>
{
private readonly T value;
public Just(T value) { this.value = value; }
public override Maybe<U> Select<U>(Func<T, Maybe<U>> f) => f(value);
public override string ToString() => $"Just {value}";
}
class Nothing<T> : Maybe<T>
{
public override Maybe<U> Select<U>(Func<T, Maybe<U>> _) => new Nothing<U>();
public override string ToString() => "Nothing";
}
abstract class Maybe<T>
{
public abstract Maybe<U> Select<U>(Func<T, Maybe<U>> f);
public Maybe<V> SelectMany<U, V>(Func<T, Maybe<U>> k, Func<T, U, V> s)
=> Select(x => k(x).Select(y => new Just<V>(s(x, y))));
public Maybe<U> Where(Func<Maybe<T>, bool> f) => f(this) ? this : new Nothing<T>();
}
class Program
{
public static void Main()
{
var x = new Just<int>(3);
var y