Какова стоимость использования фиксированного оператора C# для управляемых unsafe struct, содержащих фиксированные массивы?

Я пытался определить, какова истинная стоимость использования оператора fixed в C# для управляемых небезопасных структур, содержащих фиксированные массивы. Обратите внимание, что я не имею в виду неуправляемые структуры.

В частности, есть ли причины избегать паттерна, показанного ниже в классе 'MultipleFixed'? Является ли стоимость простой фиксации данных ненулевой, близкой к нулю (== стоимость, аналогичная установке и очистке одного флага при входе/выходе из фиксированной области), или она достаточно значительна, чтобы избегать ее, когда это возможно?

Очевидно, что эти классы надуманы, чтобы помочь объяснить вопрос. Это для структуры данных с высоким использованием в игре XNA, где производительность чтения/записи этих данных критична, так что если мне нужно зафиксировать массив и передавать его повсюду, я сделаю это, но если нет никакой разницы, я бы предпочел сохранить fixed() локально для методов, чтобы помочь сохранить сигнатуры функций немного более переносимыми на платформы, которые не поддерживают небезопасный код. (Да, это дополнительный код, но чего бы это ни стоило...)

 

    unsafe struct ByteArray
    {
       public fixed byte Data[1024];
    }

    class MultipleFixed
    {
       unsafe void SetValue(ref ByteArray bytes, int index, byte value)
       {
           fixed(byte* data = bytes.Data)
           {
               data[index] = value;
           }
       }

        unsafe bool Validate(ref ByteArray bytes, int index, byte expectedValue)
        {
           fixed(byte* data = bytes.Data)
           {
               return data[index] == expectedValue;
           }
        }

        void Test(ref ByteArray bytes)
        {
            SetValue(ref bytes, 0, 1);
            Validate(ref bytes, 0, 1);
        }
    }

    class SingleFixed
    {
       unsafe void SetValue(byte* data, int index, byte value)
       {
           data[index] = value;
       }

        unsafe bool Validate(byte* data, int index, byte expectedValue)
        {
           return data[index] == expectedValue;
        }

        unsafe void Test(ref ByteArray bytes)
        {
            fixed(byte* data = bytes.Data)
            {
                SetValue(data, 0, 1);
                Validate(data, 0, 1);
            }
        }
    }

Кроме того, я искал похожие вопросы и ближе всего я нашел this, но этот вопрос отличается тем, что он касается только чистого управляемого кода и конкретных затрат на использование fixed в этом контексте.

Спасибо за любую информацию!