Почему приведение структуры к аналогичному классу относится к работе?

Предупреждение: Это всего лишь упражнение для тех, кто страстно любит разбирать вещи, чтобы понять их механику.

Я изучал пределы того, что я смог выполнить в С#, и написал функцию ForceCast() для выполнения трансляции грубой силы без каких-либо проверок типов. Никогда не используйте эту функцию в производственном коде.

Я написал класс под названием Original и структуру под названием LikeOriginal, как с двумя целыми переменными. В Main() я создал новую переменную с именем orig и установил ее в новый экземпляр Original с a=7 и b=20. Когда orig передается в LikeOriginal и сохраняется в casted, значения cG и dG становятся undefined, что следует ожидать, поскольку LikeOriginal - это экземпляры структуры и класса, содержащие больше метаданных чем экземпляры структуры, что приводит к несоответствию макета памяти.

Результат:

Casted Original to LikeOriginal
1300246376, 542
1300246376, 542
added 3
Casted LikeOriginal back to Original
1300246379, 545

Обратите внимание, что когда я вызываю casted.Add(3) и отбрасываю обратно на Original и печатаю значения a и b, неожиданно они успешно увеличиваются на 3, и это повторяемо.

Что меня смущает, так это то, что приведение класса к структуре приведет к тому, что cG и dG будут сопоставляться с метаданными класса, но когда они будут изменены и возвращены в класс, они правильно отображают с помощью a и b.

Почему это так?

Используемый код:

using System;
using System.Runtime.InteropServices;

namespace BreakingStuff {
    public class Original {
        public int a, b;

        public Original(int a, int b)
        {
            this.a = a;
            this.b = b;
        }

        public void Add(int val)
        {
        }
    }

    public struct LikeOriginal {
        public int cG, dG;

        public override string ToString() {
            return cG + ", " + dG;
        }

        public void Add(int val) {
            cG += val;
            dG += val;
        }
    }

    public static class Program {
        public unsafe static void Main() {
            Original orig = new Original(7, 20);
            LikeOriginal casted = ForceCast<Original, LikeOriginal>(orig);
            Console.WriteLine("Casted Original to LikeOriginal");
            Console.WriteLine(casted.cG + ", " + casted.dG);
            Console.WriteLine(casted.ToString());
            casted.Add(3);
            Console.WriteLine("added 3");
            orig = ForceCast<LikeOriginal, Original>(casted);
            Console.WriteLine("Casted LikeOriginal back to Original");
            Console.WriteLine(orig.a + ", " + orig.b);
            Console.ReadLine();
        }

        //performs a pointer cast but with the same memory layout.
        private static unsafe TOut ForceCast<TIn, TOut>(this TIn input) {
            GCHandle handle = GCHandle.Alloc(input);
            TOut result = Read<TOut>(GCHandle.ToIntPtr(handle));
            handle.Free();
            return result;
        }

        private static unsafe T Read<T>(this IntPtr address) {
            T obj = default(T);
            if (address == IntPtr.Zero)
                return obj;
            TypedReference tr = __makeref(obj);
            *(IntPtr*) (&tr) = address;
            return __refvalue(tr, T);
        }
    }
}

Ответы

Ответ 1

€ dit: Короче говоря: сначала создайте функцию ForceCast, которая правильно обрабатывает как переводы идентичности ForceCast<LikeOriginal, LikeOriginal>, так и ForceCast<Original, Original>, тогда у вас может быть возможность получить фактические преобразования, работающие

Рабочий образец

Предоставляя разные коды для классов → class (CC), class- > struct (CS), struct → class (SC) и struct → struct (SS), используя Nullable<T> как промежуточное звено для структур, я получил рабочий пример:

// class -> class
private static unsafe TOut ForceCastCC<TIn, TOut>(TIn input)
    where TIn : class
    where TOut : class
{
    var handle = __makeref(input);
    return Read<TOut>(*(IntPtr*)(&handle));
}

// struct -> struct, require nullable types for in-out
private static unsafe TOut? ForceCastSS<TIn, TOut>(TIn? input)
    where TIn : struct
    where TOut : struct
{
    var handle = __makeref(input);
    return Read<TOut?>(*(IntPtr*)(&handle));
}

// class -> struct
private static unsafe TOut? ForceCastCS<TIn, TOut>(TIn input)
    where TIn : class
    where TOut : struct
{
    var handle = __makeref(input);
    // one extra de-reference of the input pointer
    return Read<TOut?>(*(IntPtr*)*(IntPtr*)(&handle));
}

// struct -> class
private static unsafe TOut ForceCastSC<TIn, TOut>(TIn? input)
    where TIn : struct
    where TOut : class
{
    // get a real pointer to the struct, so it can be turned into a reference type
    var handle = GCHandle.Alloc(input);
    var result = Read<TOut>(GCHandle.ToIntPtr(handle));
    handle.Free();
    return result;
}

Теперь используйте соответствующую функцию в своем примере и обработайте типы с нулевым значением, например, требования компилятора:

Original orig = new Original(7, 20);
LikeOriginal casted = ForceCastCS<Original, LikeOriginal>(orig) ?? default(LikeOriginal);
Console.WriteLine("Casted Original to LikeOriginal");
Console.WriteLine(casted.cG + ", " + casted.dG);
Console.WriteLine(casted.ToString());
casted.Add(3);
Console.WriteLine("added 3");
orig = ForceCastSC<LikeOriginal, Original>(casted);
Console.WriteLine("Casted LikeOriginal back to Original");
Console.WriteLine(orig.a + ", " + orig.b);

Console.ReadLine();

Для меня это возвращает правильные числа в каждой точке.

Подробнее

Некоторые сведения:

В основном, ваша проблема заключается в том, что вы рассматриваете тип значения, типа ссылочного типа...

Давайте сначала рассмотрим рабочий процесс: LikeOriginal → Original:

var h1 = GCHandle.Alloc(likeOriginal);
var ptr1 = GCHandle.ToIntPtr(h1);

Это создает указатель, указывающий на область памяти LikeOriginal (€ dit: на самом деле, не совсем такая область памяти, см. ниже)

var obj1 = default(Original);
TypedReference t1 = __makeref(obj1);
*(IntPtr*)(&t1) = ptr1;

Это создает ссылку (указатель) на Original со значением указателя, указывая на LikeOriginal

var original = __refvalue( t1,Original);

Это превращает типизированную ссылку в управляемую ссылку, указывая на память LikeOriginal. Все значения исходного объекта LikeOriginal сохраняются.

Теперь давайте проанализируем промежуточный случай, который должен работать, если ваш код будет работать двунаправленно: LikeOriginal → LikeOriginal:

var h2 = GCHandle.Alloc(likeOriginal);
var ptr2 = GCHandle.ToIntPtr(h2);

Опять же, у нас есть указатель, указывающий на область памяти LikeOriginal

var obj2 = default(LikeOriginal);
TypedReference t2 = __makeref(obj2);

Теперь вот первый намек на то, что происходит не так: __makeref(obj2) создаст ссылку на объект LikeOriginal, а не на какую-то отдельную область, где хранится указатель.

*(IntPtr*)(&t2) = ptr2;

ptr2 однако, является указателем на какой-то опорное значение

var likeOriginal2 = __refvalue( t2,LikeOriginal);

Вот мы, получив мусор, потому что t2 предположительно будет прямой ссылкой на память объекта, а не ссылкой на некоторую память указателя.

Ниже приведен некоторый тестовый код, который я выполнил, чтобы лучше понять ваш подход и что не так (некоторые из них довольно структурированы, а затем некоторые части, где я пробовал некоторые дополнительные вещи):

Original o1 = new Original(111, 222);
LikeOriginal o2 = new LikeOriginal { cG = 333, dG = 444 };

// get handles to the objects themselfes and to their individual properties
GCHandle h1 = GCHandle.Alloc(o1);
GCHandle h2 = GCHandle.Alloc(o1.a);
GCHandle h3 = GCHandle.Alloc(o1.b);
GCHandle h4 = GCHandle.Alloc(o2);
GCHandle h5 = GCHandle.Alloc(o2.cG);
GCHandle h6 = GCHandle.Alloc(o2.dG);

// get pointers from the handles, each pointer has an individual value
IntPtr i1 = GCHandle.ToIntPtr(h1);
IntPtr i2 = GCHandle.ToIntPtr(h2);
IntPtr i3 = GCHandle.ToIntPtr(h3);
IntPtr i4 = GCHandle.ToIntPtr(h4);
IntPtr i5 = GCHandle.ToIntPtr(h5);
IntPtr i6 = GCHandle.ToIntPtr(h6);

// get typed references for the objects and properties
TypedReference t1 = __makeref(o1);
TypedReference t2 = __makeref(o1.a);
TypedReference t3 = __makeref(o1.b);
TypedReference t4 = __makeref(o2);
TypedReference t5 = __makeref(o2.cG);
TypedReference t6 = __makeref(o2.dG);

// get the associated pointers
IntPtr j1 = *(IntPtr*)(&t1);
IntPtr j2 = *(IntPtr*)(&t2); // j1 != j2, because a class handle points to the pointer/reference memory
IntPtr j3 = *(IntPtr*)(&t3);
IntPtr j4 = *(IntPtr*)(&t4);
IntPtr j5 = *(IntPtr*)(&t5); // j4 == j5, because a struct handle points directly to the instance memory
IntPtr j6 = *(IntPtr*)(&t6);

// direct translate-back is working for all objects and properties
var r1 = __refvalue( t1,Original);
var r2 = __refvalue( t2,int);
var r3 = __refvalue( t3,int);
var r4 = __refvalue( t4,LikeOriginal);
var r5 = __refvalue( t5,int);
var r6 = __refvalue( t6,int);

// assigning the pointers that where inferred from the GCHandles
*(IntPtr*)(&t1) = i1;
*(IntPtr*)(&t2) = i2;
*(IntPtr*)(&t3) = i3;
*(IntPtr*)(&t4) = i4;
*(IntPtr*)(&t5) = i5;
*(IntPtr*)(&t6) = i6;

// translate back the changed references
var s1 = __refvalue( t1,Original); // Ok
// rest is garbage values!
var s2 = __refvalue( t2,int);
var s3 = __refvalue( t3,int);
var s4 = __refvalue( t4,LikeOriginal);
var s5 = __refvalue( t5,int);
var s6 = __refvalue( t6,int);

// a variation, primitively dereferencing the pointer to get to the actual memory
*(IntPtr*)(&t4) = *(IntPtr*)i4;
var s4_1 = __refvalue( t4,LikeOriginal); // partial result, getting { garbage, 333 } instead of { 333, 444 }

// prepare TypedReference for translation between Original and LikeOriginal
var obj1 = default(Original);
var obj2 = default(LikeOriginal);
TypedReference t7 = __makeref(obj1);
TypedReference t8 = __makeref(obj2);

// translate between Original and LikeOriginal
*(IntPtr*)(&t7) = i4; // From struct to class, the pointer aquired through GCHandle is apropriate
var s7 = __refvalue( t7,Original); // Ok

*(IntPtr*)(&t8) = *(IntPtr*)j1;
var s8 = __refvalue( t8,LikeOriginal); // Not Ok - Original has some value comming before its first member - getting { garbage, 111 } instead of { 111, 222 }

*(IntPtr*)(&t8) = j2;
var s9 = __refvalue( t8,LikeOriginal); // Ok by starting at the address of the first member

Заключение: переход через GCHandle → IntPtr создает указатель, указывающий на одну ячейку памяти перед первым членом, независимо от того, является ли начальная точка структурой или классом. Это приводит к ситуации, когда класс struct → class или class → работает, но структура класса → struct или struct → не работает.

Единственное, что я нашел для таргетинга на структуры, - это получить указатель на их первый член (который в случае входной структуры равен __makeref для структуры без перехода через GCHandle).

Ответ 2

Вот как я вижу эту ситуацию. Вы ссылались на ссылку Original, как на ссылку LikeOriginal. Критическая точка здесь заключается в том, что вы вызываете метод LikeOriginal.Add(), адрес которого статически ставится во время компиляции.

Этот метод, в свою очередь, работает с ссылкой this, которую он неявно получает. Поэтому он изменяет значения, которые смещены на 0 и на 4 байта относительно ссылки this, которую он имеет в своих руках.

Поскольку этот эксперимент сработал, он указывает, что макеты объекта Original и LikeOriginal struct одинаковы. Я знаю, что структуры имеют плоский макет, что делает их полезными при распределении массивов структур - в последовательность байтов, представляющих плоское содержимое структур, не будет ничего вставляться. Это то, что не стоит для классов - им нужна одна ссылка, которая будет использоваться для разрешения виртуальных функций и типа во время выполнения.

Это напоминает мне, что отсутствие этой дополнительной ссылки является основной причиной, по которой структуры не поддерживают вывод - вы не знаете, есть ли у вас база или производная структура в более позднем вызове.

В любом случае, вернемся к удивительному факту, что этот код работал нормально. Я работал с компиляторами С++, и я помню, что они использовали для размещения указателя v-table перед фактическим содержимым данных объекта. Другими словами, указатель this используется для указания 4 байта после фактического адреса блока памяти, выделенного для этого объекта. Возможно, С# делает то же самое, и в этом случае ссылка this в методе, вызванном на Original, указывает на a, как и ссылка this в методе, вызванном на LikeOriginal, указывает на cG.