C++/CLI如何将（托管）委托传递给非托管代码？

Question

我该如何从托管的C++ (C++/CLI)传递函数指针给非托管方法？我读过一些文章，比如MSDN上的这篇文章，但它描述的是两个不同的程序集，而我只想要一个。

这是我的代码：

1) 头文件(MyInterop.ManagedCppLib.h)：

#pragma once

using namespace System;

namespace MyInterop { namespace ManagedCppLib {

    public ref class MyManagedClass
    {
    public:
        void DoSomething();
    };
}}

2）CPP代码（MyInterop.ManagedCppLib.cpp）

#include "stdafx.h"
#include "MyInterop.ManagedCppLib.h"

#pragma unmanaged
void UnmanagedMethod(int a, int b, void (*sum)(const int))
{
    int result = a + b;
    sum(result);
}

#pragma managed
void MyInterop::ManagedCppLib::MyManagedClass::DoSomething()
{
    System::Console::WriteLine("hello from managed C++");
    UnmanagedMethod(3, 7, /* ANY IDEA??? */);
}

我尝试创建托管委托，然后尝试使用Marshal::GetFunctionPointerForDelegate方法，但是我无法编译。

- Ron Klein

---

您能否发布一下使用GetFunctionPointerForDelegate的代码？ - Simon

Answer 1

是的，你需要使用Marshal::GetFunctionPointerForDelegate()。你的代码片段缺少你想调用的托管函数，我只是举了一个例子。在获取函数指针之前，你还需要声明托管委托类型并创建其实例。以下方法效果很好：

#include "stdafx.h"

using namespace System;
using namespace System::Runtime::InteropServices;

#pragma managed(push, off)
typedef void (* UnmanagedSummer)(int arg);

void UnmanagedMethod(int a, int b, UnmanagedSummer sum)
{
    int result = a + b;
    sum(result);
}
#pragma managed(pop)

ref class Test {
    delegate void ManagedSummer(int arg);
public:
    static void Run() {
        Test^ t = gcnew Test();
        ManagedSummer^ managed = gcnew ManagedSummer(t, &Sum);
        IntPtr stubPointer = Marshal::GetFunctionPointerForDelegate(managed);
        UnmanagedSummer functionPointer = static_cast<UnmanagedSummer>(stubPointer.ToPointer());
        UnmanagedMethod(1, 2, functionPointer);
        GC::KeepAlive(managed);    // Important: ensure stub can't be collected while native code is running
        System::Diagnostics::Debug::Assert(t->summed == 3);
    }
    void Sum(int arg) {
        summed += arg;
    }
    int summed;
};

int main(array<System::String ^> ^args)
{
    Test::Run();
    return 0;
}

- Hans Passant

---

这个额外的转换是“缺失的链接” :-) 谢谢！ - Ron Klein

Answer 2

这是基于我在C++/CLI中实现CartoType C++地图渲染库包装器的经验，另一种方法来完成它。这是测试过并且可以正常工作的代码。

C++ API有一个异步查找函数，它带有回调函数：

TResult CartoType::CFramework::FindAsync(FindAsyncCallBack aCallBack,const TFindParam& aFindParam,bool aOverride = false);

回调函数的类型如下所示：

using FindAsyncCallBack = std::function<void(std::unique_ptr<CMapObjectArray> aMapObjectArray)>;

任务是通过向现有包装系统添加C++/CLI代码来提供.NET包装器。首先，我为我的.NET函数定义了一个合适的委托类型（相当于C++ API中的FindAsyncCallback）。

public delegate void FindAsyncDelegate(MapObjectList^ aMapObjectList);

“.NET 函数的签名如下：”

Result FindAsync(FindAsyncDelegate^ aDelegate,FindParam^ aFindParam,bool aOverride);

主要实现问题需要解决的是如何调用本地C++函数，并提供一个本地回调函数，该函数可以调用由.NET函数的调用者传递的委托。相关任务是保持委托和本地回调函数对象在异步函数的线程完成其工作之前保持活动状态。以下是实现方法。

我定义了一个与C++回调函数类型相同的C++/CLI委托类型，以及一个用于保存调用者传递给.NET函数的委托（FindAsyncDelegate类型）的类，和一个将传递给C++的委托类型（NativeAsyncHandler）。

delegate void NativeAsyncHandler(std::unique_ptr<CMapObjectArray> aMapObjectArray);

ref class FindAsyncHelper
    {
    public:
    FindAsyncHelper(Framework^ aFramework,FindAsyncDelegate^ aDelegate):
        m_framework(aFramework),
        m_delegate(aDelegate)
        {
        }

    void Handler(std::unique_ptr<CMapObjectArray> aMapObjectArray)
        {
        MapObjectList^ o = gcnew MapObjectList;
        SetMapObjectList(m_framework,o,*aMapObjectArray);
        m_delegate(o);

        // Remove this object from the list held by the framework so that it can be deleted.
        m_framework->m_find_async_helper_list->Remove(this);
        }

    Framework^ m_framework;
    FindAsyncDelegate^ m_delegate;
    NativeAsyncHandler^ m_native_handler;
    };

这个想法是我们创建一个带有两个委托的FindAsyncHelper对象，然后使用本地委托调用本地的FindAsync函数，安排调用Handler()，然后再调用原始调用者的委托。

以下是其实现方式：

typedef void(*FIND_ASYNC_CALLBACK)(std::unique_ptr<CMapObjectArray> aMapObjectArray);

Result Framework::FindAsync(FindAsyncDelegate^ aDelegate,FindParam^ aFindParam,bool aOverride)
    {
    if (aDelegate == nullptr || aFindParam == nullptr)
        return Result::ErrorInvalidArgument;
    TFindParam param;
    SetFindParam(param,aFindParam);

    FindAsyncHelper^ h = gcnew FindAsyncHelper(this,aDelegate);
    h->m_native_handler = gcnew NativeAsyncHandler(h,&FindAsyncHelper::Handler);

    IntPtr p = Marshal::GetFunctionPointerForDelegate(h->m_native_handler);
    FIND_ASYNC_CALLBACK f = static_cast<FIND_ASYNC_CALLBACK>(p.ToPointer());
    TResult error = m_framework->FindAsync(f,param,aOverride);

    // Keep h alive by adding it to a list.
    m_find_async_helper_list->Add(h);

    return (Result)(int)error;
    }

一些注释：

这些语句

FindAsyncHelper^ h = gcnew FindAsyncHelper(this,aDelegate);
h->m_native_handler = gcnew NativeAsyncHandler(h,&FindAsyncHelper::Handler);

创建一个FindAsyncHandler对象并在其中存储一个本地处理程序对象；将其保留在此处意味着我们只需要保持一个对象的活动状态，即FindAsyncHandler。下一条语句：

IntPtr p = Marshal::GetFunctionPointerForDelegate(h->m_native_handler);
FIND_ASYNC_CALLBACK f = static_cast<FIND_ASYNC_CALLBACK>(p.ToPointer());

获取一个函数指针，可以传递给本地代码，并将其转换为正确的函数指针类型。我们不能直接将其转换为FindAsyncCallback中使用的std :: function类型，因此需要繁琐的额外typedef。

最后可以调用本地的FindAsync函数：

TResult error = m_framework->FindAsync(f,param,aOverride);

接下来，为了确保各种回调函数能够继续运行，FindAsyncHandler被添加到由主框架对象拥有的列表中：

m_find_async_helper_list->Add(h);

当任务完成并调用FindAsyncHelper::Handler时，它将从列表中移除。

- Graham Asher