深入淺析C#?11?對?ref?和?struct?的改進(jìn)
前言
C# 11 中即將到來一個可以讓重視性能的開發(fā)者狂喜的重量級特性，這個特性主要是圍繞著一個重要底層性能設(shè)施 ref 和 struct 的一系列改進(jìn)。
但是這部分的改進(jìn)涉及的內(nèi)容較多，不一定能在 .NET 7（C# 11）做完，因此部分內(nèi)容推遲到 C# 12 也是有可能的。當(dāng)然，還是很有希望能在 C# 11 的時間點就看到完全體的。
本文僅僅就這一個特性進(jìn)行介紹，因為 C# 11 除了本特性之外，還有很多其他的改進(jìn)，一篇文章根本說不完，其他那些我們就等到 .NET 7 快正式發(fā)布的時候再說吧。
背景
C# 自 7.0 版本引入了新的 ref struct 用來表示不可被裝箱的棧上對象，但是當(dāng)時局限性很大，甚至無法被用于泛型約束，也無法作為 struct 的字段。在 C# 11 中，由于特性 ref 字段的推動，需要允許類型持有其它值類型的引用，這方面的東西終于有了大幅度進(jìn)展。
這些設(shè)施旨在允許開發(fā)者使用安全的代碼編寫高性能代碼，而無需面對不安全的指針。接下來我就來對 C# 11 甚至 12 在此方面的即將到來的改進(jìn)進(jìn)行介紹。
ref 字段
C# 以前是不能在類型中持有對其它值類型的引用的，但是在 C# 11 中，這將變得可能。從 C# 11 開始，將允許 ref struct 定義 ref 字段。
readonly ref struct Span<T>
{
private readonly ref T _field;
private readonly int _length;
public Span(ref T value)
{
_field = ref value;
_length = 1;
}
}直觀來看，這樣的特性將允許我們寫出上面的代碼，這段代碼中構(gòu)造了一個 Span<T>，它持有了對其他 T 對象的引用。
當(dāng)然，ref struct 也是可以被 default 來初始化的：
Span<int> span = default;
但這樣 _field 就會是個空引用，不過我們可以通過 Unsafe.IsNullRef 方法來進(jìn)行檢查：
if (Unsafe.IsNullRef(ref _field))
{
throw new NullReferenceException(...);
}另外，ref字段的可修改性也是一個非常重要的事情，因此引入了：
readonly ref：一個對對象的只讀引用，這個引用本身不能在構(gòu)造方法或init方法之外被修改ref readonly：一個對只讀對象的引用，這個引用指向的對象不能在構(gòu)造方法或 init 方法之外被修改readonly ref readonly：一個對只讀對象的只讀引用，是上述兩種的組合
例如：
ref struct Foo
{
ref readonly int f1;
readonly ref int f2;
readonly ref readonly int f3;
void Bar(int[] array)
{
f1 = ref array[0]; // 沒問題
f1 = array[0]; // 錯誤，因為 f1 引用的值不能被修改
f2 = ref array[0]; // 錯誤，因為 f2 本身不能被修改
f2 = array[0]; // 沒問題
f3 = ref array[0]; // 錯誤：因為 f3 本身不能被修改
f3 = array[0]; // 錯誤：因為 f3 引用的值不能被修改
}
}生命周期
這一切看上去都很美好，但是真的沒有任何問題嗎？
假設(shè)我們有下面的代碼來使用上面的東西：
Span<int> Foo()
{
int v = 42;
return new Span<int>(ref v);
}v 是一個局部變量，在函數(shù)返回之后其生命周期就會結(jié)束，那么上面這段代碼就會導(dǎo)致 Span<int> 持有的 v 的引用變成無效的。順帶一提，上面這段代碼是完全合法的，因為 C# 之前不支持 ref 字段，因此上面的代碼是不可能出現(xiàn)逃逸問題的。但是 C# 11 加入了 ref 字段，棧上的對象就有可能通過 ref 字段而發(fā)生引用逃逸，于是代碼變得不安全。
如果我們有一個 CreateSpan 方法用來創(chuàng)建一個引用的 Span ：
Span<int> CreateSpan(ref int v)
{
// ...
}這就衍生出了一系列在以前的 C# 中沒問題（因為 ref 的生命周期為當(dāng)前方法），但是在 C# 11 中由于可能存在 ref 字段而導(dǎo)致用安全的方式寫出的非安全代碼：
Span<int> Foo(int v)
{
// 1
return CreateSpan(ref v);
// 2
int local = 42;
return CreateSpan(ref local);
// 3
Span<int> span = stackalloc int[42];
return CreateSpan(ref span[0]);
}因此，在 C# 11 中則不得不引入破壞性更改，不允許上述代碼通過編譯。但這并沒有完全解決問題。
為了解決逃逸問題， C# 11 制定了引用逃逸安全規(guī)則。對于一個在 e 中的字段 f：
- 如果
f是個ref字段，并且e是this，則f在它被包圍的方法中是引用逃逸安全的 - 否則如果
f是個ref字段，則f的引用逃逸安全范圍和e的逃逸安全范圍相同 - 否則如果
e是一個引用類型，則f的引用逃逸安全范圍是調(diào)用它的方法 - 否則
f的引用逃逸安全范圍和e相同 - 由于 C# 中的方法是可以返回引用的，因此根據(jù)上面的規(guī)則，一個
ref struct中的方法將不能返回一個對非ref字段的引用：
ref struct Foo
{
private ref int _f1;
private int f2;
public ref int P1 => ref _f1; // 沒問題
public ref int P2 => ref _f2; // 錯誤，因為違反了第四條規(guī)則
}除了引用逃逸安全規(guī)則之外，同樣還有對 ref 賦值的規(guī)則：
- 對于
x.e1 = ref e2， 其中x是在調(diào)用方法中逃逸安全的，那么e2必須在調(diào)用方法中是引用逃逸安全的 - 對于
e1 = ref e2，其中e1是個局部變量，那么e2的引用逃逸安全范圍必須至少和e1的引用逃逸安全范圍一樣大
于是， 根據(jù)上述規(guī)則，下面的代碼是沒問題的：
readonly ref struct Span<T>
{
readonly ref T _field;
readonly int _length;
public Span(ref T value)
{
// 沒問題，因為 x 是 this，this 的逃逸安全范圍和 value 的引用逃逸安全范圍都是調(diào)用方法，滿足規(guī)則 1
_field = ref value;
_length = 1;
}
}于是很自然的，就需要在字段和參數(shù)上對生命周期進(jìn)行標(biāo)注，幫助編譯器確定對象的逃逸范圍。
而我們在寫代碼的時候，并不需要記住以上這么多的規(guī)則，因為有了生命周期標(biāo)注之后一切都變得顯式和直觀了。
scoped
在 C# 11 中，引入了 scoped 關(guān)鍵字用來限制逃逸安全范圍：
| 局部變量 s | 引用逃逸安全范圍 | 逃逸安全范圍 |
|---|---|---|
Span<int> s | 當(dāng)前方法 | 調(diào)用方法 |
scoped Span<int> s | 當(dāng)前方法 | 當(dāng)前方法 |
ref Span<int> s | 調(diào)用方法 | 調(diào)用方法 |
scoped ref Span<int> s | 當(dāng)前方法 | 調(diào)用方法 |
ref scoped Span<int> s | 當(dāng)前方法 | 當(dāng)前方法 |
scoped ref scoped Span<int> s | 當(dāng)前方法 | 當(dāng)前方法 |
其中，scoped ref scoped 是多余的，因為它可以被 ref scoped 隱含。而我們只需要知道 scoped 是用來把逃逸范圍限制到當(dāng)前方法的即可，是不是非常簡單？
如此一來，我們就可以對參數(shù)進(jìn)行逃逸范圍（生命周期）的標(biāo)注：
Span<int> CreateSpan(scoped ref int v)
{
// ...
}然后，之前的代碼就變得沒問題了，因為都是 scoped ref：
Span<int> Foo(int v)
{
// 1
return CreateSpan(ref v);
// 2
int local = 42;
return CreateSpan(ref local);
// 3
Span<int> span = stackalloc int[42];
return CreateSpan(ref span[0]);
}scoped 同樣可以被用在局部變量上：
Span<int> Foo()
{
// 錯誤，因為 span 不能逃逸當(dāng)前方法
scoped Span<int> span1 = default;
return span1;
// 沒問題，因為初始化器的逃逸安全范圍是調(diào)用方法，因為 span2 可以逃逸到調(diào)用方法
Span<int> span2 = default;
return span2;
// span3 和 span4 是一樣的，因為初始化器的逃逸安全范圍是當(dāng)前方法，加不加 scoped 都沒區(qū)別
Span<int> span3 = stackalloc int[42];
scoped Span<int> span4 = stackalloc int[42];
}另外，struct 的 this 也加上了 scoped ref 的逃逸范圍，即引用逃逸安全范圍為當(dāng)前方法，而逃逸安全范圍為調(diào)用方法。
剩下的就是和 out、in 參數(shù)的配合，在 C# 11 中，out 參數(shù)將會默認(rèn)為 scoped ref，而 in 參數(shù)仍然保持默認(rèn)為 ref：
ref int Foo(out int r)
{
r = 42;
return ref r; // 錯誤，因為 r 的引用逃逸安全范圍是當(dāng)前方法
}這非常有用，例如比如下面這個常見的情況：
Span<byte> Read(Span<byte> buffer, out int read)
{
// ..
}
Span<int> Use()
var buffer = new byte[256];
// 如果不修改 out 的引用逃逸安全范圍，則這會報錯，因為編譯器需要考慮 read 是可以被作為 ref 字段返回的情況
// 如果修改 out 的引用逃逸安全范圍，則就沒有問題了，因為編譯器不需要考慮 read 是可以被作為 ref 字段返回的情況
int read;
return Read(buffer, out read);下面給出一些更多的例子：
Span<int> CreateWithoutCapture(scoped ref int value)
{
// 錯誤，因為 value 的引用逃逸安全范圍是當(dāng)前方法
return new Span<int>(ref value);
}
Span<int> CreateAndCapture(ref int value)
// 沒問題，因為 value 的逃逸安全范圍被限制為 value 的引用逃逸安全范圍，這個范圍是調(diào)用方法
return new Span<int>(ref value)
Span<int> ComplexScopedRefExample(scoped ref Span<int> span)
// 沒問題，因為 span 的逃逸安全范圍是調(diào)用方法
return span;
// 沒問題，因為 refLocal 的引用逃逸安全范圍是當(dāng)前方法、逃逸安全范圍是調(diào)用方法
// 在 ComplexScopedRefExample 的調(diào)用中它被傳遞給了一個 scoped ref 參數(shù)，
// 意味著編譯器在計算生命周期時不需要考慮引用逃逸安全范圍，只需要考慮逃逸安全范圍
// 因此它返回的值的安全逃逸范圍為調(diào)用方法
Span<int> local = default;
ref Span<int> refLocal = ref local;
return ComplexScopedRefExample(ref refLocal);
// 錯誤，因為 stackLocal 的引用逃逸安全范圍、逃逸安全范圍都是當(dāng)前方法
// 因此它返回的值的安全逃逸范圍為當(dāng)前方法
Span<int> stackLocal = stackalloc int[42];
return ComplexScopedRefExample(ref stackLocal);unscoped
上述的設(shè)計中，仍然有個問題沒有被解決：
struct S
{
int _field;
// 錯誤，因為 this 的引用逃逸安全范圍是當(dāng)前方法
public ref int Prop => ref _field;
}因此引入一個 unscoped，允許擴(kuò)展逃逸范圍到調(diào)用方法上，于是，上面的方法可以改寫為：
struct S
{
private int _field;
// 沒問題，引用逃逸安全范圍被擴(kuò)展到了調(diào)用方法
public unscoped ref int Prop => ref _field;
}這個 unscoped 也可以直接放到 struct 上：
unscoped struct S
{
private int _field;
public unscoped ref int Prop => ref _field;
}同理，嵌套的 struct 也沒有問題：
unscoped struct Child
{
int _value;
public ref int Value => ref _value;
}
unscoped struct Container
{
Child _child;
public ref int Value => ref _child.Value;
}此外，如果需要恢復(fù)以前的 out 逃逸范圍的話，也可以在 out 參數(shù)上指定 unscoped：
ref int Foo(unscoped out int r)
{
r = 42;
return ref r;
}不過有關(guān) unscoped 的設(shè)計還屬于初步階段，不會在 C# 11 中就提供。
ref struct 約束
從 C# 11 開始，ref struct 可以作為泛型約束了，因此可以編寫如下方法了：
void Foo<T>(T v) where T : ref struct
{
// ...
}因此，Span<T> 的功能也被擴(kuò)展，可以聲明 Span<Span<T>> 了，比如用在 byte 或者 char 上，就可以用來做高性能的字符串處理了。
反射
有了上面那么多東西，反射自然也是要支持的。因此，反射 API 也加入了 ref struct 相關(guān)的支持。
實際用例
有了以上基礎(chǔ)設(shè)施之后，我們就可以使用安全代碼來造一些高性能輪子了。
棧上定長列表
struct FrugalList<T>
{
private T _item0;
private T _item1;
private T _item2;
public readonly int Count = 3;
public unscoped ref T this[int index] => index switch
{
0 => ref _item1,
1 => ref _item2,
2 => ref _item3,
_ => throw new OutOfRangeException("Out of range.")
};
}棧上鏈表
ref struct StackLinkedListNode<T>
{
private T _value;
private ref StackLinkedListNode<T> _next;
public T Value => _value;
public bool HasNext => !Unsafe.IsNullRef(ref _next);
public ref StackLinkedListNode<T> Next => HasNext ? ref _next : throw new InvalidOperationException("No next node.");
public StackLinkedListNode(T value)
{
this = default;
_value = value;
}
public StackLinkedListNode(T value, ref StackLinkedListNode<T> next)
_next = ref next;
}除了這兩個例子之外，其他的比如解析器和序列化器等等，例如 Utf8JsonReader、Utf8JsonWriter 都可以用到這些東西。
未來計劃
高級生命周期
上面的生命周期設(shè)計雖然能滿足絕大多數(shù)使用，但是還是不夠靈活，因此未來有可能在此基礎(chǔ)上擴(kuò)展，引入高級生命周期標(biāo)注。例如：
void M(scoped<'a> ref MyStruct s, scoped<'b> Span<int> span) where 'b >= 'a
{
s.Span = span;
}上面的方法給參數(shù) s 和 span 分別聲明了兩個生命周期 'a 和 'b，并約束 'b 的生命周期不小于 'a，因此在這個方法里，span 可以安全地被賦值給 s.Span。
這個雖然不會被包含在 C# 11 中，但是如果以后開發(fā)者對相關(guān)的需求增長，是有可能被后續(xù)加入到 C# 中的。
總結(jié)
以上就是 C# 11（或之后）對 ref 和 struct 的改進(jìn)了。有了這些基礎(chǔ)設(shè)施，開發(fā)者們將能輕松使用安全的方式來編寫沒有任何堆內(nèi)存開銷的高性能代碼。盡管這些改進(jìn)只能直接讓小部分非常關(guān)注性能的開發(fā)者收益，但是這些改進(jìn)帶來的將是后續(xù)基礎(chǔ)庫代碼質(zhì)量和性能的整體提升。
如果你擔(dān)心這會讓語言的復(fù)雜度上升，那也大可不必，因為這些東西大多數(shù)人并不會用到，只會影響到小部分的開發(fā)者。因此對于大多數(shù)人而言，只需要寫著原樣的代碼，享受其他基礎(chǔ)庫作者利用上述設(shè)施編寫好的東西即可。
到此這篇關(guān)于C# 11 對 ref 和 struct 的改進(jìn)的文章就介紹到這了,更多相關(guān)C# 11 ref 和 struct改進(jìn)內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
這篇文章介紹了C#中的枚舉類型(Enum)，文中通過示例代碼介紹的非常詳細(xì)。對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值，需要的朋友可以參考下2022-07-07
這篇文章主要為大家詳細(xì)介紹了C#實現(xiàn)簡單飛行棋小游戲，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-03-03
編寫圖形程序時需要使用GDI（Graphics Device Interface，圖形設(shè)備接口），所以通過網(wǎng)上的相關(guān)資料整理了這篇文章，下面這篇文章主要給大家介紹了關(guān)于C#利用GDI+畫圖基礎(chǔ)的相關(guān)資料，需要的朋友可以參考下。2018-04-04
這篇文章主要給大家介紹了關(guān)于Unity色子的投擲和點數(shù)的獲得的相關(guān)資料，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2018-10-10
C#實現(xiàn)Oracle批量寫入數(shù)據(jù)的方法詳解
往數(shù)據(jù)庫批量寫入數(shù)據(jù)，這個功能使用頻率相對還是比較高的，特別是在做一些導(dǎo)入等功能的時候。本文為大家介紹了C#實現(xiàn)Oracle批量寫入數(shù)據(jù)的方法，需要的可以參考一下2022-11-11
這篇文章介紹了C#設(shè)計模式之策略模式，文中通過示例代碼介紹的非常詳細(xì)。對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值，需要的朋友可以參考下2022-03-03
這篇文章主要介紹了C#實現(xiàn)泛型List分組輸出元素的方法,涉及C#針對List的遍歷、排序、輸出等相關(guān)操作技巧,需要的朋友可以參考下2017-12-12
selenium.chrome寫擴(kuò)展攔截或轉(zhuǎn)發(fā)請求功能
Selenium?WebDriver?是一組開源?API，用于自動測試?Web?應(yīng)用程序，利用它可以通過代碼來控制chrome瀏覽器，今天通過本文給大家介紹selenium?chrome寫擴(kuò)展攔截或轉(zhuǎn)發(fā)請求功能，感興趣的朋友一起看看吧2022-07-07
在C/C++,JAVA中，有兩種注釋，一種是單行注釋，即兩根反斜杠(//)，另一種是多行注釋，即以/*開頭，以*/結(jié)尾,本文將詳細(xì)介紹，需要的朋友可以參考下2012-12-12
C# 對XML基本操作包括讀取節(jié)點的數(shù)據(jù)，添加節(jié)點。讀取節(jié)點屬性，修改節(jié)點屬性等2011-10-10