P/Invoke封送和解组C与非托管DLL之间的2D数组、结构和指针

Question

Flann C++ library有C、C++、Python、Matlab和{a6}的包装器，但没有可用的C包装器。我正在尝试创建一个C#包装器，它包含从here下载的flann.dll32位非托管DLL。在

作为PInvoke/marshalling的新手，我很确定我没有正确地对DLL执行C#p/Invoke调用。我基本上是尝试在C中镜像可用的Python wrapper。混淆的主要领域有：

• 我不知道如何在C中的2D托管矩形数组之间封送（输入）和解组（输出），其中参数类型是float*，即指向存储在row major order中的查询集的指针（根据flann.h中的注释）。在
• 我也不确定如何将结构引用传递给C是正确的，即struct FLANNParameters*
• IntPtr是否适合引用typedef void*和{}？在

非托管C(法兰.dll图书馆）

从我需要使用的flann.h导出的公共导出C++方法如下：

typedef void* FLANN_INDEX; /* deprecated */
typedef void* flann_index_t;

FLANN_EXPORT extern struct FLANNParameters DEFAULT_FLANN_PARAMETERS;

// dataset = pointer to a query set stored in row major order
FLANN_EXPORT flann_index_t flann_build_index(float* dataset,
                                             int rows,
                                             int cols,
                                             float* speedup,
                                             struct FLANNParameters* flann_params);

FLANN_EXPORT int flann_free_index(flann_index_t index_id,
                                  struct FLANNParameters* flann_params);

FLANN_EXPORT int flann_find_nearest_neighbors(float* dataset,
                                              int rows,
                                              int cols,
                                              float* testset,
                                              int trows,
                                              int* indices,
                                              float* dists,
                                              int nn,
                                              struct FLANNParameters* flann_params);

托管C包装器（我的实现）

下面是我基于上述公开公开的方法的C#包装器。在

在NativeMethods.cs公司

^{pr2}$

在法兰测试.cs

using System;
using System.IO;
using System.Runtime.InteropServices;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace FlannWrapper
{
    [TestClass]
    public class FlannTest : IDisposable
    {
        private IntPtr curIndex; 
        protected FlannParameters flannParams;
        // protected GCHandle gcHandle;

        [TestInitialize]
        public void TestInitialize()
        {
            this.curIndex = IntPtr.Zero;
            // Initialise Flann Parameters
            this.flannParams = new FlannParameters();  // use defaults
            this.flannParams.algorithm = FlannAlgorithmEnum.FLANN_INDEX_KDTREE;
            this.flannParams.trees = 8;
            this.flannParams.logLevel = FlannLogLevelEnum.FLANN_LOG_WARN;
            this.flannParams.checks = 64;
        }

        [TestMethod]
        public void FlannNativeMethodsTestSimple()
        {
            int rows = 3, cols = 5;
            int tCount = 2, nn = 3;

            float[,] dataset2D = { { 1.0f,      1.0f,       1.0f,       2.0f,       3.0f},
                                   { 10.0f,     10.0f,      10.0f,      3.0f,       2.0f},
                                   { 100.0f,    100.0f,     2.0f,       30.0f,      1.0f} };
            //IntPtr dtaasetPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(float)) * dataset2D.Length);

            float[,] testset2D = { { 1.0f,      1.0f,       1.0f,       1.0f,       1.0f},
                                   { 90.0f,     90.0f,      10.0f,      10.0f,      1.0f} };
            //IntPtr testsetPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(float)) * testset2D.Length);

            int outBufferSize = tCount * nn;
            int[] result = new int[outBufferSize];
            int[,] result2D = new int[tCount, nn];
            IntPtr resultPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(int)) * result.Length);

            float[] dists = new float[outBufferSize];
            float[,] dists2D = new float[tCount, nn];
            IntPtr distsPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(float)) * dists.Length);

            try
            {
                // Copy the array to unmanaged memory.
                //Marshal.Copy(testset, 0, testsetPtr, testset.Length);
                //Marshal.Copy(dataset, 0, datasetPtr, dataset.Length);

                if (this.curIndex != IntPtr.Zero)
                {
                    // n - number of bytes which is enough to keep any type used by function
                    NativeMethods.flannFreeIndex(this.curIndex, ref this.flannParams);
                    this.curIndex = IntPtr.Zero;
                }

                //GC.KeepAlive(this.curIndex);    // TODO

                float speedup = 0.0f;  // TODO: ctype float

                Console.WriteLine("Computing index.");
                this.curIndex = NativeMethods.flannBuildIndex(dataset2D, rows, cols, ref speedup, ref this.flannParams);
                NativeMethods.flannFindNearestNeighborsIndex(this.curIndex, testset2D, tCount, resultPtr, distsPtr, nn, ref this.flannParams);

                // Copy unmanaged memory to managed arrays.
                Marshal.Copy(resultPtr, result, 0, result.Length);
                Marshal.Copy(distsPtr, dists, 0, dists.Length);

                // Clutching straws, convert 1D to 2D??
                for(int row=0; row<tCount; row++)
                {
                    for(int col=0; col<nn; col++)
                    {
                        int buffIndex = row*nn + col;
                        result2D[row, col] = result[buffIndex];
                        dists2D[row, col] = dists[buffIndex];
                    }
                }
            }
            finally
            {
                // Free unmanaged memory -- [BREAKPOINT HERE]
                // Free input pointers
                //Marshal.FreeHGlobal(testsetPtr);
                //Marshal.FreeHGlobal(datasetPtr);
                // Free output pointers
                Marshal.FreeHGlobal(resultPtr);
                Marshal.FreeHGlobal(distsPtr);
            }
        }

        [TestCleanup]
        public void TestCleanup()
        {
            if (this.curIndex != IntPtr.Zero)
            {
                NativeMethods.flannFreeIndex(this.curIndex, ref flannParams);
                Marshal.FreeHGlobal(this.curIndex);
                this.curIndex = IntPtr.Zero;
                // gcHandle.Free();
            }
        }
    }
}

在FlannParams.cs

正在尝试镜像Python FLANNParameters class和C struct FLANNParameters。在

using System;
using System.Runtime.InteropServices;

namespace FlannWrapper
{
    // FieldOffsets set based on assumption that C++ equivalent of int, uint, float, enum are all 4 bytes for 32-bit
    [StructLayout(LayoutKind.Explicit)]
    public class FLANNParameters
    {
        [FieldOffset(0)]
        public FlannAlgorithmEnum algorithm;
        [FieldOffset(4)]
        public int checks;
        [FieldOffset(8)]
        public float eps;
        [FieldOffset(12)]
        public int sorted;
        [FieldOffset(16)]
        public int maxNeighbors;
        [FieldOffset(20)]
        public int cores;
        [FieldOffset(24)]
        public int trees;
        [FieldOffset(28)]
        public int leafMaxSize;
        [FieldOffset(32)]
        public int branching;
        [FieldOffset(36)]
        public int iterations;
        [FieldOffset(40)]
        public FlannCentersInitEnum centersInit;
        [FieldOffset(44)]
        public float cbIndex;
        [FieldOffset(48)]
        public float targetPrecision;
        [FieldOffset(52)]
        public float buildWeight;
        [FieldOffset(56)]
        public float memoryWeight;
        [FieldOffset(60)]
        public float sampleFraction;
        [FieldOffset(64)]
        public int tableNumber;
        [FieldOffset(68)]
        public int keySize;
        [FieldOffset(72)]
        public int multiProbeLevel;
        [FieldOffset(76)]
        public FlannLogLevelEnum logLevel;
        [FieldOffset(80)]
        public long randomSeed;

        /// <summary>
        /// Default Constructor
        /// Ref https://github.com/mariusmuja/flann/blob/master/src/python/pyflann/flann_ctypes.py : _defaults
        /// </summary>
        public FlannParameters()
        {
            this.algorithm = FlannAlgorithmEnum.FLANN_INDEX_KDTREE;
            this.checks = 32;
            this.eps = 0.0f;
            this.sorted = 1;
            this.maxNeighbors = -1;
            this.cores = 0;
            this.trees = 1;
            this.leafMaxSize = 4;
            this.branching = 32;
            this.iterations = 5;
            this.centersInit = FlannCentersInitEnum.FLANN_CENTERS_RANDOM;
            this.cbIndex = 0.5f;
            this.targetPrecision = 0.9f;
            this.buildWeight = 0.01f;
            this.memoryWeight = 0.0f;
            this.sampleFraction = 0.1f;
            this.tableNumber = 12;
            this.keySize = 20;
            this.multiProbeLevel = 2;
            this.logLevel = FlannLogLevelEnum.FLANN_LOG_WARN;
            this.randomSeed = -1;
        }
    }
    public enum FlannAlgorithmEnum  : int   
    {
        FLANN_INDEX_KDTREE = 1
    }
    public enum FlannCentersInitEnum : int
    {
        FLANN_CENTERS_RANDOM = 0
    }
    public enum FlannLogLevelEnum : int
    {
        FLANN_LOG_WARN = 3
    }
}

输出错误-调试模式，立即窗口

?result2D
{int[2, 3]}
    [0, 0]: 7078010
    [0, 1]: 137560165
    [0, 2]: 3014708
    [1, 0]: 3014704
    [1, 1]: 3014704
    [1, 2]: 48
?dists2D
{float[2, 3]}
    [0, 0]: 2.606415E-43
    [0, 1]: 6.06669328E-34
    [0, 2]: 9.275506E-39
    [1, 0]: 1.05612418E-38
    [1, 1]: 1.01938872E-38
    [1, 2]: 1.541428E-43

如您所见，在调试模式下运行测试时，我没有收到任何错误，但我知道输出肯定是不正确的-垃圾值是不正确的内存寻址的结果。我还包括替代封送签名，我尝试没有任何成功（请看评论与。在

地面真相Python（调用pyflan库）

为了找到正确的结果，我使用可用的Python库pyflan实现了一个快速测试。在

在法兰测试.py

import pyflann
import numpy as np

dataset = np.array(
    [[1., 1., 1., 2., 3.],
     [10., 10., 10., 3., 2.],
     [100., 100., 2., 30., 1.] ])
testset = np.array(
    [[1., 1., 1., 1., 1.],
     [90., 90., 10., 10., 1.] ])
flann = pyflann.FLANN()
result, dists = flann.nn(dataset, testset, num_neighbors = 3, 
                         algorithm="kdtree", trees=8, checks=64)  # flann parameters

# Output
print("\nResult:")
print(result)
print("\nDists:")
print(dists)

在引擎盖下，宾夕法尼亚州皮夫兰（）调用公开公开的C方法，从index.py可以看出。在

正确输出

Result:
[[0 1 2]
 [2 1 0]]

Dists:
[[  5.00000000e+00   2.48000000e+02   2.04440000e+04]
 [  6.64000000e+02   1.28500000e+04   1.59910000e+04]]

如果您能以正确的方式帮助您，我们将不胜感激。谢谢。在

Answer 1

当你使用p/invoke时，你必须停止思考“托管”，而应该考虑物理二进制布局，32位vs 64位等等。而且，当被调用的本机二进制总是在进程内运行时（如这里，但是对于COM服务器，它可以是不同的）它比进程外容易，因为你不必考虑太多封送/序列化、ref vs out等等

而且，你不需要告诉.NET它已经知道的东西。float数组是R4的LPArray，不必指定它。越简单越好。在

所以，首先flann_index_t。它在C中被定义为void *，因此它必须是一个IntPtr（一个“something”上的不透明指针）。在

然后是结构。如果将结构定义为struct，那么在C中作为简单指针传递的结构可以作为ref参数传递。如果将其定义为class，请不要使用ref。一般来说，我更喜欢对C结构使用struct。在

你必须确保结构定义良好。一般来说，使用LayoutKind.Sequential，因为.NET p/invoke将以与C编译器相同的方式打包参数。因此，您不必使用explicit，尤其是当参数是标准的（而不是位的）时，比如int、float，所以您可以删除所有FieldOffset并使用布局Kind.顺序如果所有成员都被正确声明。。。但事实并非如此。在

对于类型，就像我说的，你真的要考虑二进制，并且问自己你所使用的每种类型，它的二进制布局是什么，大小是多少？int是（使用99.9%的C编译器）32位的。float和double是IEEE的标准，所以它们不应该有任何问题。枚举通常基于int，但这可能有所不同（在C和.NET中，为了能够匹配C）。long是（99.0%的C编译器）32位，不是64位。因此.NET等价物是Int32（int），而不是Int64（long）。在

因此，您应该更正您的FlannParameters结构，并将long替换为int。如果您真的想确定给定的结构，请使用与编译所调用的库相同的C编译器检查Marshal.SizeOf(mystruct)与C的sizeof(mystruct)。它们应该是一样的。如果没有包装尺寸的话，就按净尺寸等。在

下面是一些经过修改的定义和调用代码，它们似乎可以正常工作。在

static void Main(string[] args)
{
    int rows = 3, cols = 5;
    int tCount = 2, nn = 3;

    float[,] dataset2D = { { 1.0f,      1.0f,       1.0f,       2.0f,       3.0f},
                           { 10.0f,     10.0f,      10.0f,      3.0f,       2.0f},
                           { 100.0f,    100.0f,     2.0f,       30.0f,      1.0f} };

    float[,] testset2D = { { 1.0f,      1.0f,       1.0f,       1.0f,       1.0f},
                           { 90.0f,     90.0f,      10.0f,      10.0f,      1.0f} };

    var fparams = new FlannParameters();
    var index = NativeMethods.flannBuildIndex(dataset2D, rows, cols, out float speedup, ref fparams);

    var indices = new int[tCount, nn];
    var idists = new float[tCount, nn];
    NativeMethods.flannFindNearestNeighborsIndex(index, testset2D, tCount, indices, idists, nn, ref fparams);
    NativeMethods.flannFreeIndex(index, ref fparams);
}

[DllImport(DllWin32, EntryPoint = "flann_build_index", CallingConvention = CallingConvention.Cdecl)]
public static extern IntPtr flannBuildIndex(float[,] dataset,
                                            int rows, int cols,
                                            out float speedup, // out because, it's and output parameter, but ref is not a problem
                                            ref FlannParameters flannParams);

[DllImport(DllWin32, EntryPoint = "flann_free_index", CallingConvention = CallingConvention.Cdecl)]
public static extern int flannFreeIndex(IntPtr indexPtr,  ref FlannParameters flannParams);

[DllImport(DllWin32, EntryPoint = "flann_find_nearest_neighbors_index", CallingConvention = CallingConvention.Cdecl, SetLastError = true)]
public static extern int flannFindNearestNeighborsIndex(IntPtr indexPtr,
                                                        float[,] testset,
                                                        int tCount,
                                                        [In, Out] int[,] result, // out because it may be changed by C side
                                                        [In, Out] float[,] dists,// out because it may be changed by C side
                                                        int nn,
                                                        ref FlannParameters flannParams);

[StructLayout(LayoutKind.Sequential)]
public struct FlannParameters
{
    public FlannAlgorithmEnum algorithm;
    public int checks;
    public float eps;
    public int sorted;
    public int maxNeighbors;
    public int cores;
    public int trees;
    public int leafMaxSize;
    public int branching;
    public int iterations;
    public FlannCentersInitEnum centersInit;
    public float cbIndex;
    public float targetPrecision;
    public float buildWeight;
    public float memoryWeight;
    public float sampleFraction;
    public int tableNumber;
    public int keySize;
    public int multiProbeLevel;
    public FlannLogLevelEnum logLevel;
    public int randomSeed;
}

注意：我尝试过使用特定的flann参数值，但是在这种情况下库崩溃了，我不知道为什么。。。在