Dot Net Example (ActiveQt)

Walkthrough: .NET interop with MC++ and IJW

Normal C++ classes and functions can be used from managed .NET code by providing thin wrapper classes written in MC++. The wrapper class will take care of forwarding the calls to the normal C++ functions or methods, and converting parameter data as necessary. Since the wrapper class is a managed class, it can be used without further ado in any managed .NET application, whether written in C#, VB.NET, MC++ or other managed programming language.

 class Worker : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QString statusString READ statusString WRITE setStatusString)
 public:
     Worker();

     QString statusString() const;

 public slots:
     void setStatusString(const QString &string);

 signals:
     void statusStringChanged(const QString &string);

 private:
     QString status;
 };

The Qt class has nothing unusual for Qt users, and as even the Qt specialities like Q_PROPERTY, slots and signals are implemented with straight C++ they don't cause any trouble when compiling this class with any C++ compiler.

 class Worker;

 // .NET class
 public __gc class netWorker
 {
 public:
     netWorker();
     ~netWorker();

     __property String *get_StatusString();
     __property void set_StatusString(String *string);

     __event void statusStringChanged(String *args);

 private:
     Worker *workerObject;
 };

The .NET wrapper class uses keywords that are part of MC++ to indicate that the class is managed/garbage collected (__gc), and that StatusString should be accessible as a property in languages that support this concept (__property). We also declare an event function statusStringChanged(String*) (__event), the equivalent of the respective signal in the Qt class.

Before we can start implementing the wrapper class we need a way to convert Qt's datatypes (and potentionally your own) into .NET datatypes, e.g. QString objects need to be converted into objects of type String*.

When operating on managed objects in normal C++ code, a little extra care must be taken because of the CLR's garbage collection. A normal pointer variable should not

However, two methods are provided that solves this problem easily. The first is to use a pinned pointer, i.e. declare the pointer variable with the __pin keyword. This guarantees that the object pointed to will not be moved by the garbage collector. It is recommended that this method not be used to keep a references to managed objects for a long time, since it will decrease the efficiency of the garbage collector. The second way is to use the gcroot smartpointer template type. This lets you create safe pointers to managed objects. E.g. a variable of type gcroot<String> will always point to the String object, even if it has been moved by the garbage collector, and it can be used just like a normal pointer.

 #include <QString>

 #using <mscorlib.dll>
 #include <vcclr.h>

 using namespace System;

 String *QStringToString(const QString &qstring)
 {
     return new String((const wchar_t *)qstring.utf16());
 }

 QString StringToQString(String *string)
 {
     const wchar_t __pin *chars = PtrToStringChars(string);
     return QString::fromWCharArray(chars);
 }

The convertor functions can then be used in the wrapper class implementation to call the functions in the native C++ class.

 #include "networker.h"
 #include "worker.h"
 #include "tools.h"

 netWorker::netWorker()
 {
     workerObject = new Worker();
 }

 netWorker::~netWorker()
 {
     delete workerObject;
 }

The constructor and destructor simply create and destroy the Qt object wrapped using the C++ operators new and delete.

 String *netWorker::get_StatusString()
 {
     return QStringToString(workerObject->statusString());
 }

The netWorker class delegates calls from the .NET code to the native code. Although the transition between those two worlds implies a small performance hit for each function call, and for the type conversion, this should be negligible since we are anyway going to run within the CLR.

 void netWorker::set_StatusString(String *string)
 {
     workerObject->setStatusString(StringToQString(string));
     __raise statusStringChanged(string);
 }

The property setter calls the native Qt class before firing the event using the __raise keyword.

This wrapper class can now be used in .NET code, e.g. using C++, C#, Visual Basic or any other programming language available for .NET.

 using System;

 namespace WrapperApp
 {
         class App
         {
                 void Run()
                 {
                         netWorker worker = new netWorker();

                         worker.statusStringChanged += new netWorker.__Delegate_statusStringChanged(onStatusStringChanged);

                         System.Console.Out.WriteLine(worker.StatusString);

                         System.Console.Out.WriteLine("Working cycle begins...");
                         worker.StatusString = "Working";
                         worker.StatusString = "Lunch Break";
                         worker.StatusString = "Working";
                         worker.StatusString = "Idle";
                         System.Console.Out.WriteLine("Working cycle ends...");
                 }

                 private void onStatusStringChanged(string str)
                 {
                         System.Console.Out.WriteLine(str);
                 }

                 [STAThread]
                 static void Main(string[] args)
                 {
                         App app = new App();
                         app.Run();
                 }
         }
 }

                 private void circleClicked(object sender, System.EventArgs e)
                 {
                         this.circleWidget.lineWidth++;
                 }

                 private void resetLineWidth(object sender, System.EventArgs e)
                 {
                         this.circleWidget.lineWidth = 1;
                         this.resetButton.setFocus();
                 }