Hi Peter,

Thanks for getting back to me.

Sorry for not explaining my problem clearly.

My "problem" is an implementation issue not a technical one.  I can make it
work fine with byte-by-byte building of messages.  I am just trying to find
a better way.  Please note, this issue is not related to my specific
platform or code.  It's a generic interoperability issue many others have
surely faced.

I am sending and receiving messages between a managed server application
(c#) and an unmanaged embedded client application (c code).

The embedded client application is written in c and running on an RTOS (Non
MS).

The managed server application is written in c# running on WinXP.

The application messages sent over the socket are often nested structs.

Before c#, the server application was written in C/C++.  When the server
received messages from the client, all it had to do was look at a command
byte, and then cast the buffer to a message type.  Done.  Also, the server
and client could share the same header file that defined the message
structs.

Now, with c#, the managed server application cannot share the header file
with the client and cannot cast the received bytes to a message type.
Therefore, I am forced to redefine the messages in c# and build the received
message byte by byte (can't just cast).

Possible options for a better implementation:

1.  Purchase a product/library that can help with this (Can't find any).

2.  Write a Managed C++ wrapper (Have never done, and why learn now since
its being replaced by CLI/C++)

3.  Use some form of lightweight serialization that can be handled by both
platforms.

4.  Use StructLayout, MarshalAs, InPtr etc. (Ouch, this seems so tedious and
unsightly)

5.  Continue my normal byte-by-byte hack. (It works)

I know others have run into a similar problem.  However, I've yet to see a
straightforward solution.

I'm really surprised that MS doesn't provide a Class in the .Net Fx to deal
with this.

Thoughts ?

Thanks,  Jeff