Question

Lets say we have a native library that works with data like this:

 double *pointer = &globalValue; 
 SetAddress(pointer);

 //Then we can change value and write it to disk
 globalValue = 5.0;

 FlushValues(); // this function writes all values 
                // registered by SetAddress(..) functions

 ... //Then we change our value (or values)
 FlushValues(); //and do write any time we need

Now I have to interop it to C#. I would like to avoid using unsafe… but… I dont know =)

So on C# side we will have some class wich fields we will write. And we can do writing like:

 public class Data
 {
     [Serializable] <-- somehow we mark what we are going to write
     double myValue;

     ...

     [Serializable]
     double myValueN;
 }

 public class LibraryInterop
 {
      IntPtr[] pointers; //Pointers that will go to SetAddressMethod
      ...

      public void RegisterObject(Data data)
      {
          ... //With reflection we look for [Serializable] values
              //create a pointer for each and some kind of BindingInfo 
              //that knows connection of pointers[i] to data.myValueN

          //Then add this pointers to C++ library
          foreach(IntPtr pointer in pointers) { SetAddress(pointer);}
      }

      public void Flush() 
      {
          //Loop through all added pointers
          for(int i=0; i<pointers.Length; i++)
          {
              double value = ... //With reflections and BindingInfo we find data.myValueN
                                 // that corresponds to pointers[i]

              // then we write this value to memory of IntPtr
              // we have to brake value to bytes and write it one by one to memory
              // we could use BitConverter.DoubleToInt64Bits() but double - is just 
              // an example, so in general case we will use GetBytes
              int offset = 0;
              foreach(byte b in BitConverter.GetBytes(value))
              {
                  Marshal.WriteByte(pointer[i],offset,byte);
                  offset++;
              }
          }

          //Save values of IntPtr to disk
          FlushValues();
      }
  }

Then the user code looks like this then

  var library = new LibraryInterop();
  var data1 = new Data();
  var data2 = new AnotherData();
  library.RegisterObject(data1);
  library.RegisterObject(data2);

  ...//change data
  library.Flush();
  ...//change data
  library.Flush();
  ...//change data
  library.Flush();

So in C++ we have a very neat structure. We have pointers, we fill data behind this pointers and on FlushValues all this values are writed.

C# part cannot have SetAddress(ref double value). Since address may change, we have to pin pointers – use unsafe+fixed or IntPtr, and have SO many headache.

On the other hand, we can have “managed pointers” by boxing|unboxing data.myValue to Object. So if it would be possible to somehow bind this ValueType data.myValue to IntPtr without this coping and reflection – it would be much much neater.

Is it possible to do this interop and have less ugly and slow C# part then the one I listed here?

Answer 1

(There are some major downsides to this…)

You can use GCHandle.Alloc(data1, GCHandleType.Pinned) to “pin” an object, and then get an IntPtr from GCHandle.AddrOfPinnedObject. If you do this, you’ll be able to pass this IntPtr to your native code, which should work as expected.

However, this is going to cause a lot of issues in terms of undermining the efficiency of the garbage collector. If you decide to do something like this, I’d recommend allocating all of the objects very early on in your program (potentially immediately after calling a GC.Collect(), which is something I really don’t normally recommend), and leaving them alone for the lifetime of your program. This would (slightly) mitigate the GC issues, as it’d allocate them into the “best” possible spot early on, and leave them where they’ll only be touched in Gen2 collections.