How to Migrate structs form C++ to C#

Question

I'm writing an UDP client which is receiving complex data structures. I do have the structures in C++, but my program is in C#

There are a lot of different structures with Bitfiels and unions.

Is there any way that I do not have to convert the structs by hand?

Also is there an easy way to implement Bitfields and Unions in C#?

Right now I'm using Properties for Bitfields, but that's some difficult work, with a strong possibility for mistakes.

I provided an simplified example what I'm doing right now, there are about 50 structs with 100 lines of code each.

Example c++:

typedef struct Message_s
{
    unsigned char var : 2;
    unsigned char var2 : 6;

    union
    {
         struct
         {
            unsigned char sVar;
            unsigned char sVar2;
         }
         char arr[32];
     }    
}Message_t;

Example C#:

 [System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential)]
struct Message_s
{
    private byte Field1
    public byte var
    {
       get
       {
           return (byte)(Field1 & 0x03);
       }
       set
       {
           Field1 = (byte)((Field1 & ~0x03) | value);
       }
    public byte var2
    {
       get
       {
           return (byte)(Field1 & 0xFC);
       }
       set
       {
           Field1 = (byte)((Field1 & 0x03) | value<<2);
       }
     }
//unions may be possible with properties...
}

Answer 1

As an alternative, there is a way of using unmanaged C++ types in your code, but it does still involve some typing. In a VS C++ project, create your unmanaged struct:

struct Date_s
{
    union
    {
        struct
        {
            unsigned nWeekDay  : 3;    // 0..7   (3 bits)
            unsigned nMonthDay : 6;    // 0..31  (6 bits)
            unsigned           : 0;    // Force alignment to next boundary.
            unsigned nMonth    : 5;    // 0..12  (5 bits)
            unsigned nYear     : 8;    // 0..100 (8 bits)
        };
        unsigned bob;
    };
};

Now we create a managed type which wraps this structure:

public ref struct Date_ms
{
    AutoPtr<Date_s> data;
    Date_ms()
    {
        data = new Date_s();
    }

    property unsigned nWeekDay
    {
        unsigned get() { return data->nWeekDay; }
        void set(unsigned value) { data->nWeekDay = value; }
    }
    property unsigned nMonthDay
    {
        unsigned get() { return data->nMonthDay; }
        void set(unsigned value) { data->nMonthDay = value; }
    }
    property unsigned nMonth
    {
        unsigned get() { return data->nMonth; }
        void set(unsigned value) { data->nMonth = value; }
    }
    property unsigned nYear
    {
        unsigned get() { return data->nYear; }
        void set(unsigned value) { data->nYear = value; }
    }
    property unsigned bob
    {
        unsigned get() { return data->bob; }
        void set(unsigned value) { data->bob = value; }
    }
};

There's some copy and pasting to do there. There's also an external item I use here: it's AutoPtr from Kerr. I've also added the line T* operator=(T* rhs) { return (m_ptr = rhs); } to the AutoPtr code (as suggested in the comments to Kerr's post) to make the initialiser work.

You can now use this new structure in your C# code, and everything should work as expected:

var test = new Date_ms();
test.nMonth = 3;
test.nMonthDay = 28;
test.nYear = 98;
Console.WriteLine("{0}, {1}, {2}", test.nMonth, test.nMonthDay, test.nYear);
Console.WriteLine("{0}", test.bob);

results in 3, 28, 98 and 224.

BIG GIANT WARNING

Mixing managed and unmanaged code like this is dangerous, which is why Kerr wrote AutoPtr in the first place (BTW, his blog post on the topic is well worth a read). This works for me, but I can't guarantee that it won't cause memory leaks. You should definately check that this works as intended before deploying it.