reading a double value from an Exchange array

[davecalkinshexagon]

In Brad's intro video for ExchangeSharp, he provided a nice example of accessing individual pointer array elements. For example, when enumerating a product occurrence's child product occurrences, we can do something like the below, using Marshal.ReadIntPtr. In this case, m_ppPOccurrences is a pointer to an array of pointers and we can access one of them using this code.

               for (var poIdx = 0; poIdx < productOccurrence.m_uiPOccurrencesSize; poIdx++)
                {
                    var childProductOccurrencePtr = Marshal.ReadIntPtr(productOccurrence.m_ppPOccurrences, poIdx * Marshal.SizeOf(typeof(IntPtr)));

                    if (!WalkProductOccurrence(childProductOccurrencePtr))
                        return false;
                }

Another case involves a pointer to an array of doubles. For example, A3DTessBaseData has m_pdCoords. This provides double values for markup tessellation. Marshal has methods for reading integral types in addition to pointers, but nothing for reading double values. I found and adapted some code for this and wanted to post it here in case its helpful to others.

        // given an unmanaged pointer to an array of doubles, return the double at the specified index
        // (based on https://gist.github.com/jordanzhang/2288117 added idx offset to support arrays)
        public static double GetDoubleFromPointerToArray(IntPtr mem1, int idx)
        {
            if (mem1 == IntPtr.Zero)
                return 0;

            byte[] ba = new byte[sizeof(double)];

            for (int i = (idx * Marshal.SizeOf(typeof(double))), j = 0; j < ba.Length; i++, j++)
                ba[j] = Marshal.ReadByte(mem1, i);

            double v = BitConverter.ToDouble(ba, 0);

            return v;
        }

I was hoping on making this a generic method to work with arbitrary primitive types, however, I couldn't figure out how to get BitConverter to support conversion to a generic type. If anyone has figured this out, I'd be curious to hear how they did it.

[davecalkinshexagon]

Although BitConverter didn't work for making a generic version of the above, the below approach works. This uses Marshal.Copy to copy the bytes representing any generic type into the memory for a pinned variable of the generic type. With this, given an unmanaged pointer to an array of values, you can get the ith value (double, uint, etc).

        public static T GetItemFromPointerToArray<T>(IntPtr mem1, int idx)
        {
            if (mem1 == IntPtr.Zero)
                return default(T);

            // copy the desired value from the source unmanaged array into a local array
            byte[] ba = new byte[Marshal.SizeOf<T>()];
            for (int i = (idx * Marshal.SizeOf<T>()), j = 0; j < ba.Length; i++, j++)
                ba[j] = Marshal.ReadByte(mem1, i);

            // prepare result value
            var result = new T[1];
            var resultHandle = GCHandle.Alloc(result, GCHandleType.Pinned);
            var resultPtr = resultHandle.AddrOfPinnedObject();

            // copy into the result value
            Marshal.Copy(ba, 0, resultPtr, Marshal.SizeOf<T>());

            // cleanup
            resultHandle.Free();

            return result[0];
        }