下面的“修复”对我来说非常混乱；这里的场景是根据大小有条件地决定是否使用堆栈和租用的缓冲区-这是一个相当小的范围，但有时是必要的优化，然而：对于“明显的”实现（第3个，将确定的赋值推迟到我们真正想要赋值），编译器向cs8353抱怨：
“span”类型的stackalloc表达式的结果不能在此上下文中使用，因为它可能在包含方法外部公开
短复制（完整复制如下）是：

// take your pick of:
// Span<int> s = stackalloc[0]; // works
// Span<int> s = default; // fails
// Span<int> s; // fails

if (condition)
{   // CS8353 happens here
    s = stackalloc int[size];
}
else
{
    s = // some other expression
}
// use s here

这里我唯一能想到的是编译器确实在标记 stackalloc 正在逃离 stackalloc 发生了，并且挥舞着旗子说“我不能证明这在以后的方法中是否是安全的”，但是 stackalloc[0] 一开始，我们将“危险的”上下文范围推得更高，现在编译器很高兴它永远不会逃逸“危险的”范围（也就是说，它实际上永远不会离开方法，因为我们在顶部范围声明）。这种理解是正确的吗？这仅仅是编译器在证明什么方面的限制？
（对我来说）真正有趣的是 = stackalloc[0] 基本上是一个no-op，意思是至少在编译的形式中工作数字1 = stackalloc[0] 与失败的数字2相同 = default .
完全复制（也可在sharplab上查看il）。

using System;
using System.Buffers;

public static class C
{
    public static void StackAllocFun(int count)
    {
        // #1 this is legal, just initializes s as a default span
        Span<int> s = stackalloc int[0];

        // #2 this is illegal: error CS8353: A result of a stackalloc expression
        // of type 'Span<int>' cannot be used in this context because it may
        // be exposed outside of the containing method
        // Span<int> s = default;

        // #3 as is this (also illegal, identical error)
        // Span<int> s;

        int[] oversized = null;
        try
        {
            if (count < 32)
            {   // CS8353 happens at this stackalloc
                s = stackalloc int[count];
            }
            else
            {
                oversized = ArrayPool<int>.Shared.Rent(count);
                s = new Span<int>(oversized, 0, count);
            }
            Populate(s);
            DoSomethingWith(s);
        }
        finally
        {
            if (oversized is not null)
            {
                ArrayPool<int>.Shared.Return(oversized);
            }
        }
    }

    private static void Populate(Span<int> s)
        => throw new NotImplementedException(); // whatever
    private static void DoSomethingWith(ReadOnlySpan<int> s)
        => throw new NotImplementedException(); // whatever

    // note: ShowNoOpX and ShowNoOpY compile identically just:
    // ldloca.s 0, initobj Span<int>, ldloc.0
    static void ShowNoOpX()
    {
        Span<int> s = stackalloc int[0];
        DoSomethingWith(s);
    }
    static void ShowNoOpY()
    {
        Span<int> s = default;
        DoSomethingWith(s);
    }
}