C++/CLI (.NET) equivalent of Native C++ writing structure to network

Question

I recently inherited a program that mixes C++ and C++/CLI (.NET). It interfaces to other components over the network, and to a Driver DLL for some special hardware. However, I am trying to figure out the best way to send the data over the network, as what is used seems non-optimal.

The data is stored in a C++ Defined Structure, something like:

    struct myCppStructure {
        unsigned int field1;
        unsigned int field2;
        unsigned int dataArray[512];
    };

The program works fine when accessing the structure itself from C++/CLI. The problem is that to send it over the network the current code does something like the following:

    struct myCppStructure* data;
    IntPtr dataPtr(data);
    // myNetworkSocket is a NetworkStream cast as a System::IO::Stream^
    System::IO::BinaryWriter^ myBinWriter = gcnew BinaryWriter(myNetworkSocket);
    __int64 length = sizeof(struct myCppStructure) / sizeof(__int64);
    unsigned __int64* ptr = static_cast<__int64*>(dataPtr.toPointer());
    for (unsigned int i = 0; i < (length / sizeof(unsigned __int64)); i++)
        myBinWriter->Write((*ptr)++);

In normal C++ it'd usually be a call like:

    myBinWriter->Write(ptr,length);

But I can't find anything equivalent in C++/CLI. System::IO::BinaryWriter only has basic types and some array<>^ versions of a few of them. Is there nothing more efficient?

P.S. These records are generated many times a second; so doing additional copying (e.g. Marshaling) it out of the question.

Note: The original question asked about C#. I failed to realize that what I was thinking of as C# was really "Managed C++" (aka C++/CLI) under .NET. The above has been edited to replace 'C#' references with 'C++/CLI' references - which I am using for any version of Managed C++, though I am notably using .NET 3.5.

Answer 1

What you want to do is to find out how the C++ struct is packed, and define a struct with the correct StructLayout attribute.

To define the fixed length int[], you can defined a fixed size buffer inside it. Note that to use this you will have to mark your project /unsafe.

Now you're ready to convert that struct to a byte[] using two steps

1. Pin the array of structs in memory using a GCHandle.Alloc - this is fast and shouldn't be a performance bottleneck.
2. Now use Marshal.Copy (don't worry, this is as fast as a memcpy) with the source IntPtr = handle.AddrOfPinnedObject.

Now dispose the GCHandle and you're ready to write the bytes using the "Write" overload mentioned by Serg Rogovtsev.

Hope this helps!

Answer 2

Your structure consists of "basic types" and "array of them". Why can't you just wrote them sequentially using BinaryWriter? Something like

binWriter.Write(data.field1);
binWriter.Write(data.field2);
for(var i = 0; i < 512; i++)
    binWriter.Write(data.dataArray[i]);

Answer 3

In C# you could do the following. Start by defining the structure.

[StructLayout ( LayoutKind.Sequential )]
internal unsafe struct hisCppStruct
{
    public uint field1;
    public uint field2;
    public fixed uint dataArray [ 512 ];
}

And then write it using the binary writer as follows.

hisCppStruct @struct = new hisCppStruct ();
@struct.field1 = 1;
@struct.field2 = 2;
@struct.dataArray [ 0 ] = 3;
@struct.dataArray [ 511 ] = 4;

using ( BinaryWriter bw = new BinaryWriter ( File.OpenWrite ( @"C:\temp\test.bin") ) )
{
    int structSize = Marshal.SizeOf ( @struct );
    int limit = structSize / sizeof ( uint );

    uint* uintPtr = (uint*) &@struct;

    for ( int i = 0 ; i < limit ; i++ )
        bw.Write ( uintPtr [ i ] );
}

I'm pretty sure you can do exactly the same in managed C++.