Develop Reference

Events in native library created by "Unmanaged Exports" in C#

I have written the following code that uses .net4 to run. Since I am using this code in Unity3D that doesn't support .net4 I had to convert it to native code. I am using "Unmanaged Exports" to export it to a native library.
I can call this function from Unity3D and it works fine.
Now I want to add events to my library and then access these events from another C# code in Unity3D.
My question is: How to create a callback event and register a function in my library to call when it is done? I know how to create an event in a Managed c# code. But note that here I am exporting it to native code and I need to use the event in the native code. So, My library does something as a native code and then I want it to fire a callback function to tell Unity3D that it is done.
Here is my library code:
[DllExport("SayText", CallingConvention = CallingConvention.Cdecl)]
public static void SayText()
{
var task = new Task(() =>
{
var synth = new SpeechSynthesizer();
synth.SetOutputToNull();
synth.SetOutputToWaveFile("D:\\test3.wav");
synth.SpeakCompleted += SynthOnSpeakCompleted;
synth.SpeakAsync("This is a test text");
});
task.Start();
}
private static void SynthOnSpeakCompleted(object sender, SpeakCompletedEventArgs speakCompletedEventArgs)
{
var synth = (SpeechSynthesizer)sender;
synth.SpeakCompleted -= SynthOnSpeakCompleted;
synth.SetOutputToDefaultAudioDevice();
// I want to trigger an event here so the application knows that the file has been created.
}
And here is how I'm calling this function from Unity3D:
[DllImport("mylib", EntryPoint = "SayText")]
public static extern void SayText();

I can't be sure it will solve your issue but I tried something similar with ios plugin.
Here is the C# side of the plugin:
public class CSharpWrapper
{
// Create delegate type
public delegate void TestDelegate();
// Connection with the native side
[DllImport("__Internal")]
private static extern void externMethod( TestDelegate onCompletion);
private static Action callback = null;
// This is most likely the part you are looking for.
// That method is marshalled so it will pass its address to the native side
// When native calls it we can add any code within
[MonoPInvokeCallback(typeof(TestDelegate))]
private static void ManagedTest()
{
if(callback != null) { callback(); }
callback = null;
}
#endif
public static void CallMethod(Action<string> onCompletion)
{
callback = onCompletion;
// Here we pass our own method that is marshalled for native side
externMethod(ManagedTest);
}
}
Then I have a C section in the .m file.
extern "C"
{
typedef void (*TestCallback)();
void externMethod(TestCallback testCallback)
{
// Here communication with Objective-C code
}
}
Maybe this will get you somewhere near completion. It is also possible to add parameters, just list them as usual and the marshalling attribute will do it all for you.

Passing a C# delegate to a C++/CLI wrapper

I was following this example to use a c# delegate as a c++ callback.
My wrapper looks like this:
// GLFWWrapper.h
#pragma once
using namespace System;
namespace GLFWWrapper {
typedef void(__stdcall *KEY_CALLBACK)(int, int, int, int);
public ref class Window {
public:
void setKeyCallback(KEY_CALLBACK fp);
static KEY_CALLBACK csharpKeyCallback;
...
};
}
// GLFWWrapper.cpp
#include "stdafx.h"
#include "GLFWWrapper.h"
namespace GLFWWrapper {
void cppKeyCallback(GLFWwindow * window, int key, int scancode, int action, int mods) {
if (Window::csharpKeyCallback) {
Window::csharpKeyCallback(key, scancode, action, mods);
}
}
void Window::setKeyCallback(KEY_CALLBACK fp) {
csharpKeyCallback = fp;
}
...
}
The cppKeyCallback function is a callback I set in another function (glfwSetKeyCallback(m_ptr, cppKeyCallback);). The csharpKeyCallback is supposed to be the delegate from my C# project. In the example I linked to above it is only explained how I can set a delegate from inside my wrapper. But how can I set the delegate from my C# project? When I try to call setKeyCallback from my C# project I get an error Window.setKeyCallback(?) is not supported by the language.

You seem to be missing the managed part of the instruction:
#pragma managed
public delegate void keyCallback(int, int, int, int);
void Window::setKeyCallback(keyCallback^ fp) {
csharpKeyCallback = fp;
}
In order to pass a reference to a function instance (delegate) from C# to C++\CLI you need to declare it i.e. declare a managed delegate. This can be done either in C# or in C++\CLI.
In your code the KEY_CALLBACK is an unmanaged function declaration. Thus it is "Not supported by the language". C# side cannot use it as a delegate declaration.
In order to avoid such a mess I myself always keep my C++\CLI projects clear of any managed declarations and provide those in an additional C# class library that is referenced from both the C++\CLI wrapper and the C# side.
Edit: Do not forget to put the ^ sign after the managed reference type in the managed method declaration or the compiler is going to bust you with an error 'A delegate type is not allowed here'.

subscribing to c# CompositeCommand from c++

In a c# assembly I've got a global prism CompositeCommand to subscribe to like this:
private static readonly CompositeCommand __myCommand = new CompositeCommand();
public static CompositeCommand MyCommand
{
get { return _myCommand; }
}
From c# I can subscribe to this command using:
[...].MyCommand.RegisterCommand(new DelegateCommand<MyClass>((c) => c.Something()));
My problem: I need to subscribe to the command from managed c++, and I got no idea how the function signature needs to be to be used in DelegateCommand. Most of the time I get errors like:
error C2664: 'Microsoft::Practices::Prism::Commands::DelegateCommand::DelegateCommand(System::Action ^)': conversion of parameter 1 from 'void (__clrcall *)(MyNameSpace::MyClass ^)' in 'System::Action ^' not possible.
How do I subscribe to a c# command? Or is there some other way to listen to an event (I can replace the CompositeCommand with something different).
Thanks!

I'm going to assume that you're using managed C++ - anything else, and there's bigger issues to worry about.
It looks like you're getting linking errors to your C# type. As such, I don't think the issue is related to any problems with Prism. In order for the C++ managed compiler to link to your C# assembly, you need to produce the C# assembly with an XML documentation file (see the Build tab in your properties). Is that enabled in your project?
I used the following as a very simple proof of concept, where TestObject is defined in the C# assembly referenced by the C++ DLL. This compiled without any issues.
Header file:
void __clrcall CommandCallback(Project::Infrastructure::TestObject^ param);
public ref class ManagedModule : IModule
{
public:
ManagedModule();
virtual void __clrcall Initialize();
private:
};
Implementation:
ManagedDLL::ManagedModule::ManagedModule()
{
}
void __clrcall ManagedDLL::ManagedModule::Initialize()
{
Action<Project::Infrastructure::TestObject^>^ newAction =
gcnew Action<Project::Infrastructure::TestObject^>(&CommandCallback);
DelegateCommand<Project::Infrastructure::TestObject^>^ newCommand =
gcnew DelegateCommand<Project::Infrastructure::TestObject^>(newAction);
Project::Infrastructure::Commands::ApplicationExitCommand->RegisterCommand(newCommand);
return;
}
void __clrcall CommandCallback(Project::Infrastructure::TestObject^ param)
{
return;
}

InvalidCastException implementing .net events in native c++ with managed wrapper

I am attempting to invoke managed events from native c++, by using a managed wrapper for a native class, and then using the managed wrapper via dll from C#. However, I receive a InvalidCastException runtime error that I don't know how to resolve, or even what it means. My implementation is as follows:
The header for ManagedClass is
#pragma once
#include "NativeClass.h"
using namespace System;
using namespace System::Runtime::InteropServices;
namespace NativeLibrary
{
public delegate void ReportProgressDelegate(Double ^completionPercentage);
public ref class ManagedClass
{
public:
ManagedClass();
event ReportProgressDelegate ^OnReportProgress;
void RaiseReportProgress(Double ^completionPercentage);
void CallTestFunction();
private:
NativeClass *_NativeClass;
ReportProgressDelegate ^ReportProgress;
};
}
while ManagedClass source file is
#include "stdafx.h"
#include "ManagedClass.h"
#include "TestFunction.h"
using namespace NativeLibrary;
ManagedClass::ManagedClass()
{
_NativeClass = new NativeClass();
ReportProgress = gcnew ReportProgressDelegate(this, &ManagedClass::RaiseReportProgress);
_NativeClass->ProgressFunction = (void (*)(double))Marshal::GetFunctionPointerForDelegate(ReportProgress).ToPointer();
void ManagedClass::RaiseReportProgress(System::Double ^completionPercentage)
{
OnReportProgress(completionPercentage);
}
void ManagedClass::CallTestFunction()
{
TestFunction(*_NativeClass);
}
}
Here NativeClass is defined in its own header file
#pragma once
class NativeClass
{
public:
NativeClass() {};
void (*ProgressFunction)(double);
};
as is TestFunction
#pragma once
#include "NativeClass.h"
void TestFunction(NativeClass& nativeClass)
{
nativeClass.ProgressFunction(50.0);
return;
}
I set up a C# program to test the event. My C# program consists of
NativeLibrary.ManagedClass managedClass = new NativeLibrary.ManagedClass();
managedClass.OnReportProgress += new NativeLibrary.ReportProgressDelegate(managedClass_OnReportProgress);
managedClass.CallTestFunction();
where the managedClass_OnReportProgress event is defined as
void managedClass_OnReportProgress(ValueType completionPercentage)
{
MessageBox.Show("report progress event triggered");
}
The problem occurs when I call the function CallTestFunction. When I step through using the debugger, it successfully makes it inside the native TestFunction. However, when it reaches the closing brace of TestFunction, I get the runtime error:
"InvalidCastException was unhandled. No such interface supported (Exception from HRESULT: 0x80004002 (E_NOINTERFACE))"
I'm really clueless as to how to resolve this problem, or what the source of it is. Suggestions?

public delegate void ReportProgressDelegate(Double ^completionPercentage);
Double is a value type. You should only use the ^ for reference types. I'm guessing it bombs when it tries to convert a boxed Double (an Object) to a native double. Delete the ^

Create unmanaged c++ object in c#

I have an unmanaged dll with a class "MyClass" in it.
Now is there a way to create an instance of this class in C# code? To call its constructor? I tried but the visual studio reports an error with a message that this memory area is corrupted or something.
Thanks in advance

C# cannot create class instance exported from native Dll. You have two options:
Create C++/CLI wrapper. This is .NET Class Library which can be added as Reference to any other .NET project. Internally, C++/CLI class works with unmanaged class, linking to native Dll by standard C++ rules. For .NET client, this C++/CLI class looks like .NET class.
Write C wrapper for C++ class, which can be used by .NET client with PInvoke. For example, over-simplified C++ class:
class MyClass()
{
public:
MyClass(int n){data=n;}
~MyClass(){}
int GetData(){return data;}
private:
int data;
};
C API wrapper for this class:
void* CreateInstance()
{
MyClass* p = new MyClass();
return p;
}
void ReleaseInstance(void* pInstance)
{
MyClass* p = (MyClass*)pInstance;
delete p;
}
int GetData(void* pInstance)
{
MyClass* p = (MyClass*)pInstance;
return p->GetData();
}
// Write wrapper function for every MyClass public method.
// First parameter of every wrapper function should be class instance.
CreateInstance, ReleaseInstance and GetData may be declared in C# client using PInvoke, and called directly. void* parameter should be declared as IntPtr in PInvoke declaration.

The solution is create C++/CLI wrapper like:
#include "DllExportClass.h"
public ref class ManagedOperationHelper
{
public:
double Sum(double add1, double add2)
{
CDllExportClass obj;
double ret=obj.Sum(add1, add2);
return ret;
}
double Mult(double mult1, double mult2)
{
CDllExportClass obj;
double ret=obj.Mult(mult1, mult2);
return ret;
}
};
where CDllExportClass is the class exported from native code. Above is the .h of the C++/CLI. Take care to let find the lib to this dll. Put the dll and the lib in the same directory and compile the C++/CLI code.In the managed code directory put the native dll and the C++/CLI dll. In the managed project put the reference of the C++/CLI project. Instanciate in the maged code the C++/CLI class like:
ManagedOperationHelper obj = new ManagedOperationHelper();
double ret=obj.Sum(10, 20);
It's all.

You can not use unmanged C++ code directly in C#. The interoperability can be done using PInvoke. There are a lot of issues related to this topic, especially when calling functions which have pointers as arguments.
The basic procedure goes like this:
C# part
namespace MyNamespace {
public class Test {
[DllImport("TheNameOfThe.dll")]
public static extern void CreateMyClassInstance();
public void CallIt() {
CreateMyClassInstance(); // calls the unmanged function via PInvoke
}
}
}
C++ part
class MyClass {
public: MyClass() { /** Constructor */ }
};
MyClass* staticObject;
extern "C" void CreateMyObjectInstance() {
staticObject = new MyClass(); // constructor is called
}