The Mono runtime engine has many language interoperability features but has never had a strong story to interop with C++.
Thanks to the work of Alex Corrado, Andreia Gaita and Zoltan Varga, this is about to change.
The short story is that the new CXXI technology allows C#/.NET developers to:
Easily consume existing C++ classes from C# or any other .NET language
Instantiate C++ objects from C#
Invoke C++ methods in C++ classes from C# code
Invoke C++ inline methods from C# code (provided your library is compiled with -fkeep-inline-functions or that you provide a surrogate library)
Subclass C++ classes from C#
Override C++ methods with C# methods
Expose instances of C++ classes or mixed C++/C# classes to both C# code and C++ as if they were native code.
CXXI is the result of two summers of work from Google's Summer of Code towards improving the interoperability of Mono with the C++ language.
The Alternatives
This section is merely a refresher of of the underlying technologies for interoperability supported by Mono and how developers coped with C++ and C# interoperability in the past. You can skip it if you want to get to how to get started with CXXI.
As a reminder, Mono provides a number of interoperability bridges, mostly inherited from the ECMA standard. These bridges include:
The bi-directional "Platform Invoke" technology (P/Invoke) which allows managed code (C#) to call methods in native libraries as well as support for native libraries to call back into managed code.
COM Interop which allows Mono code to transparently call C or C++ code defined in native libraries as long as the code in the native libraries follows a few COM conventions [1].
A general interceptor technology that can be used to intercept method invocations on objects.
When it came to getting C# to consume C++ objects the choices were far from great. For example, consider a sample C++ class that you wanted to consume from C#:
class MessageLogger {
public:
MessageLogger (const char *domain);
void LogMessage (const char *msg);
}
One option to expose the above to C# would be to wrap the Demo class in a COM object. This might work for some high-level objects, but it is a fairly repetitive exercise and also one that is devoid of any fun. You can see how this looks like in the COM Interop page.
The other option was to produce a C file that was C callable, and invoke those C methods. For the above constructor and method you would end up with something like this in C:
/* bridge.cpp, compile into bridge.so */
MessageLogger *Construct_MessageLogger (const char *msg)
{
return new MessageLogger (msg);
}
void LogMessage (MessageLogger *logger, const char *msg)
{
logger->LogMessage (msg);
}
Read more:
Personal blog of Miguel de IcazaQR:
Posted via email from Jasper-net
Posts
