推荐订阅源

C#在调用动态库接口，有时需要在C#中分配非托管内存，以便动态库可以写入返回的数据；有时我们需要传递一个复杂的数组等等。在C++的方法原型中，是一个*即指针，在C#的方法原型，相对应的可以是IntPtr，有些也可以直接使用[Out,In]等属性。

     对于基础数组的数组，可以使用

            Byte[] photoData = new Byte[CompressPhotoSize];
            GCHandle gh = GCHandle.Alloc(photoData, GCHandleType.Pinned);
            IntPtr AddrOfPhotoData = gh.AddrOfPinnedObject();

来获取到数组的开始指针。但对于具有非基元（非直接复制到本机结构中的）成员的实例不能被固定。即属性中有如字符串等属性的结构体，就不能被固化，会报ArgumentException异常。这时我们就要手动分配内存了。

           基本的成员方法有如下一些

    /// <summary>
    /// 非托管代码辅助工具。
    /// </summary>
    public class MarshalHelper
    {
        /// <summary>
        /// 把托管数组复制到内存块中。
        /// </summary>
        /// <typeparam name="T">结构的类型</typeparam>
        /// <param name="InputArray">要复制的数组</param>
        /// <returns></returns>
        public static IntPtr IntPtrFromStuctArray<T>(T[] InputArray) where T : new()
        {
            int size = InputArray.Length;
            T[] resArray = new T[size];
            //IntPtr[] InPointers = new IntPtr[size];
            int dim = IntPtr.Size * size;
            IntPtr rRoot = Marshal.AllocCoTaskMem(Marshal.SizeOf(InputArray[0]) * size);
            for (int i = 0; i < size; i++)
            {
                Marshal.StructureToPtr(InputArray[i], (IntPtr)(rRoot.ToInt32() +
                        i * Marshal.SizeOf(InputArray[i])), false);
            }
            return rRoot;
        }
        /// <summary>
        /// 从非托管的内存数据转换成托管数据。
        /// </summary>
        /// <typeparam name="T">结构的类型</typeparam>
        /// <param name="outArray">数据指针</param>
        /// <param name="size">数组的长度</param>
        /// <returns></returns>
        public static T[] StuctArrayFromIntPtr<T>(IntPtr outArray, int size) where T : new()
        {
            T[] resArray = new T[size];
            IntPtr current = outArray;
            for (int i = 0; i < size; i++)
            {
                resArray[i] = new T();
                Marshal.PtrToStructure(current, resArray[i]);
                Marshal.DestroyStructure(current, typeof(T));
                int structsize = Marshal.SizeOf(resArray[i]);
                current = (IntPtr)((long)current + structsize);
            }
            Marshal.FreeCoTaskMem(outArray);
            return resArray;
        }

        /// <summary>
        /// 将数据从托管对象封送到非托管内存块。使用完得释放指针。
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="structure"></param>
        /// <returns></returns>
        public static IntPtr StructureToPtr<T>(T structure) where T : new()
        {
            IntPtr buffer = Marshal.AllocHGlobal(Marshal.SizeOf(structure));

            Marshal.StructureToPtr(structure, buffer, false);
            return buffer;
        }

        /// <summary>
        /// 从指针中获取一个结构。
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="ptr"></param>
        /// <returns></returns>
        public static T PtrToStructure<T>(IntPtr ptr) where T : new()
        {
            T a = (T)Marshal.PtrToStructure(ptr, typeof(T));
            Marshal.FreeHGlobal(ptr);
            return a;
        }

        public static void FreeHGlobal(ref IntPtr ptr)
        {
            Marshal.FreeHGlobal(ptr);
        }

        /// <summary>
        /// 把一个结构转为一个Byte数组。
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="structure"></param>
        /// <returns></returns>
        public static Byte[] StructToBytes<T>(T structure) where T : new()
        {
            Int32 size = Marshal.SizeOf(structure);
            IntPtr buffer = Marshal.AllocHGlobal(size);

            try
            {
                Marshal.StructureToPtr(structure, buffer, false);
                Byte[] bytes = new Byte[size];
                Marshal.Copy(buffer, bytes, 0, size);

                return bytes;
            }
            finally
            {
                Marshal.FreeHGlobal(buffer);
            }

        }

        //2、Byte[]转换为struct
        /// <summary>
        /// 把数组转为结构。
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public static T BytesToStruct<T>(Byte[] bytes) where T : new()
        {
            Int32 size = Marshal.SizeOf(typeof(T));
            IntPtr buffer = Marshal.AllocHGlobal(size);

            try
            {
                Marshal.Copy(bytes, 0, buffer, size);
                return (T)Marshal.PtrToStructure(buffer, typeof(T));
            }
            finally
            {
                Marshal.FreeHGlobal(buffer);
            }
        }

    }

通过上方法获取到指针，传到动态库就行了，记得，操作完成后得显式删除该指针所分配的内存，以免产生泄露。