通过 C++/CLI 包装器调用 C++/Qt 类就像在公园散步一样。

但我无法将 C++/Qt 信号映射到 C# 事件。

我尝试结合一些可用的操作方法/答案，但没有得到任何有效结果:

• How to map Qt Signal to Event in Managed C++ (C++/CLI)
• Calling managed code from unmanaged code and vice-versa
• 和其他一些不那么直接相关的...

这里的问题是，这些操作方法/答案已经很老了。我目前正在使用 Qt5.5(即将推出 5.6)和 .NET 4.6。我试图使一切适应当前的技术水平，但可能失败了。

可能是因为树太多，我看不到森林，所以我想求一个工作的例子，用当前的框架版本完成任务，这样我可以发现差异并从错误中吸取教训。

[编辑] 您可以查看此 github 存储库以获取此来源。 QtSignal 到 C#Event 的部分被注释掉，使这段代码处于工作状态。

Github repo :https://github.com/qwc/QtSignalToCSharpEvent

对于那些仍然想阅读所有内容而不去玩的人……继续阅读…… 这是我当前的非工作代码:

所以我有一个纯 Qt5 类

#ifndef PUREQT_H
#define PUREQT_H

#include <QObject>
#include <QString>
#include "PureQt_global.h"

class PUREQTSHARED_EXPORT PureQt : public QObject    {
    Q_OBJECT

public:
    PureQt(QString name);
    ~PureQt(){}
    QString getSomeVar();
    void someFunc(const QString & string);
public slots:
signals:
    void someFuncWasCalled(const QString &string);
private:
    QString someVar;
};

#endif // PUREQT_H

通过以下相当简单的实现:

#include "PureQt.h"

PureQt::PureQt(QString name)    {
    this->someVar = "ctor("+name+")";
}

QString PureQt::getSomeVar()    {
    return this->someVar;
}

void PureQt::someFunc(const QString &string)    {
    this->someVar += "someFunc("+string+")";
    emit someFuncWasCalled(this->someVar);
}

然后我用 C++/CLI 实现了一个托管包装器，以便能够从 C# 调用非托管代码。请注意，我已经尝试添加代码以获取事件管理的信号。

#pragma once
#include "conversion.h"
#include "../pureqt/PureQt.h"
#include "SignalProxy.h"

using namespace System;
using namespace System::Collections::Generic;
using namespace System::Runtime::InteropServices;

namespace ManagedCppQtSpace {

    // different variants... from tinkering around.
    delegate void someFuncWasCalled(String^);
    delegate void someFuncWasCalledU(QString str);

    [StructLayoutAttribute(LayoutKind::Sequential)]
    public ref struct DelegateWrapper {
        [MarshalAsAttribute(UnmanagedType::FunctionPtr)]
        someFuncWasCalledU^ delegate;
    };

    public ref class ManagedCppQt
    {
    public:    
        ManagedCppQt(String^ name){
            pureQtObject = new PureQt(StringToQString(name));
            proxy = new SignalProxy(pureQtObject);
            wrapper = gcnew DelegateWrapper();
            wrapper->delegate = gcnew someFuncWasCalledU(this, ManagedCppQt::signalCallback);
            signalCallbackProxy callbackproxy;
            Marshal::StructureToPtr(wrapper, callbackproxy, false); // currently im stuck here with a compile error, but the problem may lie somewhere else...
            proxy->setCallback(callbackproxy);
        };
        ~ManagedCppQt(){
            delete pureQtObject;
        };

        event someFuncWasCalled ^ someFuncCalled;

        void someFunc(String^ string){
            pureQtObject->someFunc(StringToQString(string));
        };

        String^ getSomeString() {
            return QStringToString(pureQtObject->getSomeVar());
        }

        void signalCallback(QString str) {
            someFuncCalled(QStringToString(str));
        }

        DelegateWrapper ^ wrapper;

    private:
        PureQt * pureQtObject;
        SignalProxy * proxy;
    };
}

因此，为了将来自 Qt 的信号和槽处理与能够在托管代码中引发事件的回调联系起来，当没有更改基础代码的选项时，一些人将需要一个代理类(因为它也用于其他非托管 C++ 项目).

#ifndef SIGNALPROXY_H
#define SIGNALPROXY_H

#include <QObject>
#include "../pureqt/PureQt.h"

typedef void (*signalCallbackProxy) (QString str);

class SignalProxy : public QObject
{
    Q_OBJECT

public:
    explicit SignalProxy(PureQt* pqt);
    ~SignalProxy();
    void setCallback(signalCallbackProxy callback);
signals:
public slots:
    void someFuncSlot(QString str);
private:
    PureQt* pureQt;
    signalCallbackProxy scallback;
};

#endif // SIGNALPROXY_H

随着实现:

#include "SignalProxy.h"

SignalProxy::SignalProxy(PureQt* pqt){
    pureQt = pqt;
    this->connect(pureQt, SIGNAL(PureQt::someFuncWasCalled(QString)), this, SLOT(someFuncSlot(QString)));
}

SignalProxy::~SignalProxy()
{}

void SignalProxy::setCallback(signalCallbackProxy callback){
    this->scallback = callback;
}

void SignalProxy::someFuncSlot(QString str){
    if(this->scallback != NULL)
        this->scallback(str);
}

所以。现在，如何正确链接这两个世界，Qt 信号 -> 托管 .NET 事件？

我也尝试过一些简单的方法，但会导致编译错误，例如:

QObject::connect(pureQtObject, &PureQt::someFuncWasCalled, &MangagedCppQtSpace::ManagedCppQt::signalCallback);

代替代理类，或使用 lambda 函数:

QObject::connect(pureQtObject, &PureQt::someFuncWasCalled, [] (QString str) {
    signalCallback(str);// or ManagedCppQt::signalCallback, but for this the method has to be static, and it isn't possible to raise events from static methods...
}

最佳答案

这里的问题是将 Qt 与 C++ CLI 混合使用。要获得功能性信号和槽，Qt 需要进程头文件来生成自己的元数据。问题是该工具将无法理解 C++CLI 功能。

要首先解决这个问题，您必须回退到 C++ 接口(interface)并在那里安全地执行 C++ CLI 操作。

所以你需要像这样的额外类，它不知道 .net 并创建到标准 C++ 的桥梁:

class PureQtReceiverDelegate { // this should go to separate header file
   virtual void NotifySomeFunc(const char *utf8) = 0;
};

class PureQtReceiver : public QObject {
    Q_OBJECT

public:
    PureQtReceiver(PureQtReceiverDelegate *delegate, PureQt *parent)
    : QObject(parent)
    , mDelegate(delegate)
    {
        bool ok = connect(parent, SIGNAL(PureQt::someFuncWasCalled(QString)),
                this, SLOT(someFuncReceiver(QString)));
        Q_ASSERT(ok);
    }

public slots:
    void someFuncReceiver(const QString & string)
    {
        delegate->NotifySomeFunc(string.toUtf8().data());
    }
private:
    PureQtReceiverDelegate *delegate;
};

现在您的 C++CLI 类应该实现此 PureQtReceiverDelegate 并将字符串转换为 .net 版本并发布通知。

请注意，您可以/应该在 C++CLI 头文件中转发声明 Qt 特定类。

如果您使用的是 Qt 5 并且有可用的 C++11，则有更方便的解决方案:您可以在与 QObject 建立连接时使用 lambda 表达式。所以你的 ManagedCppQt 看起来像这样:

标题:

#pragma once
#include "conversion.h"

using namespace System;
using namespace System::Collections::Generic;
using namespace System::Runtime::InteropServices;

// forward declaration
class PureQt;

namespace ManagedCppQtSpace {
    delegate void someFuncWasCalled(String^);

    public ref class ManagedCppQt
    {
    public:    
        ManagedCppQt(String^ name);
        ~ManagedCppQt();

        event someFuncWasCalled ^ someFuncCalled;

        void someFunc(String^ string);

        String^ getSomeString();

        void signalCallback(QString str);

    private:
        PureQt * pureQtObject;
    };
}

在 cpp 中:

#include "../pureqt/PureQt.h"

using namespace ManagedCppQtSpace;

ManagedCppQt:ManagedCppQt(String^ name) {
    pureQtObject = new PureQt(QStringFromString(name));
    QObject::connect(pureQtObject, &PureQt::someFuncWasCalled,
                     [this](const QString &string){
                         if (this->someFuncCalled) {
                              String^ s = StringFromQString(string);
                              this->someFuncCalled(s);
                         }
                     });
}

ManagedCppQt::~ManagedCppQt(){
    delete pureQtObject;
}

这更容易、更快速且更易于维护。

关于c# - 如何编写用于将 Qt 信号映射到 C# 事件的包装类(通过 C++/CLI)，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/36844406/