深入淺析C#?11?對(duì)?ref?和?struct?的改進(jìn)

更新時(shí)間：2022年04月22日 08:45:33 作者：hez2010

這篇文章主要介紹了C#?11?對(duì)?ref?和?struct?的改進(jìn),有了這些基礎(chǔ)設(shè)施，開發(fā)者們將能輕松使用安全的方式來編寫沒有任何堆內(nèi)存開銷的高性能代碼，需要的朋友可以參考下

前言

C# 11 中即將到來一個(gè)可以讓重視性能的開發(fā)者狂喜的重量級(jí)特性，這個(gè)特性主要是圍繞著一個(gè)重要底層性能設(shè)施 ref 和 struct 的一系列改進(jìn)。

但是這部分的改進(jìn)涉及的內(nèi)容較多，不一定能在 .NET 7（C# 11）做完，因此部分內(nèi)容推遲到 C# 12 也是有可能的。當(dāng)然，還是很有希望能在 C# 11 的時(shí)間點(diǎn)就看到完全體的。

本文僅僅就這一個(gè)特性進(jìn)行介紹，因?yàn)?C# 11 除了本特性之外，還有很多其他的改進(jìn)，一篇文章根本說不完，其他那些我們就等到 .NET 7 快正式發(fā)布的時(shí)候再說吧。

背景

C# 自 7.0 版本引入了新的 ref struct 用來表示不可被裝箱的棧上對(duì)象，但是當(dāng)時(shí)局限性很大，甚至無法被用于泛型約束，也無法作為 struct 的字段。在 C# 11 中，由于特性 ref 字段的推動(dòng)，需要允許類型持有其它值類型的引用，這方面的東西終于有了大幅度進(jìn)展。

這些設(shè)施旨在允許開發(fā)者使用安全的代碼編寫高性能代碼，而無需面對(duì)不安全的指針。接下來我就來對(duì) C# 11 甚至 12 在此方面的即將到來的改進(jìn)進(jìn)行介紹。

ref 字段

C# 以前是不能在類型中持有對(duì)其它值類型的引用的，但是在 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)造了一個(gè) Span<T>，它持有了對(duì)其他 T 對(duì)象的引用。

當(dāng)然，ref struct 也是可以被 default 來初始化的：

Span<int> span = default;

但這樣 _field 就會(huì)是個(gè)空引用，不過我們可以通過 Unsafe.IsNullRef 方法來進(jìn)行檢查：

if (Unsafe.IsNullRef(ref _field))
{
    throw new NullReferenceException(...);
}

另外，ref字段的可修改性也是一個(gè)非常重要的事情，因此引入了：

readonly ref：一個(gè)對(duì)對(duì)象的只讀引用，這個(gè)引用本身不能在構(gòu)造方法或 init 方法之外被修改
ref readonly：一個(gè)對(duì)只讀對(duì)象的引用，這個(gè)引用指向的對(duì)象不能在構(gòu)造方法或 init 方法之外被修改
readonly ref readonly：一個(gè)對(duì)只讀對(duì)象的只讀引用，是上述兩種的組合

例如：

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];      // 錯(cuò)誤，因?yàn)?f1 引用的值不能被修改
        f2 = ref array[0];  // 錯(cuò)誤，因?yàn)?f2 本身不能被修改
        f2 = array[0];      // 沒問題
        f3 = ref array[0];  // 錯(cuò)誤：因?yàn)?f3 本身不能被修改
        f3 = array[0];      // 錯(cuò)誤：因?yàn)?f3 引用的值不能被修改
    }
}

生命周期

這一切看上去都很美好，但是真的沒有任何問題嗎？

假設(shè)我們有下面的代碼來使用上面的東西：

Span<int> Foo()
{
    int v = 42;
    return new Span<int>(ref v);
}

v 是一個(gè)局部變量，在函數(shù)返回之后其生命周期就會(huì)結(jié)束，那么上面這段代碼就會(huì)導(dǎo)致 Span<int> 持有的 v 的引用變成無效的。順帶一提，上面這段代碼是完全合法的，因?yàn)?C# 之前不支持 ref 字段，因此上面的代碼是不可能出現(xiàn)逃逸問題的。但是 C# 11 加入了 ref 字段，棧上的對(duì)象就有可能通過 ref 字段而發(fā)生引用逃逸，于是代碼變得不安全。

如果我們有一個(gè) CreateSpan 方法用來創(chuàng)建一個(gè)引用的 Span ：

Span<int> CreateSpan(ref int v)
{
     // ...
}

這就衍生出了一系列在以前的 C# 中沒問題（因?yàn)?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ī)則。對(duì)于一個(gè)在 e 中的字段 f：

如果 f 是個(gè) ref 字段，并且 e是this，則 f 在它被包圍的方法中是引用逃逸安全的
否則如果 f 是個(gè) ref 字段，則 f 的引用逃逸安全范圍和 e 的逃逸安全范圍相同
否則如果 e 是一個(gè)引用類型，則 f 的引用逃逸安全范圍是調(diào)用它的方法
否則 f 的引用逃逸安全范圍和 e 相同
由于 C# 中的方法是可以返回引用的，因此根據(jù)上面的規(guī)則，一個(gè) ref struct 中的方法將不能返回一個(gè)對(duì)非 ref 字段的引用：

ref struct Foo
{
    private ref int _f1;
    private int f2;

    public ref int P1 => ref _f1; // 沒問題
    public ref int P2 => ref _f2; // 錯(cuò)誤，因?yàn)檫`反了第四條規(guī)則
}

除了引用逃逸安全規(guī)則之外，同樣還有對(duì) ref 賦值的規(guī)則：

對(duì)于 x.e1 = ref e2，其中 x 是在調(diào)用方法中逃逸安全的，那么 e2 必須在調(diào)用方法中是引用逃逸安全的
對(duì)于 e1 = ref e2，其中 e1 是個(gè)局部變量，那么 e2 的引用逃逸安全范圍必須至少和 e1 的引用逃逸安全范圍一樣大

于是，根據(jù)上述規(guī)則，下面的代碼是沒問題的：

readonly ref struct Span<T>
{
    readonly ref T _field;
    readonly int _length;

    public Span(ref T value)
    {
        // 沒問題，因?yàn)?x 是 this，this 的逃逸安全范圍和 value 的引用逃逸安全范圍都是調(diào)用方法，滿足規(guī)則 1
        _field = ref value;
        _length = 1;
    }
}

于是很自然的，就需要在字段和參數(shù)上對(duì)生命周期進(jìn)行標(biāo)注，幫助編譯器確定對(duì)象的逃逸范圍。

而我們?cè)趯懘a的時(shí)候，并不需要記住以上這么多的規(guī)則，因?yàn)橛辛松芷跇?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 是多余的，因?yàn)樗梢员?ref scoped 隱含。而我們只需要知道 scoped 是用來把逃逸范圍限制到當(dāng)前方法的即可，是不是非常簡(jiǎn)單？

如此一來，我們就可以對(duì)參數(shù)進(jìn)行逃逸范圍（生命周期）的標(biāo)注：

Span<int> CreateSpan(scoped ref int v)
{
    // ...
}

然后，之前的代碼就變得沒問題了，因?yàn)槎际?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()
{
    // 錯(cuò)誤，因?yàn)?span 不能逃逸當(dāng)前方法
    scoped Span<int> span1 = default;
    return span1;

    // 沒問題，因?yàn)槌跏蓟鞯奶右莅踩秶钦{(diào)用方法，因?yàn)?span2 可以逃逸到調(diào)用方法
    Span<int> span2 = default;
    return span2;
    // span3 和 span4 是一樣的，因?yàn)槌跏蓟鞯奶右莅踩秶钱?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ù)將會(huì)默認(rèn)為 scoped ref，而 in 參數(shù)仍然保持默認(rèn)為 ref：

ref int Foo(out int r)
{
    r = 42;
    return ref r; // 錯(cuò)誤，因?yàn)?r 的引用逃逸安全范圍是當(dāng)前方法
}

這非常有用，例如比如下面這個(gè)常見的情況：

Span<byte> Read(Span<byte> buffer, out int read)
{
    // .. 
}

Span<int> Use()
    var buffer = new byte[256];
    // 如果不修改 out 的引用逃逸安全范圍，則這會(huì)報(bào)錯(cuò)，因?yàn)榫幾g器需要考慮 read 是可以被作為 ref 字段返回的情況
    // 如果修改 out 的引用逃逸安全范圍，則就沒有問題了，因?yàn)榫幾g器不需要考慮 read 是可以被作為 ref 字段返回的情況
    int read;
    return Read(buffer, out read);

下面給出一些更多的例子：

Span<int> CreateWithoutCapture(scoped ref int value)
{
    // 錯(cuò)誤，因?yàn)?value 的引用逃逸安全范圍是當(dāng)前方法
    return new Span<int>(ref value);
}

Span<int> CreateAndCapture(ref int value)
    // 沒問題，因?yàn)?value 的逃逸安全范圍被限制為 value 的引用逃逸安全范圍，這個(gè)范圍是調(diào)用方法
    return new Span<int>(ref value)
Span<int> ComplexScopedRefExample(scoped ref Span<int> span)
    // 沒問題，因?yàn)?span 的逃逸安全范圍是調(diào)用方法
    return span;
    // 沒問題，因?yàn)?refLocal 的引用逃逸安全范圍是當(dāng)前方法、逃逸安全范圍是調(diào)用方法
    // 在 ComplexScopedRefExample 的調(diào)用中它被傳遞給了一個(gè) scoped ref 參數(shù)，
    // 意味著編譯器在計(jì)算生命周期時(shí)不需要考慮引用逃逸安全范圍，只需要考慮逃逸安全范圍
    // 因此它返回的值的安全逃逸范圍為調(diào)用方法
    Span<int> local = default;
    ref Span<int> refLocal = ref local;
    return ComplexScopedRefExample(ref refLocal);
    // 錯(cuò)誤，因?yàn)?stackLocal 的引用逃逸安全范圍、逃逸安全范圍都是當(dāng)前方法
    // 因此它返回的值的安全逃逸范圍為當(dāng)前方法
    Span<int> stackLocal = stackalloc int[42];
    return ComplexScopedRefExample(ref stackLocal);

unscoped

上述的設(shè)計(jì)中，仍然有個(gè)問題沒有被解決：

struct S
{
    int _field;

    // 錯(cuò)誤，因?yàn)?this 的引用逃逸安全范圍是當(dāng)前方法
    public ref int Prop => ref _field;
}

因此引入一個(gè) unscoped，允許擴(kuò)展逃逸范圍到調(diào)用方法上，于是，上面的方法可以改寫為：

struct S
{
    private int _field;
    // 沒問題，引用逃逸安全范圍被擴(kuò)展到了調(diào)用方法
    public unscoped ref int Prop => ref _field;
}

這個(gè) 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è)計(jì)還屬于初步階段，不會(huì)在 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)的支持。

實(shí)際用例

有了以上基礎(chǔ)設(shè)施之后，我們就可以使用安全代碼來造一些高性能輪子了。

棧上定長(zhǎng)列表

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;
}

除了這兩個(gè)例子之外，其他的比如解析器和序列化器等等，例如 Utf8JsonReader、Utf8JsonWriter 都可以用到這些東西。

未來計(jì)劃

高級(jí)生命周期

上面的生命周期設(shè)計(jì)雖然能滿足絕大多數(shù)使用，但是還是不夠靈活，因此未來有可能在此基礎(chǔ)上擴(kuò)展，引入高級(jí)生命周期標(biāo)注。例如：

void M(scoped<'a> ref MyStruct s, scoped<'b> Span<int> span) where 'b >= 'a
{
    s.Span = span;
}

上面的方法給參數(shù) s 和 span 分別聲明了兩個(gè)生命周期 'a 和 'b，并約束 'b 的生命周期不小于 'a，因此在這個(gè)方法里，span 可以安全地被賦值給 s.Span。

這個(gè)雖然不會(huì)被包含在 C# 11 中，但是如果以后開發(fā)者對(duì)相關(guān)的需求增長(zhǎng)，是有可能被后續(xù)加入到 C# 中的。

總結(jié)

以上就是 C# 11（或之后）對(duì) ref 和 struct 的改進(jìn)了。有了這些基礎(chǔ)設(shè)施，開發(fā)者們將能輕松使用安全的方式來編寫沒有任何堆內(nèi)存開銷的高性能代碼。盡管這些改進(jìn)只能直接讓小部分非常關(guān)注性能的開發(fā)者收益，但是這些改進(jìn)帶來的將是后續(xù)基礎(chǔ)庫代碼質(zhì)量和性能的整體提升。

如果你擔(dān)心這會(huì)讓語言的復(fù)雜度上升，那也大可不必，因?yàn)檫@些東西大多數(shù)人并不會(huì)用到，只會(huì)影響到小部分的開發(fā)者。因此對(duì)于大多數(shù)人而言，只需要寫著原樣的代碼，享受其他基礎(chǔ)庫作者利用上述設(shè)施編寫好的東西即可。

到此這篇關(guān)于C# 11 對(duì) ref 和 struct 的改進(jìn)的文章就介紹到這了,更多相關(guān)C# 11 ref 和 struct改進(jìn)內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: