Develop Reference

Marshalling ByValTStr as UTF8

I am working with a C DLL and have trouble with marshalling strings using P/Invoke.
The DLL has a struct as follows:
typedef struct
{
char sAddress[256];
BYTE byUseRtsp;
WORD wPort;
}INFO,*LPINFO;
My C# struct looks like this:
[StructLayout(LayoutKind.Sequential)]
public struct INFO
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
public string sAddress;
public byte byUseRtsp;
public short wPort;
}
The string marshalling for sAddress works with ASCII text, but the DLL uses UTF-8 encoding throughout. So as soon as multi-byte characters are used the marshalling garbles the text. Using CharSet.Unicode doesn't work here as that tells the marshaller to encode/decode strings as UTF-16 on Windows. I need a CharSet.Utf8 which unfortunately doesn't exist.
I do have a workaround, but it's ugly and want to avoid if possible. The workaround is to replace:
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
public string sAddress;
with:
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
public byte[] sAddress;
and then just re-write my code to use Encoding.UTF8.GetBytes/String() methods to get the string values. I will also need to handle null-terminators myself with this method.
Is there a better way of doing this?

Is there a better way of doing this?
Using the built-in options for marshalling what you have done is probably as good as it gets. You would want to write some helper methods to manage this for you, but I'm sure you are alive to that.
Beyond this you could use a custom marshaler. I'm not aware that there is a great body of work available on this topic. One of the more complete happens to be this question of mine: How do I write a custom marshaler which allows data to flow from native to managed?

[In case it helps others] .NET Framework 4.7 introduced UnmanagedType.LPUTF8Str which is likely just for this situation.

Conversion of C/C++ Struct To C#.Net CF WinCE

Hi I am trying to convert the C/C++ Strcut to C#
C/C++ Struct looks like:
typedef struct _NDISUIO_QUERY_OID
{
NDIS_OID Oid;
PTCHAR ptcDeviceName;
UCHAR Data[sizeof(ULONG)];
} NDISUIO_QUERY_OID, *PNDISUIO_QUERY_OID;
My C# Struct is:
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct _NDISUIO_QUERY_OID
{
public uint Oid;
[MarshalAs(UnmanagedType.LPWStr)]
public string ptcDeviceName;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8*sizeof(uint))]
public string Data;
};
I was bit doubtful about the converted structure, can anyone clarify me about this conversion??
If possible can anyone please tell me any tutorials or some references that are useful for conversion of data types or structures from c/c++ to C#.Net CF.
Thanks :)

In a previous question of yours, #ctacke said that you won't be able to use MarshalAs(UnmanagedType.LPWStr) with the compact framework. He asserted that you would have to declare that field as IntPtr, and marshal it manually.
However, this MSDN document states that MarshalAs(UnmanagedType.LPWStr) works under the compact framework. I suppose I am inclined to believe the MSDN documents.
The final member is also declared incorrectly. The SizeConst must be sizeof(uint).

How do I make fixed-size byte array user type in C#?

I'm converting an old Visual BASIC program to C#. It sends messages to some industrial machinery over ethernet. To do this it assembles a stream of bytes from fixed-size user defined chunks.
Most of these chunks are small and in C# it's easy to create structs of a few bytes or ints and control their size and layout using StructLayout's, for example
[StructLayout(LayoutKind.Sequential, Pack = 1)]
...so when we go into unmanaged space to do a bytewise copy we don't have byte order or padding problems.
But some of the VB6 structures are big arrays, for example,
Private Type SEND_MSG_BUFFER_320_BYTES
bytes(0 To 319) As Byte '320 bytes
End Type
and I'm struggling with how to do this in C#. I can make a fixed size array in a class, e.g.,
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public class SOME_BYTES
{
public byte[] b = new byte[320];
}
but to do the byte-wise copy I need to be able to discover the size of this at runtime and System.Runtime.InteropServices.Marshal.SizeOf returns a 4 for this.
Any suggestions for how do do this will be much appreciated.

You can use fixed size buffers if you're okay with unsafe code, and changing your class into a struct:
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public unsafe struct SomeBytes
{
public fixed byte MessageData[320];
}
Personally I would try to avoid all of this if possible. If you're just sending the data over the network, why do you need to "go into unmanaged space"? Can you remove that requirement somehow? (Maybe it's fundamental - but it's not clear from your question.)

You can use a fixed-size array:
unsafe struct SomeBytes {
public fixed byte b[320];
}

I think you want to do something like this:
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public class SOME_BYTES
{
[MarshalAs(UnmanagedType.ByValArray, SizeConst=320)]
public byte[] b;
}
You would initialise it as follows:
SOME_BYTES data = new SOME_BYTES {b = new byte[320]};
Then you can populate data.b[] and use marshalling to get the data to send. The MarshalAs attribute tells the marshaller what fixed size buffer to use when marshalling the data.
You don't need to use the unsafe fixed keyword to do this kind of thing, and I strongly recommend that you avoid it.

Marshal exception when using arrays of structs [duplicate]

i am using a COM dll in my C# Project.
I have one USERINFO Structure in my COM dll which looks like :
struct USERINFO
{
BYTE UserID[USER_ID_SIZE];//42
BYTE FirstName[NAME_SIZE];//66
BYTE LastName[NAME_SIZE]; //66
long Pin;
BYTE TimeGroupIDList[IDLIST_SIZE];//10
enum EUserKind eUserKind;
BYTE WarningEye;
};
When i use this structure in my C# Application to fill this structure for User data and pass to my AddUser API it returns this Error.
Any help is appreciated.
Thanks.

C# does not support fixed-length arrays embedded in a struct (except in an unsafe context) so your C structure is probably being marshalled into a C# structure something like this:
struct USERINFO
{
MarshalAs(UnmanagedType.ByValArray, SizeConst = 42)
BYTE[] UserID;
MarshalAs(UnmanagedType.ByValArray, SizeConst = 66)
BYTE[] FirstName;
// etc.
};
Note that the members are references to arrays, not embedded arrays.
For the marshalling to work the arrays have to be exactly the right length (or maybe at least the right length, I forget). For example, UserID should be initialised with userInfo.UserID = new byte[42];

Using struct in C# as you would in C - can you?

I am reading a binary file of a specific format, and am used to being able to cast a block of data to a struct then reading the struct to pull fields out of the binary datafile.
I'm trying to do this but failing in C#, they seem more like classes than structures in the C sense. Is it possible to do what I want? For example..
public struct Datum {
byte type;
ushort payload;
}
public struct DiskPage {
ushort pageNumber;
Datum[] data = Datum[170];
}
I want to be able to read 512 bytes of a file and cast it to a DiskPage, then to be able to read the values from the DiskPage structure. Is this possible in c# - or is there another preferred approach? Should I just leave that code in C and link it in?
Thanks!
Reza

The compiler doesn't respect ordering of your fields by default (also it might move the fields and leave gaps in the memory = Packing). By using StructLayout you can enforce a different behavior (Default, Sequential, or Explicit).
Use MarshalAs for specific options on a field. Be careful with endianess.
[StructLayout(LayoutKind.Explicit, Size=16, CharSet=CharSet.Ansi)]
public struct MySystemTime
{
[FieldOffset(0)]public ushort wYear;
[FieldOffset(2)]public ushort wMonth;
[FieldOffset(4)]public ushort wDayOfWeek;
[FieldOffset(6)]public ushort wDay;
[FieldOffset(8)]public ushort wHour;
[FieldOffset(10)]public ushort wMinute;
[FieldOffset(12)]public ushort wSecond;
[FieldOffset(14)]public ushort wMilliseconds;
}

I suggest you read Mastering C# structs that discusses using marshaling (Marshal.Copy in particular) for that purpose.

You can use fixed arrays in C# if you compile with Unsafe option enabled.
You can also use pointers.
internal unsafe struct MyStruct
{
public fixed byte MyFixedArray[128];
public byte* MyPointer;
}
It is preferred to use marshalling, field offset and avoid unsafe code.
Use unsafe code if you really need too in small portion of your code.
Don't expose to external world a fixed array or a pointer (interfaces or public classes\structs) if you can avoid it.