2008 年前後的 Midori 專案試圖構建一個以 .NET 為使用者態基礎的作業系統，在這個專案中有很多讓 CLR 以及 C# 的型別系統向著適合系統程式設計的方向改進的探索，雖然專案最終沒有面世，但是積累了很多的成果。近些年由於 .NET 團隊在高效能和零開銷設施上的需要，從 2017 年開始，這些成果逐漸被加入 CLR 和 C# 中，從而能夠讓 .NET 團隊將原先大量的 C++ 基礎庫函數用 C# 重寫，不僅能減少互操作的開銷，還允許 JIT 進行 inline 等優化。
與常識可能不同，將原先 C++ 的函數重寫成 C# 之後，帶來的結果反而是大幅提升了執行效率。例如 Visual Studio 2019 的 16.5 版本將原先 C++ 實現的查詢與替換功能用 C# 重寫之後，更是帶來了超過 10 倍的效能提升，在十萬多個檔案中利用正規表示式查詢字串從原來的 4 分多鐘減少只需要 20 多秒。
目前已經到了 .NET 7 和 C# 11，我們已經能找到大量的相關設施，不過我們仍處在改進程序的中途。
本文則利用目前為止已有的設施，講講如何在 .NET 中進行零開銷的抽象。
首先我們來通過以下的不完全介紹來熟悉一下部分基礎設施。
ref、out、in 和 ref readonly談到 ref 和 out，相信大多數人都不會陌生，畢竟這是從 C# 1 開始就存在的東西。這其實就是記憶體安全的指標，允許我們在記憶體安全的前提之下，享受到指標的功能：
void Foo(ref int x)
{
x++;
}
int x = 3;
ref int y = ref x;
y = 4;
Console.WriteLine(x); // 4
Foo(ref y);
Console.WriteLine(x); // 5
而 out 則多用於傳遞函數的結果，非常類似 C/C++ 以及 COM 中返回撥用是否成功，而實際資料則通過引數裡的指標傳出的方法：
bool TryGetValue(out int x)
{
if (...)
{
x = default;
return false;
}
x = 42;
return true;
}
if (TryGetValue(out int x))
{
Console.WriteLine(x);
}
in 則是在 C# 7 才引入的，相對於 ref 而言，in 提供了唯讀參照的功能。通過 in 傳入的引數會通過參照方式進行唯讀傳遞，類似 C++ 中的 const T*。
為了提升 in 的易用性，C# 為其加入了隱式參照傳遞的功能，即呼叫時不需要在呼叫處寫一個 in，編譯器會自動為你建立區域性變數並傳遞對該變數的參照：
void Foo(in Mat3x3 mat)
{
mat.X13 = 4.2f; // 錯誤，因為唯讀參照不能修改
}
// 編譯後會自動建立一個區域性變數儲存這個 new 出來的 Mat3x3
// 然後呼叫函數時會傳遞對該區域性變數的參照
Foo(new() { });
struct Mat3x3
{
public float X11, X12, X13, X21, X22, X23, X31, X32, X33;
}
當然，我們也可以像 ref 那樣使用 in，明確指出我們參照的是什麼東西：
Mat3x3 x = ...;
Foo(in x);
struct 預設的引數傳遞行為是傳遞值的拷貝，當傳遞的物件較大時（一般指多於 4 個欄位的物件），就會發生比較大的拷貝開銷，此時只需要利用唯讀參照的方法傳遞引數即可避免，提升程式的效能。
從 C# 7 開始，我們可以在方法中返回參照，例如：
ref int Foo(int[] array)
{
return ref array[3];
}
呼叫該函數時，如果通過 ref 方式呼叫，則會接收到返回的參照：
int[] array = new[] { 1, 2, 3, 4, 5 };
ref int x = ref Foo(array);
Console.WriteLine(x); // 4
x = 5;
Console.WriteLine(array[3]); // 5
否則表示接收值，與返回非參照沒有區別：
int[] array = new[] { 1, 2, 3, 4, 5 };
int x = Foo(array);
Console.WriteLine(x); // 4
x = 5;
Console.WriteLine(array[3]); // 4
與 C/C++ 的指標不同的是，C# 中通過 ref 顯式標記一個東西是否是參照，如果沒有標記 ref，則一定不會是參照。
當然，配套而來的便是返回唯讀參照，確保返回的參照是不可修改的。與 ref 一樣，ref readonly 也是可以作為變數來使用的：
ref readonly int Foo(int[] array)
{
return ref array[3];
}
int[] array = new[] { 1, 2, 3, 4, 5 };
ref readonly int x = ref Foo(array);
x = 5; // 錯誤
ref readonly int y = ref array[1];
y = 3; // 錯誤
ref structC# 7.2 引入了一種新的型別：ref struct。這種型別由編譯器和執行時同時確保絕對不會被裝箱，因此這種型別的範例的生命週期非常明確，它只可能在棧記憶體中，而不可能出現在堆記憶體中：
Foo[] foos = new Foo[] { new(), new() }; // 錯誤
ref struct Foo
{
public int X;
public int Y;
}
藉助 ref struct，我們便能在 ref struct 中儲存參照，而無需擔心 ref struct 的範例因為生命週期被意外延長而導致出現無效參照。
Span<T>、ReadOnlySpan<T>從 .NET Core 2.1 開始，.NET 引入了 Span<T> 和 ReadOnlySpan<T> 這兩個型別來表示對一段連續記憶體的參照和唯讀參照。
Span<T> 和 ReadOnlySpan<T> 都是 ref struct，因此他們絕對不可能被裝箱，這確保了只要在他們自身的生命週期內，他們所參照的記憶體絕對都是有效的，因此藉助這兩個型別，我們可以代替指標來安全地操作任何連續記憶體。
Span<int> x = new[] { 1, 2, 3, 4, 5 };
x[2] = 0;
void* ptr = NativeMemory.Alloc(1024);
Span<int> y = new Span<int>(ptr, 1024 / sizeof(int));
y[4] = 42;
NativeMemory.Free(ptr);
我們還可以在 foreach 中使用 ref 和 ref readonly 來以參照的方式存取各成員：
Span<int> x = new[] { 1, 2, 3, 4, 5 };
foreach (ref int i in x) i++;
foreach (int i in x) Console.WriteLine(i); // 2 3 4 5 6
stackalloc在 C# 中，除了 new 之外，我們還有一個關鍵字 stackalloc，允許我們在棧記憶體上分配陣列：
Span<int> array = stackalloc[] { 1, 2, 3, 4, 5 };
這樣我們就成功在棧上分配出了一個陣列，這個陣列的生命週期就是所在程式碼塊的生命週期。
ref field我們已經能夠在區域性變數中使用 ref 和 ref readonly 了，自然，我們就想要在欄位中也使用這些東西。因此我們在 C# 11 中迎來了 ref 和 ref readonly 欄位。
欄位的生命週期與包含該欄位的型別的範例相同，因此，為了確保安全，ref 和 ref readonly 必須在 ref struct 中定義，這樣才能確保這些欄位參照的東西一定是有效的：
int x = 1;
Foo foo = new Foo(ref x);
foo.X = 2;
Console.WriteLine(x); // 2
Bar bar = new Bar { X = ref foo.X };
x = 3;
Console.WriteLine(bar.X); // 3
bar.X = 4; // 錯誤
ref struct Foo
{
public ref int X;
public Foo(ref int x)
{
X = ref x;
}
}
ref struct Bar
{
public ref readonly int X;
}
當然，上面的 Bar 裡我們展示了對唯讀內容的參照，但是欄位本身也可以是唯讀的，於是我們就還有：
ref struct Bar
{
public ref int X; // 參照可變內容的可變欄位
public ref readonly int Y; // 參照唯讀內容的可變欄位
public readonly ref int Z; // 參照可變內容的唯讀欄位
public readonly ref readonly int W; // 參照唯讀內容的唯讀欄位
}
scoped 和 UnscopedRef我們再看看上面這個例子的 Foo，這個 ref struct 中有接收參照作為引數的建構函式，這次我們不再在欄位中儲存參照：
Foo Test()
{
Span<int> x = stackalloc[] { 1, 2, 3, 4, 5 };
Foo foo = new Foo(ref x[0]); // 錯誤
return foo;
}
ref struct Foo
{
public Foo(ref int x)
{
x++;
}
}
你會發現這時程式碼無法編譯了。
因為 stackalloc 出來的東西僅在 Test 函數的生命週期內有效，但是我們有可能在 Foo 的建構函式中將 ref int x 這一參照儲存到 Foo 的欄位中，然後由於 Test 方法返回了 foo，這使得 foo 的生命週期被擴充套件到了呼叫 Test 函數的函數上，有可能導致本身應該在 Test 結束時就釋放的 x[0] 的生命週期被延長，從而出現無效參照。因此編譯器拒絕編譯了。
你可能會好奇，編譯器在理論上明明可以檢測到底有沒有實際的程式碼在欄位中儲存了參照，為什麼還是直接報錯了？這是因為，如果需要檢測則需要實現複雜度極其高的過程分析，不僅會大幅拖慢編譯速度，而且還存在很多無法靜態處理的邊緣情況。
那要怎麼處理呢？這個時候 scoped 就出場了：
Foo Test()
{
Span<int> x = stackalloc[] { 1, 2, 3, 4, 5 };
Foo foo = new Foo(ref x[0]);
return foo;
}
ref struct Foo
{
public Foo(scoped ref int x)
{
x++;
}
}
我們只需要在 ref 前加一個 scoped，顯式標註出 ref int x 的生命週期不會超出該函數，這樣我們就能通過編譯了。
此時，如果我們試圖在欄位中儲存這個參照的話，編譯器則會有效的指出錯誤：
ref struct Foo
{
public ref int X;
public Foo(scoped ref int x)
{
X = ref x; // 錯誤
}
}
同樣的，我們還可以在區域性變數中配合 ref 或者 ref readonly 使用 scoped：
Span<int> a = stackalloc[] { 1, 2, 3, 4, 5 };
scoped ref int x = ref a[0];
scoped ref readonly int y = ref a[1];
foreach (scoped ref int i in a) i++;
foreach (scoped ref readonly int i in a) Console.WriteLine(i); // 2 3 4 5 6
x++;
Console.WriteLine(a[0]); // 3
a[1]++;
Console.WriteLine(y); // 4
當然，上面這個例子中即使不加 scoped，也是預設 scoped 的，這裡標出來只是為了演示，實際上與下面的程式碼等價：
Span<int> a = stackalloc[] { 1, 2, 3, 4, 5 };
ref int x = ref a[0];
ref readonly int y = ref a[1];
foreach (ref int i in a) i++;
foreach (ref readonly int i in a) Console.WriteLine(i); // 2 3 4 5 6
x++;
Console.WriteLine(a[0]); // 3
a[1]++;
Console.WriteLine(y); // 4
對於 ref struct 而言，由於其自身就是一種可以儲存參照的「類參照」型別，因此我們的 scoped 也可以用於 ref struct，表明該 ref struct 的生命週期就是當前函數：
Span<int> Foo(Span<int> s)
{
return s;
}
Span<int> Bar(scoped Span<int> s)
{
return s; // 錯誤
}
有時候我們希望在 struct 中返回 this 上成員的參照，但是由於 struct 的 this 有著預設的 scoped 生命週期，因此此時無法通過編譯。這個時候我們可以藉助 [UnscopedRef] 來將 this 的生命週期從當前函數延長到呼叫函數上：
Foo foo = new Foo();
foo.RefX = 42;
Console.WriteLine(foo.X); // 42
struct Foo
{
public int X;
[UnscopedRef]
public ref int RefX => ref X;
}
這對 out 也是同理的，因為 out 也是預設有 scoped 生命週期：
ref int Foo(out int i)
{
i = 42;
return ref i; // 錯誤
}
但是我們同樣可以新增 [UnscopedRef] 來擴充套件生命週期：
ref int Foo([UnscopedRef] out int i)
{
i = 42;
return ref i;
}
Unsafe、Marshal、MemoryMarshal、CollectionsMarshal、NativeMemory 和 Buffer在 .NET 中，我們有著非常多的工具函數，分佈在 Unsafe.*、Marshal.*、MemoryMarshal.*、CollectionsMarshal.*、NativeMemory.* 和 Buffer.* 中。利用這些工具函數，我們可以非常高效地在幾乎不直接使用指標的情況下，操作各類記憶體、參照和陣列、集合等等。當然，使用的前提是你有相關的知識並且明確知道你在幹什麼，不然很容易寫出不安全的程式碼，畢竟這裡面大多數 API 就是 unsafe 的。
例如消除掉邊界檢查的存取：
void Foo(Span<int> s)
{
Console.WriteLine(Unsafe.Add(ref MemoryMarshal.GetReference(s), 3));
}
Span<int> s = new[] { 1, 2, 3, 4, 5, 6 };
Foo(s); // 4
檢視生成的程式碼驗證：
G_M000_IG02: ;; offset=0004H
mov rcx, bword ptr [rcx]
mov ecx, dword ptr [rcx+0CH]
call [System.Console:WriteLine(int)]
可以看到，邊界檢查確實被消滅了，對比直接存取的情況：
void Foo(Span<int> s)
{
Console.WriteLine(s[3]);
}
G_M000_IG02: ;; offset=0004H
cmp dword ptr [rcx+08H], 3 ; <-- range check
jbe SHORT G_M000_IG04
mov rcx, bword ptr [rcx]
mov ecx, dword ptr [rcx+0CH]
call [System.Console:WriteLine(int)]
nop
G_M000_IG04: ;; offset=001CH
call CORINFO_HELP_RNGCHKFAIL
int3
再比如，直接獲取字典中成員的參照：
Dictionary<int, int> dict = new()
{
[1] = 7,
[2] = 42
};
// 如果存在則獲取參照，否則新增一個 default 進去然後再返回參照
ref int value = ref CollectionsMarshal.GetValueRefOrAddDefault(dict, 3, out bool exists);
value++;
Console.WriteLine(exists); // false
Console.WriteLine(dict[3]); // 1
如此一來，我們便不需要先呼叫 ContainsKey 再操作，只需要一次查詢即可完成我們需要的操作，而不是 ContainsKey 查詢一次，後續操作再查詢一次。
我們還可以用 Buffer.CopyMemory 來實現與 memcpy 等價的高效率陣列拷貝；再有就是前文中出現過的 NativeMemory，藉助此 API，我們可以手動分配非託管記憶體，並指定對齊方式、是否清零等引數。
C# 的 struct 允許我們利用 [StructLayout] 按位元組手動指定記憶體佈局，例如：
unsafe
{
Console.WriteLine(sizeof(Foo)); // 10
}
[StructLayout(LayoutKind.Explicit, Pack = 1)]
struct Foo
{
[FieldOffset(0)] public int X;
[FieldOffset(4)] public float Y;
[FieldOffset(0)] public long XY;
[FieldOffset(8)] public byte Z;
[FieldOffset(9)] public byte W;
}
上面的例子中我們將 X、Y 與 XY 的記憶體重疊，並且利用 Pack 指定了 padding 行為，使得 Foo 的長度為 10 位元組，而不是 12 位元組。
我們還有定長陣列：
Foo foo = new Foo();
foo.Color[1] = 42;
struct Foo
{
public unsafe fixed int Array[4];
}
此時，我們便有一個長度固定為 4 的陣列存在於 Foo 的欄位中，佔據 16 個位元組的長度。
.NET 7 中我們迎來了介面的虛靜態方法，這一特性加強了 C# 泛型的表達能力，使得我們可以更好地利用引數化多型來更高效地對程式碼進行抽象。
此前當遇到字串時，如果我們想要編寫一個方法來對字串進行解析，得到我們想要的型別的話，要麼需要針對各種過載都編寫一份，要麼寫成泛型方法，然後再在裡面判斷型別。兩種方法編寫起來都非常的麻煩：
int ParseInt(string str);
long ParseLong(string str);
float ParseFloat(string str);
// ...
或者：
T Parse<T>(string str)
{
if (typeof(T) == typeof(int)) return int.Parse(str);
if (typeof(T) == typeof(long)) return long.Parse(str);
if (typeof(T) == typeof(float)) return float.Parse(str);
// ...
}
儘管 JIT 有能力在編譯時消除掉多餘的分支（因為 T 在編譯時已知），編寫起來仍然非常費勁，並且無法處理沒有覆蓋到的情況。
但現在我們只需要利用介面的虛靜態方法，即可高效的對所有實現了 IParsable<T> 的型別實現這個 Parse 方法。.NET 標準庫中已經內建了不少相關型別，例如 System.IParsable<T> 的定義如下：
public interface IParsable<TSelf> where TSelf : IParsable<TSelf>?
{
abstract static TSelf Parse(string s, IFormatProvider? provider);
abstract static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out TSelf result);
}
那麼，我們只需要編寫一個：
T Parse<T>(string str) where T : IParsable<T>
{
return T.Parse(str, null);
}
即可。
這樣，哪怕是其他地方定義的型別，只要實現了 IParsable<T>，就能夠傳到這個方法中：
struct Point : IParsable<Point>
{
public int X, Y;
public static Point Parse(string s, IFormatProvider? provider) { ... }
public static bool TryParse(string? s, IFormatProvider? provider, out Point result) { ... }
}
當然，既然是虛靜態方法，那就意味著不僅僅可以是 abstract，更可以是 virtual 的，如此一來我們還可以提供自己的預設實現：
interface IFoo
{
virtual static void Hello() => Console.WriteLine("hello");
}
Dispose 和 IDisposable我們有時需要顯式地手動控制資源釋放，而不是一味地交給 GC 來進行處理，那麼此時我們的老朋友 Dispose 就派上用場了。
對於 class、struct 和 record 而言，我們需要為其實現 IDisposable 介面，而對於 ref struct 而言，我們只需要暴露一個 public void Dispose()。這樣一來，我們便可以用 using 來自動進行資源釋放。
例如：
// 在 foo 的作用域結束時自動呼叫 foo.Dispose()
using Foo foo = new Foo();
// ...
// 顯式指定 foo 的作用域
using (Foo foo = new Foo())
{
// ...
}
struct Foo : IDisposable
{
private void* memory;
private bool disposed;
public void Dispose()
{
if (disposed) return;
disposed = true;
NativeMemory.Free(memory);
}
}
異常是個好東西，但是也會對效率造成影響。因為異常在程式碼中通常是不常見的，因為 JIT 在編譯程式碼時，會將包含丟擲異常的程式碼認定為冷塊（即不會被怎麼執行的程式碼塊），這麼一來會影響 inline 的決策：
void Foo()
{
// ...
throw new Exception();
}
例如上面這個 Foo 方法，就很難被 inline 掉。
但是，我們可以將異常拿走放到單獨的方法中丟擲，這麼一來，拋異常的行為就被我們轉換成了普通的函數呼叫行為，於是就不會影響對 Foo 的 inline 優化，將冷塊從 Foo 轉移到了 Throw 中：
[DoesNotReturn] void Throw() => throw new Exception();
void Foo()
{
// ...
Throw();
}
考慮到目前 .NET 還沒有 bottom types 和 union types，當我們的 Foo 需要返回東西的時候，很顯然上面的程式碼會因為不是所有路徑都返回了東西而報錯，此時我們只需要將 Throw 的返回值型別改成我們想返回的型別，或者乾脆封裝成泛型方法然後傳入型別引數即可。因為 throw 在 C# 中隱含了不會返回的含義，編譯器遇到 throw 時知道這個是不會返回的，也就不會因為 Throw 沒有返回東西而報錯：
[DoesNotReturn] int Throw1() => throw new Exception();
[DoesNotReturn] T Throw2<T>() => throw new Exception();
int Foo1()
{
// ...
return Throw1();
}
int Foo2()
{
// ...
return Throw2<int>();
}
指標相信大家都不陌生，像 C/C++ 中的指標那樣，C# 中套一個 unsafe 就能直接用。唯一需要注意的地方是，由於 GC 可能會移動堆記憶體上的物件，所以在使用指標操作 GC 堆記憶體中的物件前，需要先使用 fixed 將其固定：
int[] array = new[] { 1, 2, 3, 4, 5 };
fixed (int* p = array)
{
Console.WriteLine(*(p + 3)); // 4
}
當然，指標不僅僅侷限於物件，函數也可以有函數指標：
delegate* managed<int, int, int> f = &Add;
Console.WriteLine(f(3, 4)); // 7
static int Add(int x, int y) => x + y;
函數指標也可以指向非託管方法，例如來自 C++ 庫中、有著 cdecl 呼叫約定的函數：
delegate* unmanaged[Cdecl]<int, int, int> f = ...;
進一步我們還可以指定 SuppressGCTransition 來取消做互操作時 GC 上下文的切換來提高效能。當然這是危險的，只有當被呼叫的函數能夠非常快完成時才能使用：
delegate* unmanaged[Cdecl, SuppressGCTransition]<int, int, int> f = ...;
SuppressGCTransition 同樣可以用於 P/Invoke：
[DllImport(...), SuppressGCTransition]
static extern void Foo();
[LibraryImport(...), SuppressGCTransition]
static partial void Foo();
IntPtr、UIntPtr、nint 和 nuintC# 中有兩個通過數值方式表示的指標型別：IntPtr 和 UIntPtr，分別是有符號和無符號的，並且長度等於當前程序的指標型別長度。由於長度與平臺相關的特性，它也可以用來表示 native 數值，因此誕生了 nint 和 nuint，底下分別是 IntPtr 和 UIntPtr，類似 C++ 中的 ptrdiff_t 和 size_t 型別。
這麼一來我們就可以方便地像使用其他的整數型別那樣對 native 數值型別運算：
nint x = -100;
nuint y = 200;
Console.WriteLine(x + (nint)y); //100
當然，寫成 IntPtr 和 UIntPtr 也是沒問題的：
IntPtr x = -100;
UIntPtr y = 200;
Console.WriteLine(x + (IntPtr)y); //100
SkipLocalsInitSkipLocalsInit 可以跳過 .NET 預設的分配時自動清零行為，當我們知道自己要幹什麼的時候，使用 SkipLocalsInit 可以節省掉記憶體清零的開銷：
[SkipLocalsInit]
void Foo1()
{
Guid guid;
unsafe
{
Console.WriteLine(*(Guid*)&guid);
}
}
void Foo2()
{
Guid guid;
unsafe
{
Console.WriteLine(*(Guid*)&guid);
}
}
Foo1(); // 一個不確定的 Guid
Foo2(); // 00000000-0000-0000-0000-000000000000
熟悉完 .NET 中的部分基礎設施，我們便可以來實際編寫一些程式碼了。
在大型應用中，我們偶爾會用到超出 GC 管理能力範圍的超大陣列（> 4G），當然我們可以選擇類似連結串列那樣拼接多個陣列，但除了這個方法外，我們還可以自行封裝出一個處理非託管記憶體的結構來使用。另外，這種需求在遊戲開發中也較為常見，例如需要將一段記憶體作為頂點緩衝區然後送到 GPU 進行處理，此時要求這段記憶體不能被移動。
那此時我們可以怎麼做呢？
首先我們可以實現基本的儲存、釋放和存取功能：
public sealed class NativeBuffer<T> : IDisposable where T : unmanaged
{
private unsafe T* pointer;
public nuint Length { get; }
public NativeBuffer(nuint length)
{
Length = length;
unsafe
{
pointer = (T*)NativeMemory.Alloc(length);
}
}
public NativeBuffer(Span<T> span) : this((nuint)span.Length)
{
unsafe
{
fixed (T* ptr = span)
{
Buffer.MemoryCopy(ptr, pointer, sizeof(T) * span.Length, sizeof(T) * span.Length);
}
}
}
[DoesNotReturn] private ref T ThrowOutOfRange() => throw new IndexOutOfRangeException();
public ref T this[nuint index]
{
get
{
unsafe
{
return ref (index >= Length ? ref ThrowOutOfRange() : ref (*(pointer + index)));
}
}
}
public void Dispose()
{
unsafe
{
// 判斷記憶體是否有效
if (pointer != (T*)0)
{
NativeMemory.Free(pointer);
pointer = (T*)0;
}
}
}
// 即使沒有呼叫 Dispose 也可以在 GC 回收時釋放資源
~NativeBuffer()
{
Dispose();
}
}
如此一來，使用時只需要簡單的：
NativeBuffer<int> buf = new(new[] { 1, 2, 3, 4, 5 });
Console.WriteLine(buf[3]); // 4
buf[2] = 9;
Console.WriteLine(buf[2]); // 9
// ...
buf.Dispose();
或者讓它在作用域結束時自動釋放：
using NativeBuffer<int> buf = new(new[] { 1, 2, 3, 4, 5 });
或者乾脆不管了，等待 GC 回收時自動呼叫我們的編寫的解構函式，這個時候就會從 ~NativeBuffer 呼叫 Dispose 方法。
緊接著，為了能夠使用 foreach 進行迭代，我們還需要實現一個 Enumerator，但是為了提升效率並且支援參照，此時我們選擇實現自己的 GetEnumerator。
首先我們實現一個 NativeBufferEnumerator：
public ref struct NativeBufferEnumerator
{
private unsafe readonly ref T* pointer;
private readonly nuint length;
private ref T current;
private nuint index;
public ref T Current
{
get
{
unsafe
{
// 確保指向的記憶體仍然有效
if (pointer == (T*)0)
{
return ref Unsafe.NullRef<T>();
}
else return ref current;
}
}
}
public unsafe NativeBufferEnumerator(ref T* pointer, nuint length)
{
this.pointer = ref pointer;
this.length = length;
this.index = 0;
this.current = ref Unsafe.NullRef<T>();
}
public bool MoveNext()
{
unsafe
{
// 確保沒有越界並且指向的記憶體仍然有效
if (index >= length || pointer == (T*)0)
{
return false;
}
if (Unsafe.IsNullRef(ref current)) current = ref *pointer;
else current = ref Unsafe.Add(ref current, 1);
}
index++;
return true;
}
}
然後只需要讓 NativeBuffer.GetEnumerator 方法返回我們的實現好的迭代器即可：
public NativeBufferEnumerator GetEnumerator()
{
unsafe
{
return new(ref pointer, Length);
}
}
從此，我們便可以輕鬆零分配地迭代我們的 NativeBuffer 了：
int[] buffer = new[] { 1, 2, 3, 4, 5 };
using NativeBuffer<int> nb = new(buffer);
foreach (int i in nb) Console.WriteLine(i); // 1 2 3 4 5
foreach (ref int i in nb) i++;
foreach (int i in nb) Console.WriteLine(i); // 2 3 4 5 6
並且由於我們的迭代器中儲存著對 NativeBuffer.pointer 的參照，如果 NativeBuffer 被釋放了，執行了一半的迭代器也能及時發現並終止迭代：
int[] buffer = new[] { 1, 2, 3, 4, 5 };
NativeBuffer<int> nb = new(buffer);
foreach (int i in nb)
{
Console.WriteLine(i); // 1
nb.Dispose();
}
我們經常會需要儲存結構化資料，例如在進行圖片處理時，我們經常需要儲存顏色資訊。這個顏色可能是直接從檔案資料中讀取得到的。那麼此時我們便可以封裝一個 Color 來代表顏色資料 RGBA：
[StructLayout(LayoutKind.Sequential)]
public struct Color : IEquatable<Color>
{
public byte R, G, B, A;
public Color(byte r, byte g, byte b, byte a = 0)
{
R = r;
G = g;
B = b;
A = a;
}
public override int GetHashCode() => HashCode.Combine(R, G, B, A);
public override string ToString() => $"Color {{ R = {R}, G = {G}, B = {B}, A = {A} }}";
public override bool Equals(object? other) => other is Color color ? Equals(color) : false;
public bool Equals(Color other) => (R, G, B, A) == (other.R, other.G, other.B, other.A);
}
這麼一來我們就有能表示顏色資料的型別了。但是這麼做還不夠，我們需要能夠和二進位制資料或者字串編寫的顏色值相互轉換，因此我們編寫 Serialize、Deserialize 和 Parse 方法來進行這樣的事情：
[StructLayout(LayoutKind.Sequential)]
public struct Color : IParsable<Color>, IEquatable<Color>
{
public static byte[] Serialize(Color color)
{
unsafe
{
byte[] buffer = new byte[sizeof(Color)];
MemoryMarshal.Write(buffer, ref color);
return buffer;
}
}
public static Color Deserialize(ReadOnlySpan<byte> data)
{
return MemoryMarshal.Read<Color>(data);
}
[DoesNotReturn] private static void ThrowInvalid() => throw new InvalidDataException("Invalid color string.");
public static Color Parse(string s, IFormatProvider? provider = null)
{
if (s.Length is not 7 and not 9 || (s.Length > 0 && s[0] != '#'))
{
ThrowInvalid();
}
return new()
{
R = byte.Parse(s[1..3], NumberStyles.HexNumber, provider),
G = byte.Parse(s[3..5], NumberStyles.HexNumber, provider),
B = byte.Parse(s[5..7], NumberStyles.HexNumber, provider),
A = s.Length is 9 ? byte.Parse(s[7..9], NumberStyles.HexNumber, provider) : default
};
}
public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Color result)
{
result = default;
if (s?.Length is not 7 and not 9 || (s.Length > 0 && s[0] != '#'))
{
return false;
}
Color color = new Color();
return byte.TryParse(s[1..3], NumberStyles.HexNumber, provider, out color.R)
&& byte.TryParse(s[3..5], NumberStyles.HexNumber, provider, out color.G)
&& byte.TryParse(s[5..7], NumberStyles.HexNumber, provider, out color.B)
&& (s.Length is 9 ? byte.TryParse(s[7..9], NumberStyles.HexNumber, provider, out color.A) : true);
}
}
接下來，我們再實現一個 ColorView，允許以多種方式對 Color 進行存取和修改：
public ref struct ColorView
{
private readonly ref Color color;
public ColorView(ref Color color)
{
this.color = ref color;
}
[DoesNotReturn] private static ref byte ThrowOutOfRange() => throw new IndexOutOfRangeException();
public ref byte R => ref color.R;
public ref byte G => ref color.G;
public ref byte B => ref color.B;
public ref byte A => ref color.A;
public ref uint Rgba => ref Unsafe.As<Color, uint>(ref color);
public ref byte this[int index]
{
get
{
switch (index)
{
case 0:
return ref color.R;
case 1:
return ref color.G;
case 2:
return ref color.B;
case 3:
return ref color.A;
default:
return ref ThrowOutOfRange();
}
}
}
public ColorViewEnumerator GetEnumerator()
{
return new(this);
}
public ref struct ColorViewEnumerator
{
private readonly ColorView view;
private int index;
public ref byte Current => ref view[index];
public ColorViewEnumerator(ColorView view)
{
this.index = -1;
this.view = view;
}
public bool MoveNext()
{
if (index >= 3) return false;
index++;
return true;
}
}
}
然後我們給 Color 新增一個 CreateView() 方法即可：
public ColorView CreateView() => new(ref this);
如此一來，我們便能夠輕鬆地通過不同檢視來操作 Color 資料，並且一切抽象都是零開銷的：
Console.WriteLine(Color.Parse("#FFEA23")); // Color { R = 255, G = 234, B = 35, A = 0 }
Color color = new(255, 128, 42, 137);
ColorView view = color.CreateView();
Console.WriteLine(color); // Color { R = 255, G = 128, B = 42, A = 137 }
view.R = 7;
view[3] = 28;
Console.WriteLine(color); // Color { R = 7, G = 128, B = 42, A = 28 }
view.Rgba = 3072;
Console.WriteLine(color); // Color { R = 0, G = 12, B = 0, A = 0 }
foreach (ref byte i in view) i++;
Console.WriteLine(color); // Color { R = 1, G = 13, B = 1, A = 1 }
C# 是一門自動擋手動擋同時具備的語言，上限極高的同時下限也極低。可以看到上面的幾個例子中，儘管封裝所需要的程式碼較為複雜，但是到了使用的時候就如同一切的底層程式碼全都消失了一樣，各種語法糖加持之下，不僅僅用起來非常的方便快捷，而且藉助零開銷抽象，程式碼的記憶體效率和執行效率都能達到 C++、Rust 的水平。此外，現在的 .NET 7 有了 NativeAOT 之後更是能直接編譯到本機程式碼，執行時無依賴也完全不需要虛擬機器器，實現了與 C++、Rust 相同的應用形態。這些年來 .NET 在不同的平臺、不同工作負載上均有著數一數二的執行效率表現的理由也是顯而易見的。
而程式碼封裝的髒活則是由各庫的作者來完成的，大多數人在進行業務開發時，無需接觸和關係這些底層的東西，甚至哪怕什麼都不懂都可以輕鬆使用封裝好的庫，站在這些低開銷甚至零開銷的抽象基礎之上來進行應用的構建。
以上便是對 .NET 中進行零開銷抽象的一些簡單介紹，在開發中的區域性熱點利用這些技巧能夠大幅度提升執行效率和記憶體效率。