在C+；中的.Net委托中封装对本机对象的引用+/CLI

让我们假设有一个静态的.Net方法

static void RegisterDelegate(Action<array<Object^>^>^ handler);

静态无效寄存器delegate（操作^handler）；

在某些程序集中定义，我们无法修改

我有以下代码：

static void HandleCallback(Action<array<Object^>^>^ handler, NATIVE_CPP_TYPE *nativeObject){
    //some code here
}

static void TestCall(NATIVE_CPP_TYPE *nativeObject){
    //RegisterDelegate(??);
}

static void HandleCallback（操作^handler，NATIVE\u CPP\u TYPE*nativeObject）{
//这里有一些代码
}
静态void TestCall（本机\u CPP\u类型*nativeObject）{
//寄存器delegate（？？）；
}

其中，

NATIVE\u CPP\u TYPE

是一些不可序列化且仅限本机的类型，也不能修改

对

TestCall（ptrToObj）

的调用现在应该创建类型为

Action

的委托。调用时，此委托应调用

HandleCallback

，并传递它自己的参数（对象数组）和指向原始传递给

TestCall

函数的本机对象的指针。因此，指针需要存储在某种闭包中

你知道怎么做吗？我考虑过

System:：Linq:：Expressions

名称空间，但恐怕我无法在这种表达式中封装本机对象

---

提前谢谢

据我所知，在C++/CLI中，您无法执行托管lambdas。当然，您可以创建自己的类来存储本机类型，然后公开一个用作委托的方法：

public ref class ManagedClass
{
    static void RegisterDelegate(Action<array<Object^>^>^ handler)
    {

    }
};

class NATIVE_CPP_TYPE
{

};

static void HandleCallback(array<Object^>^ handler, NATIVE_CPP_TYPE *nativeObject)
{     
    //some code here 
}  

public ref class HandleCallbackWithNativeType
{
    NATIVE_CPP_TYPE * m_pNativeObject;

public:
    HandleCallbackWithNativeType(NATIVE_CPP_TYPE *nativeObject)
    {
        m_pNativeObject = nativeObject;
    }

    void Execute(array<Object^>^ array)
    {
        HandleCallback(array, m_pNativeObject);
    }
};


static void TestCall(NATIVE_CPP_TYPE *nativeObject)
{
    // This type will act as your closure "capturing" nativeObject.
    HandleCallbackWithNativeType ^ pHandler = gcnew HandleCallbackWithNativeType(nativeObject);
    Action<array<Object^>^>^ handler = gcnew Action<array<Object^>^>(pHandler, &HandleCallbackWithNativeType::Execute);
} 

public ref类ManagedClass
{
静态无效寄存器delegate（操作^handler）
{
}
};
类本机\u CPP\u类型
{
};
静态void HandleCallback（数组^handler，NATIVE\u CPP\u TYPE*nativeObject）
{     
//这里有一些代码
}  
public ref类HandleCallbackWithNativeType
{
本机_CPP_TYPE*m_pNativeObject；
公众：
HandleCallbackWithNativeType（NATIVE_CPP_TYPE*nativeObject）
{
m_pNativeObject=本地对象；
}
无效执行（数组^array）
{
HandleCallback（数组、m_pNativeObject）；
}
};
静态void TestCall（本机\u CPP\u类型*nativeObject）
{
//此类型将充当闭包“捕获”nativeObject。
HandleCallbackWithNativeType ^pHandler=gcnew HandleCallbackWithNativeType（nativeObject）；
Action^handler=gcnewaction（pHandler和HandleCallbackWithNativeType:：Execute）；
} 

它不像lambda语法那样方便，但它确实做到了这一点