如何编写包装类以将 Qt 信号映射到 C# 事件（通过 C++/CLI）

Posted 2023-02-22

【中文标题】如何编写包装类以将 Qt 信号映射到 C# 事件（通过 C++/CLI）

【英文标题】：How to write wrapper classes for mapping Qt Signals to C# events (through C++/CLI)

【发布时间】：2016-04-25 15:07:06

【问题描述】：

通过 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 仓库：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...

【问题讨论】：

您能否更具体地说明是什么让您绊倒了？你得到编译错误吗？运行时错误？没有错误但事件没有触发？

您需要做两件事： 1. 将事件处理程序声明为您的类的成员。 2. 从连接到信号的槽（实际上是 lambda）调用事件处理程序。这就是它的全部内容。

"可以粘贴我当前的示例代码，但我认为这只会让读者感到困惑......" 这正是你需要做的，以保持这个问题的主题。否则，就是直接复制。

@Kuba Ober 您能否进一步详细说明您的第一条评论，例如有代码示例吗？

【参考方案1】：

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

要克服这个问题，首先你必须回退到 C++ 接口，并在那里安全地执行 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 特定类。

---

如果您使用的是 Qt4 并且不要使用 C++11，则上述解决方案很好。

如果您使用的是 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;

这更容易、更快、更容易维护。

【讨论】：

虽然我很遗憾没有时间测试您的解决方案，但它解释得很好，很有意义，看起来很有希望。赏金结束后我不会在这里，所以我会提前奖励它。

如何使用您最后的 lambda 提示来规避此编译器错误：ManagedCppQtSpace::ManagedQt::ctor::<lambda_somehash>: local class, struct or union definitions are not allowed in a member function of a managed class

使用 Qt4 方法：从本机接口派生托管类 (ref class) 是不可能的 -> 编译器错误。由于关于未知命名空间/类等的编译器错误，编写另一个通过auto_gcroot<ManagedCppQt^> 使用托管对象的代理类失败。TL;DR：我无法让它工作。