.Net中如何将一个实例的内存二进制内容读出来(超简单方法)

public static class bytesprinter
{
    public unsafe static void printbytes<t>(t value)
    {
        var size = sizecalculator.instance.sizeof(() => value);
        var bytes = new byte[size];
        var pointer = unsafe.aspointer(ref value);
        intptr head = typeof(t).isvaluetype ? new intptr(pointer) : *(intptr*)pointer - intptr.size;
        marshal.copy(head, bytes, 0, size);
        console.writeline($"[{size}]{bitconverter.tostring(bytes)}");
    }
    public static string asstring(this intptr ptr) => bitconverter.tostring(bitconverter.getbytes(ptr.toint64()));
}

public class sizecalculator
{
    private static readonly concurrentdictionary<type, int> _sizes = new();
    private static readonly methodinfo _getdefaultmethod = typeof(sizecalculator).getmethod(nameof(getdefault), bindingflags.static | bindingflags.nonpublic)!;
    public static readonly sizecalculator instance = new();
    public int sizeof(type type, func<object?>? instanceaccessor = null)
    {
        if (_sizes.trygetvalue(type, out var size)) return size;
        if (type.isvaluetype) return _sizes.getoradd(type, calculatevaluetypeinstance);
        object? instance;
        try
        {
            instance = instanceaccessor?.invoke() ?? activator.createinstance(type);
        }
        catch
        {
            throw new invalidoperationexception("the delegate to get instance must be specified.");
        }
        return _sizes.getoradd(type, type => calculatereferencetypeinstance(type, instance));
    }
    public int sizeof<t>(func<t>? instanceaccessor = null)
    {
        if (instanceaccessor is null) return sizeof(typeof(t));
        func<object?> accessor = () => instanceaccessor();
        return sizeof(typeof(t), accessor);
    }
    public int calculatevaluetypeinstance(type type)
    {
        var instance = getdefaultasobject(type);
        var fields = type.getfields(bindingflags.declaredonly | bindingflags.instance | bindingflags.public | bindingflags.nonpublic)
            .where(it => !it.isstatic)
            .toarray();
        if (fields.length == 0) return 0;
        var tupletype = typeof(valuetuple<,>).makegenerictype(type, type);
        var tupple = tupletype.getconstructors()[0].invoke(new object?[] { instance, instance });
        var addresses = generatefieldaddressaccessor(tupletype.getfields()).invoke(tupple).orderby(it => it).toarray();
        return (int)(addresses[2] - addresses[0]);
    }
    public int calculatereferencetypeinstance(type type, object? instance)
    {
        var fields = getbasetypesandthis(type)
            .selectmany(type => type.getfields(bindingflags.declaredonly | bindingflags.instance | bindingflags.public | bindingflags.nonpublic))
            .where(it => !it.isstatic).toarray();
        if (fields.length == 0) return type.isvaluetype ? 0 : 3 * intptr.size;
        var addresses = generatefieldaddressaccessor(fields).invoke(instance);
        var list = new list<fieldinfo>(fields);
        list.insert(0, null!);
        fields = list.toarray();
        array.sort(addresses, fields);
        var lastfieldoffset = (int)(addresses.last() - addresses.first());
        var lastfield = fields.last();
        var lastfieldsize = lastfield.fieldtype.isvaluetype ? calculatevaluetypeinstance(lastfield.fieldtype) : intptr.size;
        var size = lastfieldoffset + lastfieldsize;
        // round up to intptr.size
        int round = intptr.size - 1;
        return ((size + round) & (~round)) + intptr.size;
        static ienumerable<type> getbasetypesandthis(type? type)
        {
            while (type is not null)
            {
                yield return type;
                type = type.basetype;
            }
        }
    }
    private static func<object?, long[]> generatefieldaddressaccessor(fieldinfo[] fields)
    {
        var method = new dynamicmethod(
            name: "getfieldaddresses",
            returntype: typeof(long[]),
            parametertypes: new[] { typeof(object) },
            m: typeof(sizecalculator).module,
            skipvisibility: true);
        var ilgen = method.getilgenerator();
        // var addresses = new long[fields.length + 1];
        ilgen.declarelocal(typeof(long[]));
        ilgen.emit(opcodes.ldc_i4, fields.length + 1);
        ilgen.emit(opcodes.newarr, typeof(long));
        ilgen.emit(opcodes.stloc_0);
        // addresses[0] = address of instace;
        ilgen.emit(opcodes.ldloc_0);
        ilgen.emit(opcodes.ldc_i4, 0);
        ilgen.emit(opcodes.ldarg_0);
        ilgen.emit(opcodes.conv_i8);
        ilgen.emit(opcodes.stelem_i8);
        // addresses[index] = address of field[index + 1];
        for (int index = 0; index < fields.length; index++)
        {
            ilgen.emit(opcodes.ldloc_0);
            ilgen.emit(opcodes.ldc_i4, index + 1);
            ilgen.emit(opcodes.ldarg_0);
            ilgen.emit(opcodes.ldflda, fields[index]);
            ilgen.emit(opcodes.conv_i8);
            ilgen.emit(opcodes.stelem_i8);
        }
        ilgen.emit(opcodes.ldloc_0);
        ilgen.emit(opcodes.ret);
        return (func<object?, long[]>)method.createdelegate(typeof(func<object, long[]>));
    }
    private static t getdefault<t>() where t : struct => default!;
    private static object? getdefaultasobject(type type) => _getdefaultmethod.makegenericmethod(type).invoke(null, array.empty<object>());
}

bytesprinter.printbytes(new foobarstructure(255, 65535));
bytesprinter.printbytes(new foobarclass(255, 65535));
public struct foobarstructure
{
    public byte foo;
    public int bar;
    public foobarstructure(byte foo, int bar)
    {
        foo = foo;
        bar = bar;
    }
}
public class foobarclass
{
    public byte foo;
    public int bar;
    public foobarclass(byte foo, int bar)
    {
        foo = foo;
        bar = bar;
    }
}

[8][ff-00-00-00]-[ff-ff-00-00]
[24][00-00-00-00-00-00-00-00]-[38-39-78-b3-fd-7f-00-00]-[ff-ff-00-00-ff-00-00-00]

await task.yield();
printthreadid();
var foobar = new foobar();
lock (foobar)
{
    bytesprinter.printbytes(foobar);
    lock (foobar)
    {
        bytesprinter.printbytes(foobar);
        lock (foobar)
        {
            bytesprinter.printbytes(foobar);
            debugger.break();
        }
    }
}
static void printthreadid()
{
    var bytes = bitconverter.getbytes(environment.currentmanagedthreadid);
    console.writeline($"thread id: {bitconverter.tostring(bytes)}");
}
public class foobar{}

var foobar = new foobar();
var hashcode = foobar.gethashcode();
printhashcode(hashcode);
bytesprinter.printbytes(foobar);
static void printhashcode(int hashcode)
{
    var bytes = bitconverter.getbytes(hashcode);
    console.writeline($"hash code: {bitconverter.tostring(bytes)}");
}

public class foobar
{
    public override int gethashcode() => int.maxvalue;
}

var foobar = new foobar();
foobar.gethashcode();
lock (foobar)
{
    bytesprinter.printbytes(foobar);
    debugger.break();
}
public class foobar{}