Convert a C++ struct to C#

Question

I am writing a C# application that communicates with an old C DLL. I looked at the header of the C DLL and saw 2 structures that I need to create in C#:

typedef struct
{
    char    user_field_name[MAXLENGTH];
    WORD    user_field_length;
    char    user_field_contents[80];
    char    user_field_requested[1];
    char    user_field_clear[1];
    char    user_field_attribute[1];
} U_FIELD_STRUCT;
typedef U_FIELD_STRUCT FAR * P_U_FIELD_STRUCT;

typedef struct
{
    char                user_begin_literal[7];
    char                user_screen_name[MNFRMSCRNAMELENGTH];
    char                key_to_be_sent[256]; 
    WORD                num_of_user_fields;
    U_FIELD_STRUCT      user_field[MAXFIELDCOUNT];
    char                user_end_literal[7];
} USER_FIELD_STRUCT;

In my C# class, I wrote them as follows:

    public const Int32 MAXLENGTH = 51;
    public const Int32 MAXTAGLENGTH = 80;
    public const Int32 MNFRMSCRNAMELENGTH = 5;
    public const Int32 MAXFIELDCOUNT = 100;
    public const Int32 MAXTAGCOUNT = 40;
    public const Int32 MAXSCREENCOUNT = 150;

    public const Int32 NO_SCREEN_DATA = 99;

    [StructLayout(LayoutKind.Sequential, Pack=4, CharSet=CharSet.Ansi)]
    public struct U_FIELD_STRUCT
    {
        [ MarshalAs( UnmanagedType.ByValArray, SizeConst=MAXLENGTH)]
        public char [] user_field_name;
        public short user_field_length;
        [ MarshalAs( UnmanagedType.ByValArray, SizeConst=80)]
        public char [] user_field_contents;
        [ MarshalAs( UnmanagedType.ByValArray, SizeConst=1)]
        public char [] user_field_requested;
        [ MarshalAs( UnmanagedType.ByValArray, SizeConst=1)]
        public char [] user_field_clear;
        [ MarshalAs( UnmanagedType.ByValArray, SizeConst=1)]
        public char [] user_field_attribute;
    };

    [StructLayout(LayoutKind.Sequential, Pack = 4, CharSet = CharSet.Ansi)]
    public struct USER_FIELD_STRUCT
    {
        [ MarshalAs( UnmanagedType.ByValArray, SizeConst=7)]
        public char [] user_begin_literal;
        [ MarshalAs( UnmanagedType.ByValArray, SizeConst=MNFRMSCRNAMELENGTH)]
        public char [] user_screen_name;
        [ MarshalAs( UnmanagedType.ByValArray, SizeConst=256)]
        public char [] key_to_be_sent;
        public short num_of_user_fields;
        [ MarshalAs( UnmanagedType.ByValArray, SizeConst=MAXFIELDCOUNT)]
        public U_FIELD_STRUCT [] user_field;
        [ MarshalAs( UnmanagedType.ByValArray, SizeConst=7)]
        public char [] user_end_literal;
    };

When I initialize the struct in C#, I do it as follows:

        USER_FIELD_STRUCT UserFieldsData = new USER_FIELD_STRUCT();
        UserFieldsData.user_begin_literal = new char[7];
        UserFieldsData.user_screen_name = new char[MNFRMSCRNAMELENGTH];
        UserFieldsData.key_to_be_sent = new char[256];
        UserFieldsData.user_field = new U_FIELD_STRUCT[MAXFIELDCOUNT];
        UserFieldsData.user_end_literal = new char[7];
        for (int i = 0; i < MAXFIELDCOUNT; i++)
        {
            UserFieldsData.user_field[i].user_field_name = new char[MAXLENGTH];
            UserFieldsData.user_field[i].user_field_contents = new char[80];
            UserFieldsData.user_field[i].user_field_requested = new char[1];
            UserFieldsData.user_field[i].user_field_clear = new char[1];
            UserFieldsData.user_field[i].user_field_attribute = new char[1];
        }

The problem is that when I pinvoke my method, I am getting an error message (basically the DLL has to validate the strings, and it sends a message that the strings are not what they are supposed to be). So I installed VS6 and I ran the DLL in Debug mode. I took a look at the struct I was sending and the strings did have the data that I put in them (some of the char[] had no data and other had a combination of 2 of the fields.)

For example, the field if I set the fields like this:

user_begin_literal=”T0k0a10”
user_end_literal=”T0k0b10”
user_screen_name=”SC00”

When I look at the object in VS6:

user_begin_literal=” T0k0a10”
user_end_literal=””
user_screen_name=”SC00”

Did I mess up my struct design?

Have you tried backing off on some of those decorators? That may be part of your problem too. — , Jul 16 '12 at 19:56

Monroe Thomas · Accepted Answer · 2012-07-16T20:05:04.197

2

In C, a char is only 1 byte, but in C# it is 2 bytes.

In C# use sbyte to map to a C char (both are signed 8-bit values), and ushort to map to a C WORD (both are unsigned 16-bit values).

If you want to assign a string value to one of your struct's buffers, you should convert it to ASCII (or UTF8 if the native code can handle it), and then copy the bytes to the field:

void CopyStringToField(string value, sbyte[] field)
{
    int maxLength = field.Length;  // or field.Length - 1 if you need room for null terminator

    byte[] fieldValue = Encoding.ASCII.GetBytes(value);
    if (fieldValue.Length > maxLength)
        throw new ArgumentException("string too long for field.");

    int length = Math.Min(fieldValue.Length, maxLength);
    Array.Copy(fieldValue, 0, field, 0, length);

    // zero fill remaining bytes
    for (int i = length; i < field.Length; i++)
    {
        field[i] = 0;
    }
}

edited Jul 16 '12 at 20:05

answered Jul 16 '12 at 19:45

Monroe Thomas

4,962
1
17
21

Yes. Use `byte` instead of `char` in C# (but I think the marshaller also lets you specify fixed-size byte strings directly). – Philipp Jul 16 '12 at 19:46
@Philipp: Yes, you can do `public fixed byte name[24];` which is the proper way to pass an array of `char` to a C/C++ DLL. – Jul 16 '12 at 19:54
@0A0D `fixed` requires use of an `unsafe` block, doesn't it? – Monroe Thomas Jul 16 '12 at 19:58
@MonroeThomas: Yes, I have used it successfully for years. Don't be scared to use it. – Jul 16 '12 at 20:00
@0A0D You should be scared if the code needs to run in an untrusted context – David Heffernan Jul 16 '12 at 21:00
@Philipp how do I copy a string onto a fixed byte[] – user889829 Jul 16 '12 at 21:06
@MonroeThomas Thank you for your answer, I tried it but i'm still getting the same error – user889829 Jul 16 '12 at 21:07
@user889829 you can use the same code as in my answer: `CopyStringToField`, but you can change the signature to byte[] instead of sbyte[] (results will be equivalent if converting to ASCII). But David's answer is a better choice, since you can just assign the strings directly to the fields. – Monroe Thomas Jul 16 '12 at 21:08
@MonroeThomas when i try that I get a compiler error, Cannot convert from byte* to byte[] – user889829 Jul 16 '12 at 21:12
@user889829 I agree with David. – Monroe Thomas Jul 16 '12 at 21:14
@DavidHeffernan: I write C++ code in an untrusted context daily. – Jul 17 '12 at 01:09
@0A0D very nice, but this is C# – David Heffernan Jul 17 '12 at 06:19
@DavidHeffernan: Either way, it's not /bad/. Even Jon Skeet suggested it. See my answer with link. – Jul 17 '12 at 11:01

score 0 · Answer 2 · edited May 23 '17 at 11:56

0

You need to restructure your C# char into a byte. Also, you need to declare the byte array as a fixed byte in order to successfully pass it to your DLL.

WORD should be labeled as ushort in C#.

It is also unclear how your struct is ordered in your DLL, but you may be OK with setting the ordering as

[StructLayout(LayoutKind.Sequential)]

We have no information on byte padding from you.

Convert a C++ struct to C#

2 Answers2

Linked