How do I get a byte* for the bits in a BitArray?

Question

I am working on a C++ CLI wrapper of a C API. One function in the C API expected data in the form:

void setData(byte* dataPtr, int offset, int length);
void getData(byte* buffer, int offset, int length);

For the C++ CLI it was suggested that we use a System.Collections.BitArray (Yes the individual Bits have meaning). A BitArray can be constructed from an array of bytes and copied to one:

  array<System::Byte>^ bytes = gcnew array<System::Byte>(40);
  System::Collections::BitArray^ ba = gcnew System::Collections::BitArray(bytes);
  int length = ((ba->Length - 1)/8) +1;
  array<System::Byte>^ newBytes = gcnew array<System::Byte>(length);
  ba->CopyTo(newBytes, 0);
  pin_ptr<unsigned char> rawDataPtr = &buffer[0];

My concern is the last line. Is it valid to get a pointer from the array in this way? Is there a better alternative in C# for working with arbitrary bits? Remember the individual bits have meaning.

Answer 1

Is it valid to get a pointer from the array in this way?

Yes, that's valid. The pin_ptr<> helper class calls GCHandle.Alloc() under the hood, asking for GCHandleType.Pinned. So the pointer is stable and can be passed to unmanaged code without fear that the garbage collector is going to move the array and make the pointer invalid.

A very important detail is missing from the question however. The reason that pin_ptr<> exists instead of just letting you use GCHandle directly is exactly when the GCHandle.Free() method will be called. You don't do this explicitly, pin_ptr<> does it for you, it uses the standard C++ RAII pattern. In other words, the Free() method is automatically called, it happens when the variable goes out of scope. Which gets the C++ compiler to emit the destructor call, it in turns calls Free().

This will go very, very wrong when the C function stores the passed dataPtr and uses it later. Later being the problem, the array won't be pinned anymore and can now exist at an arbitrary address. Major data corruption, very hard to diagnose. The getData() function strongly suggests that is fact the case. This is not good.

You will need to fix this, using GCHandle::Alloc() yourself to pin the array permanently is very painful to garbage collector, a rock in the road that won't budge and has a long-lasting effect on the efficiency of the program. Instead you should copy the managed array to stable memory that you allocate with, say, malloc() or Marshal::AllocHGlobal(). That's unmanaged memory, it will never move. Marshal::Copy() is a simple way to copy it.