Question

在.Net Core中，当在编译时不知道父对象时，如何获取原始字段的内存地址（IntPtr）？

如果对象类是一个struct并且blittable，那么我可以使用Marshel.Offset，但不幸的是它不是。

以下代码说明了我要做的事情

    class Example   // this class is defined in a different assembly and is not known at compile time
    {
        public double foo;
    }

    static void Main(string[] args)
    {
        Example obj = new Example();
        obj.foo = 123;

        var hdl = GCHandle.Alloc(obj, GCHandleType.Pinned);
        IntPtr foo_add = GetAddressOf(obj, "foo");

        hdl.Free();
    }

    static IntPtr GetAddressOf(object pinned_object, string field_name)
    {
        FieldInfo field = pinned_object.GetType().GetField(field_name);
        return field.GetFieldAddress(pinned_object); // Unfortunatly this function does not exist, what are the alternatives?
    }

替代question着眼于获取对象的内存地址，这可以使用GCHandle.Alloc完成，但不适用于基元。

Answer 1

以下答案描述了如何使用C＃7.0中的“ref return”功能获取引用的字段：

https://stackoverflow.com/a/45046664/425678

基于这个精彩的答案，我们可以修改函数create_refgetter以获得非托管指针。这使用了在使用泛型类型（detailed explanation）

时所需的鲜为人知的函数__makeref。

然后使用函数GetAddressOf包装此函数，该函数允许调用而不指定泛型类型。

    static IntPtr GetAddressOf(object pinned_object, string field_name)
    {
        var fi_val = pinned_object.GetType().GetField(field_name);
        var mi_all = typeof(Program).GetMethod("create_refgetter", BindingFlags.Static | BindingFlags.Public);

        var mi_generic = mi_all.MakeGenericMethod(pinned_object.GetType(), fi_val.FieldType);
        var ptr = (IntPtr) mi_generic.Invoke(null, new object[] {pinned_object, field_name });

        return ptr;
    }

    https://stackoverflow.com/a/45046664/425678

    public delegate ref U RefGetter<T, U>(T obj);
    public static IntPtr create_refgetter<T, U>(object obj,string s_field)
    {
        const BindingFlags bf = BindingFlags.NonPublic |
                                BindingFlags.Public |
                                BindingFlags.Instance |
                                BindingFlags.DeclaredOnly;

        var fi = typeof(T).GetField(s_field, bf);
        if (fi == null)
            throw new MissingFieldException(typeof(T).Name, s_field);

        var s_name = "__refget_" + typeof(T).Name + "_fi_" + fi.Name;

        // workaround for using ref-return with DynamicMethod:
        //   a.) initialize with dummy return value
        var dm = new DynamicMethod(s_name, typeof(U), new[] { typeof(T) }, typeof(T), true);

        //   b.) replace with desired 'ByRef' return value
        dm.GetType().GetField("m_returnType", bf).SetValue(dm, typeof(U).MakeByRefType());

        var il = dm.GetILGenerator();
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldflda, fi);
        il.Emit(OpCodes.Ret);

        RefGetter<T, U> ref_getter = (RefGetter<T, U>)dm.CreateDelegate(typeof(RefGetter<T, U>));

        unsafe
        {
            TypedReference t_ref = __makeref(ref_getter((T)obj));

            IntPtr ptr = *((IntPtr*)&t_ref);
            return ptr;
        }
    }
}

〔实施例：

class Example   // this class is defined in a different assembly and is not known at compile time
{
    public double foo;
}

static void Main(string[] args)
{
    Example obj = new Example();
    obj.foo = 123;

    var hdl = GCHandle.Alloc(obj);

    unsafe
    {
        IntPtr foo_add = GetAddressOf(obj, "foo");

        double* ptr = (double*) foo_add;
        Console.WriteLine("Current Value: {0}", *ptr);

        *ptr = 4;
        Console.WriteLine("Updated Value: {0}", obj.foo);
    }

    hdl.Free();

    Console.ReadLine();
}

示例输出：

Current Value: 123
Updated Value: 4

使用反射获取字段的内存地址（C＃）

1 个答案: