P/Invoke以指针形式传递结构体内的数组

在使用P/Invoke（平台调用）从.NET（例如C#）调用C++本机函数时，可以选择将数组以指针的形式传递。但如果数组是结构体中的成员时，就只能通过SafeArray或者按值传递数组的方式传递了，无法用指针的形式传递。那么问题来了，如果要在P/Invoke中使用一个带有动态数组成员的结构体，又不想用SafeArray，该如何实现呢？

为了解决这个问题，可以设计专用于传递动态数组的结构。这个结构需要满足以下要求：

能作为其他对象的成员在.NET和本机函数之间传递
能从.NET的IEnumerable接口转换，或者转换到C#数组
正确实现.NET的IDisposable模式，使得：
- 内存空间能够通过Dispose函数被显式释放
- 在忘记调用Dispose的情况下由终结器释放内存
- 不会尝试在.NET端释放在本机端创建的对象
与C++标准库中的其他集合有相似的接口
正确实现C++的析构函数，使得：
- 析构函数调用时，通过C++端分配的内存空间能够正确释放，数组成员的析构函数能正确调用

一个能通过P/Invoke传递的基本数组结构C#代码如下所示：

[StructLayout(LayoutKind.Sequential)]
public class UnmanagedArray
{
    private readonly IntPtr data;
    private readonly int length;
}

要实现与.NET IEnumerable<T>接口之间的互相转换，可以通过下面给出的FromIEnumerable和Cast成员函数实现。为了防止原始IEnumerable<T>中的元素被垃圾回收导致意外情况（例如将IEnumerable<UnmanagedArray>转换为UnmanagedArray时，垃圾回收和终结器会将原始数据中分配的本机内存释放），在一个静态字典中存储该原始IEnumerable<T>。

/// <summary>
/// 用于保留转换为UnmanagedArray的原始对象，以防止其值被垃圾回收。
/// </summary>
private static Dictionary<IntPtr, object> originalVals = new Dictionary<IntPtr, object>();

/// <summary>
/// 该构造函数只用于将非托管对象转换为托管对象时由Marshal函数调用。
/// 使用该构造函数的实例不会自动释放内存空间。
/// </summary>
private UnmanagedArray()
{
    data = IntPtr.Zero;
    length = 0;
}

/// <summary>
/// 以预先分配的地址空间初始化<see cref="UnmanagedArray"/>类
/// </summary>
/// <param name="data">数组的第一个元素的指针</param>
/// <param name="length">数组的长度</param>
private UnmanagedArray(IntPtr data, int length)
{
    this.data = data;
    this.length = length;
}

public static UnmanagedArray FromIEnumerable<T>(IEnumerable<T> originalData)
{
    int size;
    if (typeof(T) == typeof(string))
    {
        size = Marshal.SizeOf<IntPtr>();
    }
    else
    {
        size = Marshal.SizeOf<T>();
    }

    int length = originalData.Count();

    var data = Marshal.AllocHGlobal(size * length);
    int i = 0;
    if (typeof(T) == typeof(string))
    {
        foreach (T item in originalData)
        {
            Marshal.WriteIntPtr(data + (size * i), Marshal.StringToHGlobalUni((string)(object)item));
            ++i;
        }
    }
    else
    {
        foreach (var item in originalData)
        {
            Marshal.StructureToPtr(item, data + (size * i), false);
            ++i;
        }
    }

    originalVals[data] = originalData;

    return new UnmanagedArray(data, length, typeof(T));
}

public IEnumerable<T> Cast<T>()
{
    for (int i = 0; i < length; ++i)
    {
        yield return Marshal.PtrToStructure<T>(data + (i * Marshal.SizeOf<T>()));
    }
}

要实现.NET的IDisposable模式，首先令UnmanagedArray类实现IDisposable接口，并增加Dispose函数和终结器。由于P/Invoke功能不支持泛型，在此通过一个静态的类型字典来存储每个实例的类型。同时，构造函数需要进行修改以防止终结器尝试释放C++分配的内存。完整的C#中的UnmanagedArray类如下所示：

[StructLayout(LayoutKind.Sequential)]
public class UnmanagedArray : IDisposable
{
    private static Dictionary<IntPtr, Type> typeMap = new Dictionary<IntPtr, Type>();

    /// <summary>
    /// 用于保留转换为UnmanagedArray的原始对象，以防止其值被垃圾回收。
    /// </summary>
    private static Dictionary<IntPtr, object> originalVals = new Dictionary<IntPtr, object>();

    private readonly IntPtr data;
    private readonly int length;

    /// <summary>
    /// 该构造函数只用于将非托管对象转换为托管对象时由Marshal函数调用。
    /// 使用该构造函数的实例不会自动释放内存空间。
    /// </summary>
    private UnmanagedArray()
    {
        data = IntPtr.Zero;
        length = 0;
        GC.SuppressFinalize(this);
    }

    /// <summary>
    /// 以预先分配的地址空间初始化<see cref="UnmanagedArray"/>类
    /// </summary>
    /// <param name="data">数组的第一个元素的指针</param>
    /// <param name="length">数组的长度</param>
    /// <param name="type">数组元素的类型</param>
    private UnmanagedArray(IntPtr data, int length, Type type)
    {
        this.data = data;
        this.length = length;
        typeMap[data] = type;
    }

    ~UnmanagedArray()
    {
        Dispose(false);
    }

    public static UnmanagedArray FromIEnumerable<T>(IEnumerable<T> originalData)
    {
        int size;
        if (typeof(T) == typeof(string))
        {
            size = Marshal.SizeOf<IntPtr>();
        }
        else
        {
            size = Marshal.SizeOf<T>();
        }

        int length = originalData.Count();

        var data = Marshal.AllocHGlobal(size * length);
        int i = 0;
        if (typeof(T) == typeof(string))
        {
            foreach (T item in originalData)
            {
                Marshal.WriteIntPtr(data + (size * i), Marshal.StringToHGlobalUni((string)(object)item));
                ++i;
            }
        }
        else
        {
            foreach (var item in originalData)
            {
                Marshal.StructureToPtr(item, data + (size * i), false);
                ++i;
            }
        }

        originalVals[data] = originalData;

        return new UnmanagedArray(data, length, typeof(T));
    }

    public IEnumerable<T> Cast<T>()
    {
        for (int i = 0; i < length; ++i)
        {
            yield return Marshal.PtrToStructure<T>(data + (i * Marshal.SizeOf<T>()));
        }
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (typeMap.ContainsKey(data))
        {
            var type = typeMap[data];
            typeMap.Remove(data);

            originalVals.Remove(data);

            if (type == typeof(string))
            {
                int size = Marshal.SizeOf<IntPtr>();
                for (int i = 0; i < length; ++i)
                {
                    Marshal.ZeroFreeGlobalAllocUnicode(
                        Marshal.ReadIntPtr(data + (size * i)));
                }
            }
            else
            {
                int size = Marshal.SizeOf(type);
                for (int i = 0; i < length; ++i)
                {
                    Marshal.DestroyStructure(data + (size * i), type);
                }
            }

            Marshal.FreeHGlobal(data);
        }
    }
}

在C++中对应的类代码如下。由于在使用P/Invoke时，.NET端的类对象会以指针的形式传递到C++代码中，所以C++侧的析构函数不会被调用，因此不必对析构函数做特殊处理。

template<typename T>
class Array
{
private:
	T *m_data;
	int m_length;

public:
	Array()
		: m_data(nullptr), m_length(0)
	{}

	Array(int _length)
		: m_data(new T[_length]), m_length(_length)
	{}

	~Array()
	{
		delete[] m_data;
	}
}

添加了复制构造函数、赋值操作符重载、迭代器接口和索引接口的C++类如下所示：

template<typename T>
class Array
{
private:
	T *m_data;
	int m_length;

public:
	Array()
		: m_data(nullptr), m_length(0)
	{}

	Array(int _length)
		: m_data(new T[_length]), m_length(_length)
	{}

	~Array()
	{
		delete[] m_data;
	}

	Array(const Array<T> &array)
		: m_data(new T[array.m_length]), m_length(array.m_length)
	{
		for (int i = 0; i < m_length; ++i)
		{
			m_data[i] = array.m_data[i];
		}
	}

	Array<T> &operator=(const Array<T> &array)
	{
		if (this != &array)
		{
			delete[] m_data;
			m_data = new T[array.m_length];
			m_length = array.m_length;

			for (int i = 0; i < m_length; ++i)
			{
				m_data[i] = array.m_data[i];
			}
		}

		return *this;
	}

	Array<T> &operator=(Array<T> &&array)
	{
		if (this != &array)
		{
			delete[] m_data;

			m_data = array.m_data;
			m_length = array.m_length;

			array.m_data = nullptr;
			array.m_length = 0;
		}

		return *this;
	}

	const T &operator[](size_t index) const
	{
		return m_data[index];
	}

	T &operator[](size_t index)
	{
		return m_data[index];
	}

	T *data()
	{
		return m_data;
	}

	T *begin()
	{
		return m_data;
	}

	T *end()
	{
		return m_data + m_length;
	}

	const T *begin() const
	{
		return m_data;
	}

	const T *end() const
	{
		return m_data + m_length;
	}

	int length() const
	{
		return m_length
	}
};

一个C++函数和对应的P/Invoke声明示例如下所示。由于.NET端不能正确释放C++端分配的内存，所以需要通过P/Invoke调用C++函数来释放空间。

class InputParam {
public:
    Array<int> ints;
    Array<int> doubles;
};

class OutputParam {
public:
    Array<int> ints;
    Array<double> doubles;
};

extern "C" __declspec(dllexport) void Foo(const InputParam &inputParam, const OutputParam *&outputParam);

extern "C" __declspec(dllexport) void FreeOutput(const OutputParam *paramToFree);

[StructLayout(LayoutKind.Sequential)]
public class InputParam {
    UnmanagedArray ints;
    UnmanagedArray doubles;
}

[StructLayout(LayoutKind.Sequential)]
public class OutputParam {
    UnmanagedArray ints;
    UnmanagedArray doubles;
}

public static extern void Foo(
    InputParam inputParam,
    [Out] out IntPtr outputParam);

public static extern void FreeOutput(
    IntPtr outputParam);

public void ExampleCall()
{
    InputParam a = ...;
    Foo(a, out IntPtr bPtr);
    var b = Marshal.PtrToStructure<OutputParam>(bPtr);
    FreeOutput(bPtr);
}