Должен ли этот небезопасный код работать и в .NET Core 3?

Я делаю рефакторинг своих библиотек, чтобы Span<T>по возможности избегать выделения кучи, но поскольку я нацеливаюсь и на более старые фреймворки, я также реализую некоторые общие резервные решения. Но теперь я обнаружил странную проблему и не совсем уверен, нашел ли я ошибку в .NET Core 3 или я делаю что-то нелегальное.

Проблема:

// This returns 1 as expected but cannot be used in older frameworks:
private static uint ReinterpretNew()
{
    Span<byte> bytes = stackalloc byte[4];
    bytes[0] = 1; // FillBytes(bytes);

    // returning bytes as uint:
    return Unsafe.As<byte, uint>(ref bytes.GetPinnableReference());
}

// This returns garbage in .NET Core 3.0 with release build:
private static unsafe uint ReinterpretOld()
{
    byte* bytes = stackalloc byte[4];
    bytes[0] = 1; // FillBytes(bytes);

    // returning bytes as uint:
    return *(uint*)bytes;
}

Интересно, что он ReinterpretOldхорошо работает в .NET Framework и .NET Core 2.0 (так что я мог бы быть доволен этим в конце концов), тем не менее, это немного беспокоит меня.

Btw. ReinterpretOldможет быть исправлено также в .NET Core 3.0 с помощью небольшой модификации:

//return *(uint*)bytes;
uint* asUint = (uint*)bytes;
return *asUint;

Мой вопрос:

Это ошибка или она ReinterpretOldработает в старых фреймворках только случайно, и я должен применить исправление также для них?

Примечания:

• Отладочная сборка работает также в .NET Core 3.0
• Я пытался применить [MethodImpl(MethodImplOptions.NoInlining)]к , ReinterpretOldно это не имело никакого эффекта.

Ох, это забавная находка; то, что происходит здесь, это то, что ваш местный становится оптимизированным - там не осталось местных жителей, что означает, что их нет .locals init, что означает, что stackallocведет себя по- разному и не стирает пространство;

private static unsafe uint Reinterpret1()
{
    byte* bytes = stackalloc byte[4];
    bytes[0] = 1;

    return *(uint*)bytes;
}

private static unsafe uint Reinterpret2()
{
    byte* bytes = stackalloc byte[4];
    bytes[0] = 1;

    uint* asUint = (uint*)bytes;
    return *asUint;
}

будет выглядеть так:

.method private hidebysig static uint32 Reinterpret1() cil managed
{
    .maxstack 8
    L_0000: ldc.i4.4 
    L_0001: conv.u 
    L_0002: localloc 
    L_0004: dup 
    L_0005: ldc.i4.1 
    L_0006: stind.i1 
    L_0007: ldind.u4 
    L_0008: ret 
}

.method private hidebysig static uint32 Reinterpret2() cil managed
{
    .maxstack 3
    .locals init (
        [0] uint32* numPtr)
    L_0000: ldc.i4.4 
    L_0001: conv.u 
    L_0002: localloc 
    L_0004: dup 
    L_0005: ldc.i4.1 
    L_0006: stind.i1 
    L_0007: stloc.0 
    L_0008: ldloc.0 
    L_0009: ldind.u4 
    L_000a: ret 
}

Я думаю, что я был бы рад сказать, что это ошибка компилятора, или, по крайней мере, нежелательный побочный эффект и поведение, учитывая, что были приняты предыдущие решения, чтобы сказать «испустить init .locals» , в частности, чтобы попытаться оставайтесь в stackallocздравом уме - но согласны ли люди компилятора, решать им.

Обходной путь: обрабатывать stackallocпространство как неопределенное (что, честно говоря, это то, что вы должны делать); если вы ожидаете, что это будут нули: вручную обнулите его.