【问题标题】:Why does casting a struct to a similar class sort-of work?为什么将结构转换为类似的类工作?
【发布时间】:2018-01-15 21:44:20
【问题描述】:

警告:这只是对那些热衷于破坏东西以了解其机制的人的练习。

我正在探索我可以在 C# 中完成的限制,我编写了一个 ForceCast() 函数来执行强力强制转换,而无需任何类型检查。 永远不要考虑在生产代码中使用这个函数。

我编写了一个名为Original 的类和一个名为LikeOriginal 的结构,它们都带有两个整数变量。在Main() 中,我创建了一个名为orig 的新变量,并将其设置为Original 的新实例,其中a=7b=20。当orig 转换为LikeOriginal 并存储在casted 中时,cGdG 的值将变为未定义,这是可以预料的,因为LikeOriginal 是一个结构,而类实例包含的元数据比结构多实例从而导致内存布局不匹配。

示例输出:

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

但是请注意,当我调用 casted.Add(3) 并转换回 Original 并打印 ab 的值时,令人惊讶的是它们成功地增加了 3,并且这是可重复的。

让我感到困惑的是,将类转换为结构会导致cGdG 映射到类元数据,但是当它们被修改并转换回类时,它们会正确映射到@987654342 @和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);
        }
    }
}

【问题讨论】:

  • 所以您真正要问的问题是:“structclass 是否共享相同的元数据内存布局?”
  • 您应该为成员分配一些“明显”的值,例如0xDEADBEEF。然后从this 指针打印一个十六进制转储,以确定数据成员的实际偏移量。我怀疑它位于偏移量 0 处,这使您能够做您正在做的事情。正如 Zorn 所说,元数据(类型信息、vtable)可能在 this 指针之前。
  • 请记住,结构是按值复制的...这与 LikeOriginal casted = ForceCast&lt;Original, LikeOriginal&gt;(orig); 代码行有关...您将获得 ForceCast 结果的副本!
  • *(IntPtr*) (&amp;tr) = address 是一种可靠的强制转换引用方式的想法在涉及值类型时显然会失效。如果你将Original 设为一个结构,你仍然会得到垃圾,即使类型现在在布局上是相同的。如果您随后将ForceCastOriginal 变为Original,您将仍然返回垃圾,即使类型现在相同TypedReference 不是一个简单的指针,你可以用 C++ 重新解释它;运行时以完全不同的方式处理引用和值类型。
  • 如果内存布局匹配,我不会得到垃圾,你试过了吗?

标签: c# class struct casting memory-layout


【解决方案1】:

这是我对这种情况的看法。您已经对Original 的引用采取了行动,就好像它是对LikeOriginal 的引用一样。这里的关键点是您正在调用LikeOriginal.Add() 方法,该方法的地址是在编译时静态解析的。

反过来,此方法对隐式接收的this 引用进行操作。因此,它会修改相对于它手中的 this 引用偏移 0 和 4 个字节的值。

由于这个实验成功了,说明Original对象和LikeOriginal结构的布局是一样的。我知道结构具有平面布局,这使得它们在分配结构数组时很有用 - 不会有任何内容插入到表示结构的平面内容的字节序列中。这正是类不代表的东西——它们需要一个引用,用于在运行时解析虚函数和类型。

这提醒我说,缺少这个附加的引用是结构不支持派生的核心原因——在以后的调用中你不会知道你是有一个基结构还是派生结构。

无论如何,回到令人惊讶的事实,即这段代码运行良好。我一直在使用 C++ 编译器,我记得他们曾经将 v-table 指针放在 对象的实际数据内容之前。换句话说,this 指针用于指向为该对象分配的内存块的实际地址之后的 4 个字节。也许 C# 也在做同样的事情,在这种情况下,Original 上调用的方法中的this 引用指向a,就像LikeOriginal 上调用的方法中的this 引用指向cG

【讨论】:

  • 让我感到困惑的是,如果是这样的话,我假设cGdG 在第一次演员表之后分别是 7 和 20。 ://
【解决方案2】:

€dit:长话短说:首先创建一个正确处理身份转换ForceCast&lt;LikeOriginal, LikeOriginal&gt;ForceCast&lt;Original, Original&gt; 的 ForceCast 函数,然后您可能有机会进行实际转换

工作示例

通过为 class->class (CC)、class->struct (CS)、struct->class (SC) 和 struct->struct (SS) 提供不同的代码,使用 Nullable&lt;T&gt; 作为结构的中间体,我有一个工作示例:

// 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 -> class 工作但 class -> struct 或 struct -> struct 不工作的情况。

我发现定位结构的唯一方法是获取指向其第一个成员的指针(在输入结构的情况下,该指针等于指向结构的 __makeref 而无需通过 GCHandle)。

【讨论】:

    猜你喜欢
    • 1970-01-01
    • 2017-09-27
    • 1970-01-01
    • 2018-02-15
    • 2018-09-12
    • 2010-11-13
    • 1970-01-01
    • 2015-05-15
    相关资源
    最近更新 更多