Mono C到正在运行的C＃程序

Question

I'm looking at communicating between a C++ program and a C# program using Mono. On the Mono website they have some good examples of embedding Mono in a C program, starting the C# program, and then communicating between the two.

mono_domain_assembly_open is used to open a C# assembly and mono_jit_exec is used to run it.

My question is, is it possible to "connect" to an already running assembly? The mono_jit_exec call would seem to me to be not needed since the C# assembly is already running. Instead would there be an alternate call to "link" the C and C# programs?

Thanks,

mj

Answer 1

I guess you mean a mono-specific way to exchange data/perform calls between the C side and the managed (C#) side in the same process (for different processes you will have to use a socket, like tcp/ip, and develop a protocol or use an existing one according to your needs).

First, to call a C function from within managed code you have two main mechanisms:

• a P/Invoke call (see http://www.mono-project.com/Interop_with_Native_Libraries for more details), using "__Internal" as the dll name to lookup the function in the executing program instead of an external library
• an InternalCall call: this is a managed method implemented as a C function, see samples/embed/teste.c in the mono sources for a simple example

The main difference between the two is that with P/Invoke data marshalling happens (for example a managed string becomes a char* string on the C side), while with icalls you get direct access to managed objects.

The main mechanism to go the other way (invoke a managed method from C) is to call mono_runtime_invoke (). samples/embed/test-invoke.c has a few examples.

Another way is to first marshal a delegate using P/Invoke: on the C side you will receive a function pointer which you can save (as long as you keep the managed delegate object alive, by storing it to a static field in a managed class, for example). Later you can call using the function pointer on the C side and you will be transfered to the managed world automatically.

If the assembly you are executing with mono_jit_exec() is long running, you will need to perform the mono_runtime_invoke() on a separate thread that you will have started before calling mono_jit_exec().

When embedding mono it is customary to have a very short Main() method used only for initialization, so mono_jit_exec() returns quickly and you can control everything from within the main thread in the C side.

If you start a separate thread, make sure you call mono_thread_attach() inside it before calling any other mono function or manipulating managed objects in it.

Answer 2

You would need to use some sort of IPC (inter process communication) as your C program has no control over the C# program. Possible ways would be named pipes, some sort of TCP/IP communication, Remoting (not sure of this applies on mono).