C ++结构/联合成C＃结构

Question

How do I convert this struct/union from C++ code into my C#-UWP-code? The important thing is, that the logic and references does not change because this struct must be sent to a server.

the difference to this article ( Convert C++ struct to C# )

• i have got nonprimitive datatypes (as another struct and long[]) in my struct
• i have got unions in my struct

typedef struct _HEADER
{
    _HEADER_TYPE HeaderType;
    ULONG cc;

    union
    {
        struct 
        {
            LONG Protocol;

            _TYPE CType;

            _INFO InfoDesired;  // -> that's another struct

            LONG ResolutionX[MAX_]; // -> how do i initialize an array in c# with maximum size ? 
            LONG ResolutionY[MAX_];
        } Identification;

        struct 
        {
            LONG Width;           
            _TYPE Type;
            _INFO Info; // -> that's another struct
        } Buffer;
    } u;
} _HEADER, *_HEADER;

_HEADER_TYPE is an enum:

public enum _HEADER_TYPE
        {
            _HEADER_TYPE_IDENTIFICATION,
            _HEADER_TYPE_PING
        }

_INFO is a struct:

public struct _INFO

    {
        public TJ S;
        public long Q;

        public long R1;   
    }

TJ is an enum:

public enum TJSAMP
{
       _44,
       _42            
}

_TYPE is an enum:

public enum _TYPE
{
      _OFF
      _ON
}

What I've tried so far (C# code):

  [StructLayout(LayoutKind.Explicit,Size=TotalBytesInStruct),Serializable]
    public struct _HEADER 
{ 
    [FieldOffset(0)]
    public _HEADER_TYPE HeaderType;
    [FieldOffset(2)]
    public ulong cc;
    [FieldOffset(4)] 
    public longProtocol;
    [FieldOffset(4)]
    public _TYPE CType;
    [FieldOffset(4)]
    public _INFO InfoDesired;  // -> that's another struct
    [FieldOffset(4)]
    [MarshalAsAttribute(UnmanagedType.ByValTStr, SizeConst = 15)]
    public long[] ResolutionX; 
    [FieldOffset(4)]
    [MarshalAsAttribute(UnmanagedType.ByValTStr, SizeConst = 15)]
    public long[] ResolutionY;
    [FieldOffset(8)]
    public long Width;     
    [FieldOffset(8)]      
    public _TYPE Type;
    [FieldOffset(8)]
    public _INFO Info; // -> that's another struct
 }

Does this exactly the same as the c++ struct above ?

Answer 1

Here is what I got, assuming a packed layout (which is not always the case, you will need to check your C++ code):

public class Program
{
    public static void Main()
    {
        Console.WriteLine($"sizeof(_INFO): {Marshal.SizeOf(typeof(_INFO))}");
        Console.WriteLine($"sizeof(Identification): {Marshal.SizeOf(typeof(Identification))}");
        Console.WriteLine($"sizeof(Buffer): {Marshal.SizeOf(typeof(Buffer))}");
        Console.WriteLine($"sizeof(_HEADER): {Marshal.SizeOf(typeof(_HEADER))}");
        Console.WriteLine();

        Console.WriteLine("To prove that it behaves union-like:");
        var header = new _HEADER();
        header.Identification.Protocol = 5;
        Console.WriteLine($"header.Identification.Protocol: {header.Identification.Protocol}");
        Console.WriteLine($"header.Buffer.Width: {header.Buffer.Width}");
    }

    public const int MAX_ = 10;
}

public enum TJ { _44, _42 }

public enum _TYPE { _OFF, _ON }

public enum _HEADER_TYPE { _HEADER_TYPE_IDENTIFICATION, _HEADER_TYPE_PING }

[StructLayout(LayoutKind.Explicit, Pack=4, Size=20)]
public struct _INFO
{
    [FieldOffset(0)] public TJ S;
    [FieldOffset(4)] public long Q;
    [FieldOffset(12)] public long R1;   
}

[StructLayout(LayoutKind.Explicit, Pack=4, Size=32+2*8*Program.MAX_)]
public struct Identification
{
    [FieldOffset(0)] public long Protocol;
    [FieldOffset(8)] public _TYPE CType;
    [FieldOffset(12)] public _INFO InfoDesired;

    [MarshalAsAttribute(UnmanagedType.ByValArray, SizeConst = Program.MAX_)]
    [FieldOffset(32)] public long[] ResolutionX;

    [MarshalAsAttribute(UnmanagedType.ByValArray, SizeConst = Program.MAX_)]
    [FieldOffset(32 + Program.MAX_ * 8)] public long[] ResolutionY;
}

[StructLayout(LayoutKind.Explicit, Pack=4, Size=32)]
public struct Buffer
{
    [FieldOffset(0)] public long Width;
    [FieldOffset(4)] public _TYPE Type;
    [FieldOffset(12)] public _INFO Info;
}

[StructLayout(LayoutKind.Explicit, Pack=4, Size=204)]
public struct _HEADER
{
    // First slot (4 bytes)
    [FieldOffset(0)] public _HEADER_TYPE HeaderType;

    // Second slot (8 bytes)
    [FieldOffset(4)] public ulong cc;

    // The next 2 structs share the third slot (204 bytes)
    [FieldOffset(12)] public Identification Identification;
    [FieldOffset(12)] public Buffer Buffer;
}

Output:

sizeof(_INFO): 20
sizeof(Identification): 192
sizeof(Buffer): 32
sizeof(_HEADER): 204

To prove that it behaves union-like:
header.Identification.Protocol: 5
header.Buffer.Width: 5

The points to note are that:

• an enum is basically an int , so it uses 4 bytes;
• a long uses 8 bytes;
• the argument of FieldOffset is in byte;
• you need to keep MAX_ in sync between C++ code and C# code.