How to resolve AOT when using Marshal.PtrToStructure occurs IL2091 warnings

[maikebing]

I'm having the following issue when trying to convert a piece of data to a struct

Here's an example repository: https://github.com/maikebing/115140

T BytesTo<T>(byte[] rawdatas) where T : struct
{
    var t = new T();
    int rawsize = Marshal.SizeOf<T>();
    IntPtr buffer = Marshal.AllocHGlobal(rawsize);
    Marshal.Copy(rawdatas, 0, buffer, rawsize);
    t = Marshal.PtrToStructure<T>(buffer);//  can't AOT !
    Marshal.PtrToStructure(buffer, t);// The structure must not be a value class
    Marshal.FreeHGlobal(buffer);
    return t;
}

The following code can be converted, but there will be AOT warnings .

var    t = Marshal.PtrToStructure<T>(buffer);

warning IL2091: 'T' generic argument does not satisfy 'DynamicallyAccessedMemberTypes.PublicConstructors', 'DynamicallyAccessedMemberTypes.NonPublicConstructors' in 'System.Runtime.InteropServices.Marshal.PtrToStructure(nint)'. The generic parameter 'T' of 'BytesTo(Byte[])' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.

The following method does not have an AOT alarm, but an exception occurs.

Marshal.PtrToStructure(buffer, t);

The structure must not be a value class. (Parameter 'structure'

t = MemoryMarshal.Read<T>(rawdatas);

Cannot use type 'DF_X0_Result'. Only value types without pointers or references are supported.

Type 'DF_X0_Result'

https://github.com/maikebing/115140/blob/2f01505ff2602876166aefb75e91ffaf16c49333/Program.cs#L72

My question is, what should I do if the AOT conditions are met?

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/interop-contrib
See info in area-owners.md if you want to be subscribed.

[Sergio0694]

Can you just use MemoryMarshal.Read<T>(data), assuming your T is blittable?

[huoyaoyuan]

You need to propagate the required attribute to the generic parameter of your method, like this:

BytesTo<[DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors] T>

If the type is blittable, then using MemoryMarshal.Read is much more effecient.

[maikebing]

@Sergio0694 @huoyaoyuan

t = MemoryMarshal.Read(rawdatas);

Cannot use type 'DF_X0_Result'. Only value types without pointers or references are supported.

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
public struct DF_X0_Result

[huoyaoyuan]

MemoryMarshal.Read is not available if your struct isn't blittable and contains reference types like string or array. Use the attribute approach instead.

In long term, it's still recommended to modify your structure definition. Learn more at https://learn.microsoft.com/dotnet/standard/native-interop/best-practices.

[Zonciu]

Use MemoryMarshal.Read and make sure your struct members all are non-object fields. Like public byte[] LaneHex; you need to convert to public unsafe fixed byte LaneHex[_lane_hex_size], or use InlineArray instead:

[InlineArray(4)]
public struct LaneHex
{
    public byte Value;
}

Example:

var t1 = new Test
{
    A = 0xC,
    B = 0x23,
    C = 0xFF,
    D = new Byte4(),
};

t1.D[0] = 0xA;
t1.D[1] = 0x14;
t1.D[2] = 0x1E;
t1.D[3] = 0x32;

unsafe
{
    t1.E[0] = 0x1A;
    t1.E[1] = 0x24;
    t1.E[2] = 0x3E;
    t1.E[3] = 0x42;
}

var bytes1 = new byte[18];
MemoryMarshal.Write(bytes1, t1);

var t2 = MemoryMarshal.Read<Test>(bytes1);

Console.WriteLine(t1);
Console.WriteLine(t2);

var dSpan = MemoryMarshal.CreateSpan(ref Unsafe.As<Byte4, byte>(ref t2.D), 4);
Console.WriteLine($"D Span: {dSpan[0]:X},{dSpan[1]:X},{dSpan[2]:X},{dSpan[3]:X}");

[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 18)]
public struct Test
{
    [FieldOffset(0)]
    public int A;

    [FieldOffset(4)]
    public int B;

    [FieldOffset(8)]
    public ushort C;

    [FieldOffset(10)]
    public Byte4 D; // 4 bytes

    [FieldOffset(14)]
    public unsafe fixed byte E[4];

    public override unsafe string ToString()
    {
        return $"{A:X},{B:X},{C:X}, {D[0]:X},{D[1]:X},{D[2]:X},{D[3]:X}, {E[0]:X},{E[1]:X},{E[2]:X},{E[3]:X}";
    }
}

[InlineArray(4)]
public struct Byte4
{
    public byte V;
}

[agocke]

It looks like others have outlined solutions to your problem, but to summarize, you have two options:

1. You can propagate the DynamicallyAccessedMembers annotation to your type parameters, as @huoyaoyuan suggests.
2. You can refactor all the callers to be blittable (i.e., not contain any object references). You can then manually convert from the blittable type to the final type that your callers expect (e.g., by converting native IntPtr strings into C# strings).

Of the two options, (2) is more work but it's also preferred. C# has historically built up a large set of automatic conversions that it can do for interop scenarios. Many of these conversions can be unintuitive or surprising. Since all interop is unsafe, the runtime will not provide any checking, so mistakes can lead to silent data corruption. Our modern recommendation: be explicit. It is easier to ensure that your code and the native code match up. As a benefit, it will likely be a lot faster than automatic marshalling.

[maikebing]

Thank you @Zonciu , @agocke, for the best advice.