如何将结构体与 marshal.sizeof c#/c++ 联合

Question

The Problem is that I'm trying to use c++ structure in my c# programm.

We are using Mail slots to communicate with a user interface and there is no other way to do this because of the complexity and age and it is running on over 1000 machines all around the world.

Our structure looks like this

// Message data
typedef struct _t_messageData
{
    t_messageHeader header;
    t_messageBody body;
    t_messageParameter parameter;
} t_messageData;

typedef struct _t_messageHeader 
{
    UCHAR  stx;
    UCHAR  packetType;
    USHORT packetCount;
    USHORT checksum;
    UCHAR  sourceAddress;
    USHORT sourcePID;
    UCHAR  destinationAddress;
    USHORT destinationPID;
    UCHAR  destinationNet;
    USHORT packetSequenceNumber;
    USHORT packetID;
} t_messageHeader;

// Message body
typedef struct _t_messageBody 
{
    char    order[4];
    USHORT  module;
    USHORT  station;
    USHORT  part;
    USHORT  position;
} t_messageBody;

// Message parameter
typedef union _t_messageParameter 
{
    t_internalProcessData internalProcess;
    char data[PACKET_DATA_SIZE];
} t_messageParameter;


typedef struct _t_internalProcessData
{
    USHORT command;
    UCHAR data[PACKET_DATA_SIZE-2];
} t_internalProcessData;

In c# all the sizes are fixed by these values.

public const int PACKET_HEADER_SIZE = 17;
public const int PACKET_BODY_SIZE = 12;
public const int PACKET_COMPLETE_SIZE = 4204;
public const int PACKET_DATA_SIZE = PACKET_DATA_SIZE = 4175;

Now the problem is not with the header or the body, that was pretty simple to manage. The problem is with the union.

class MailslotData
{
    // Message header
    [StructLayout(LayoutKind.Sequential, Pack=1)]
    public struct SMessageHeader
    {
        public byte stx;
        public byte packetType;
        public ushort packetCount;
        public ushort checksum;
        public byte sourceAddress;
        public ushort sourcePID;
        public byte destinationAddress;
        public ushort destinationPID;
        public byte destinationNet;
        public ushort packetSequenceNumber;
        public ushort packetID;
    };

    // Message body
    [StructLayout(LayoutKind.Sequential, Pack=1)]
    public struct SMessageBody
    {
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
        public char[] order;
        public ushort placeHolder1;     // Old ModuleNbr
        public ushort station;
        public ushort part;
        public ushort placeHolder2;     // Old PositionNbr
    };

Now here comes the problem. The Union. With the Fieldoffset I can stick both the byte array and the struckt that have the same size into the same location.

[StructLayout(LayoutKind.Explicit, Pack = 1)]
public struct SMessageParameter
{
    [FieldOffset(0)]
    public SInternalProcessData strInternalProcess;
    [FieldOffset(0)]
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = PACKET_DATA_SIZE)]
    public byte[] data;
};

While defining it this way I get an ArgumentException at CalculateChecksum(). I declare my struct with new and i only use SInternalProcess like seen here.

public void CreateInternalProcessMessage(ushort station, ushort part, ushort command)
{
    CreateMessageHeader(PACKETTYPE_SINGLE_PACKET, ADDRESS_USERINT, PID_USERINT, DESTINATIONNET_USERINT, 0);

    CreateMessageBody (INTERNAL_PROCESS_MESSAGE.ToCharArray(), station, part);

    messageData.parameter.strInternalProcess.command = command;
    messageData.header.packetCount += (ushort)Marshal.SizeOf (messageData.parameter.strInternalProcess.command);

    messageData.parameter.strInternalProcess.data = new byte[PACKET_DATA_SIZE - 2];

    messageData.parameter.strInternalProcess.data[0] = (byte)ETX;
    messageData.header.packetCount += 1;
    CalculateChecksum();
}

In CalculateChecksum() i'll get ArgumentException{"Type could not be marshaled because the length of an embedded array instance does not match the declared length in the layout."}

which you can see at the image here.

//This is the part where there would have been a picture but i don't have enough reputation. So I have to write it down. :-( i'll post it asap my repu is up to 10.

unsafe void CalculateChecksum()
{
    int i = 0;
    ushort checksum = 0;
    i = Marshal.SizeOf(messageData);
    i = sizeof(ushort);

    byte[] byteArray = new byte[Marshal.SizeOf(messageData)];


    fixed (byte* pArray = byteArray)Marshal.StructureToPtr(messageData, new IntPtr (pArray), false);

    // Calculate the checksum
    messageData.header.checksum = 0;
    for (byte u = 0; u < messageData.header.packetCount; u++)
        checksum += byteArray[u];

    messageData.header.checksum = checksum;
}

*messageData.parameter.data -> 0x00cc1bfc and *messageData.parameter.strInternalProcess.data -> 0x00cc1bfc

both data array's are pointing to the same position, which is wrong there should be at least a 2byte offset because of the ushort command.

My byte[] byteArray is 4204

So after reading a lot more and trying to figure it out myself I found 2 possible solutions. But each solution has a problem i can't solve by my self.

First of all am i doing something wrong in all the things i have done up to now, or is there a simple solution to the code i have posted.

So now i'll get to the possible solutions that i have thought of but i will post them separately below this post.

Thanks for all your help. I appreciated every answer because i am stuck at this point for over a week now and don't know anything else to try.

Answer 1

Possible solution for the Problem mith a new problem that i can't fix myself.

I changed the definition of:

    public byte[] data;   
    to look as followed
    public fixed byte data[PACKET_DATA_SIZE];

Here you can see the whole changes

public unsafe struct SInternalProcessData
{
    public ushort command;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = PACKET_DATA_SIZE - 2)]
    public fixed byte data[PACKET_DATA_SIZE - 2];
};

[StructLayout(LayoutKind.Explicit, Pack = 1)]
public unsafe struct SMessageParameter
{
    [FieldOffset(0)]
    public SInternalProcessData strInternalProcess;
    [FieldOffset(0)]
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = PACKET_DATA_SIZE)]
    public fixed byte data[PACKET_DATA_SIZE];
};


public const int PACKET_HEADER_SIZE = 17;
public const int PACKET_BODY_SIZE = 12;
public const int PACKET_COMPLETE_SIZE = 4204;
public const int PACKET_DATA_SIZE = PACKET_COMPLETE_SIZE - PACKET_HEADER_SIZE - PACKET_BODY_SIZE;
//value PACKET_DATA_SIZE = 4175 

This fixes the problem that i have with both data array's pointing at the same location. As you can see in the Picture. But it creates an new problem.

Type 'GettingStartedClient.MailslotData+SMessageData' cannot 
be marshaled as an unmanaged structure; no meaningful size or offset can be computed.

So I played with the settings for the [MarshalAs(UnmanagedType. but i could not find a configuration that would work fine.

I tested all settings with a subset from my structure Marshal.SizeOf(messageData.parameter.data)

So here is my problem that i would need some help with.

Answer 2

Type 'GettingStartedClient.MailslotData+SMessageData' cannot be marshaled as an unmanaged structure; no meaningful size or offset can be computed.

So I played with the settings for the [MarshalAs(UnmanagedType. but i could not find a configuration that would work fine.

Now i know why. So to understand the background makes it all clear. I was trying to mashal a fixed array. What mashel does is to rearrange the structure to look like you have decided it to look. which the mashal command can't do with a fixed array.

So the solution was pretty easy. Remove the mashaling and voilà. It all works fine.

[StructLayout(LayoutKind.Explicit, Size = PACKET_DATA_SIZE, Pack = 1)]
public unsafe struct SInternalProcessData
{
    [FieldOffset(0)]
    public ushort command;
    [FieldOffset(1)]
    public fixed byte data[PACKET_DATA_SIZE - 2];
};

[StructLayout(LayoutKind.Explicit, Size = PACKET_DATA_SIZE, Pack = 1)]
public unsafe struct SMessageParameter
{
    [FieldOffset(0)]
    public SInternalProcessData strInternalProcess;
    [FieldOffset(0)]
    public fixed byte data[PACKET_DATA_SIZE];
};