'値を整列化できません：無効な管理対象/非管理対象型の組み合わせです。'文字列配列のデリゲートを整列化しています。

Question

デリゲートを関数ポインタにマーシャリングしようとしています。デリゲートの戻り値の型は文字列の配列で、関数ポインタの戻り値の型はchar **

以下のコードは無効な管理対象/非管理型の組み合わせの例外をスローします。これをどうすれば解決できますか？

// unmanaged code 

typedef char** (*MyFuncPtr)(void); 

class __declspec(dllexport) MyUnmanagedClass{ 
private: 
    MyFuncPtr mFunPtr 
public: 

    MyUnmanagedClass(MyFuncPtr funPtr) 
    { 
     mFunPtr = funPtr; 
    } 

    char* Func1() 
    { 
     // callback 
     mFunPtr(); 

     return "something"; 
    } 
}; 

// managed wrapper (CLI) 

public delegate cli::array<String^>^ MyDelegate(); 

public class MyCliClass{ 
private: 
    MyDelegate mDel; 
public: 

    MyCliClass(MyDelegate del) 
    { 
     mDel = del; 
    } 

    String^ Func2() 
    { 
     MyFuncPtr funPtr = static_cast<MyFuncPtr>(Marshal::GetFunctionPointerForDelegate(mDel).ToPointer()); 

     MyUnmanagedClass* muc = new MyUnmanagedClass(funPtr); 
     char* retValPtr = muc->Func1(); 

     return context->marshal_as<String^>(retValPtr); 
    } 
}; 

// managed client (C#) 
class Program 
{ 
    static void Main(string[] args) 
    { 
     MyCliClass mcc = new MyCliClass(Func3); 
     mcc.Func2(); 
    } 

    static string[] Func3() 
    { 
     return new[] { "Some 1", "Some 2" }; 
    } 
} 

Answer 1

これは、関数は、CまたはC++のプログラムから確実に呼び出すことは不可能です...私は最終的にそれを解決する方法

// unmanaged code 
class __declspec(dllexport) NativeInterface 
{ 
public: 
    vector<string> NativeInterfaceFunc() = 0; 
}; 

class __declspec(dllexport) UnmanagedClass{ 
private: 
    NativeInterface* mNativeInterface 
public: 

    UnmanagedClass(NativeInterface* nativeInterface) 
    { 
     mNativeInterface = nativeInterface; 
    } 

    string UnmanagedClassFunc() 
    { 
     vector<string> values = mNativeInterface->NativeInterfaceFunc(); 

     ostringstream oss; 

     copy(values.begin(), values.end(), ostream_iterator<string>(oss, ",")); 

     return oss.str(); 
    } 
}; 

// managed wrapper (CLI) 
class NativeClass : NativeInterface 
{ 
public: 
    NativeInterface(ManagedInterface^ managedInterface) 
    { 
     mManagedInterface = managedInterface   
    }; 

    vector<string> NativeInterfaceFunc() 
    { 
     IEnumerable<String^> managedReturn = mManagedInterface->ManagedInterfaceFunc(); 

     vector<string> nativeReturn; 

     marshal_context^ context = new marshal_context(); 

     for each(String^ manRet in managedReturn) 
     { 
      nativeReturn.push_back(context->marshal_as<const char*>(manRet)) 
     } 

     delete context; 

     return nativeReturn; 
    }; 
private: 
    gcroot<ManagedInterface^> mManagedInterface; 
}; 

public ref class CliClass{ 
public: 

    CliClass(ManagedInterface^ managedInterface) 
    { 
     mNativeInterface = new NativeClass(managedInterface); 

     mUnmanagedClass = new UnmanagedClass(mNativeInterface); 
    } 

    ~CliClass() 
    { 
     delete mUnmanagedClass; 
     delete mNativeInterface; 
    } 

    String^ CliFunc() 
    { 
     string nativeReturn = mUnmanagedClass->UnmanagedClassFunc(); 

     return gcnew String(nativeReturn.c_str()); 
    } 
private: 
    UnmanagedClass mUnmanagedClass; 
    NativeInterface mNativeInterface; 
}; 

// managed interface (C#) 
interface ManagedInterface 
{ 
    IEnumerable<string> ManagedInterfaceFunc(); 
} 

// managed interface implementation(C#) 
public class ManagedClass : ManagedInterface 
{ 
    public IEnumerable<string> ManagedInterfaceFunc() 
    { 
     return new List<string> { "Some 1", "Some 2" }; 
    } 
} 

// managed client (C#) 
class Program 
{ 
    static void Main(string[] args) 
    { 
     MyCliClass mcc = new MyCliClass(new ManagedClass()); 

     Console.WriteLine(mcc.CliFunc()); 

     mcc.Dispose(); 
    } 
}