如何映射Qt信号到事件在托管C ++（C ++ / CLI） [英] How to map Qt Signal to Event in Managed C++ (C++/CLI)

问题描述

我在.NET（C ++ / CLI）中编写一个包装器，以便能够在.NET中使用一些本地C ++ Qt代码。如何将Qt信号映射到托管的.NET事件，以便当我的Qt代码触发一个信号，我可以把这转发到.NET代码。

I'm writing a wrapper in .NET (C++/CLI) to be able to use some native C++ Qt code in .NET. How can I map a Qt signal into a managed .NET event, so that when my Qt code fires off a signal, I can bring this forward to the .NET code.

My Managed类定义事件，但如果我尝试使用正常的QObject :: connect方法来连接信号，它需要一个QObject *接收器...我想我必须做一些魔法编组的一些类型？

My Managed class defines the event, but if I try to use the normal QObject::connect method to hook up to the signal, it requires a QObject * receiver... I guess I have to do some magic marshalling of some sorts?

推荐答案

定义正常的非托管Qt事件处理程序。从这个处理程序，引发托管事件。

Define normal unmanaged Qt event handler. From this handler, raise managed event.

编辑：如果你以前有过Qt的经验，你知道如何处理非托管类中的Qt信号。不要试图让这个类管理。而不是这样，编写包含此QObject派生类的C ++ / CLI包装。

if you have previous experience in Qt, you know how to handle Qt signals in unmanaged class. Don't try to make this class managed. Instead of this, write C++/CLI wrapper which contains this QObject-derived class.

编辑2.创建C ++ / CLI控制台应用程序，调用它test1，代码：

Edit 2. Create C++/CLI Console application, call it test1, and add the following code to it:

test1.cpp：

test1.cpp:

#include "stdafx.h"
#include "ManagedClass.h"

using namespace System;

int main(array ^args)
{
    ManagedClass^ c = gcnew ManagedClass();
    c->Test();

    return 0;
}

ManagedClass.h：

ManagedClass.h:

#pragma once

class UnmanagedClass;

// Wrapper
ref class ManagedClass
{
public:
    ManagedClass(void);
    ~ManagedClass();
    !ManagedClass();
    void Test();
    void Callback();

private:
    UnmanagedClass* m_pUnmanagedClass;
};

ManagedClass.cpp：

ManagedClass.cpp:

#include "StdAfx.h"
#include "ManagedClass.h"
#include "UnmanagedClass.h"

ManagedClass::ManagedClass(void)
{
    m_pUnmanagedClass = new UnmanagedClass(this);
}

ManagedClass::~ManagedClass()
{
    this->!ManagedClass();
    GC::SuppressFinalize(this);
}

ManagedClass::!ManagedClass()
{
    if ( m_pUnmanagedClass )
    {
        delete m_pUnmanagedClass;
        m_pUnmanagedClass = NULL;
    }
}


void ManagedClass::Test()
{
    m_pUnmanagedClass->Test();
}

void ManagedClass::Callback()
{
    Console::WriteLine(L"This text is printed from managed wrapper function, called from unmanaged class.");
    Console::WriteLine(L"Here you can raise managed event for .NET client.");
    Console::WriteLine(L"Let's say that UnmanagedClass is QObject-derived, and this funcstion");
    Console::WriteLine(L"is called from UnmanagedClass Qt event handler - this is what you need.");
}

UnmanagedClass.h：

UnmanagedClass.h:

#pragma once

#include 
using namespace System;


ref class ManagedClass;

// Wrapped native class
class UnmanagedClass
{
public:
    UnmanagedClass(ManagedClass^ pWrapper);
    ~UnmanagedClass(void);
    void Test();

private:
    gcroot m_pWrapper;
};

UnmanagedClass.cpp：

UnmanagedClass.cpp:

#include "StdAfx.h"
#include "UnmanagedClass.h"
#include "ManagedClass.h"

UnmanagedClass::UnmanagedClass(ManagedClass^ pWrapper)
{
    m_pWrapper = pWrapper;
}

UnmanagedClass::~UnmanagedClass(void)
{
}

void UnmanagedClass::Test()
{
    m_pWrapper->Callback();
}

这让你了解非托管类和托管包装器如何一起工作。如果你知道Qt编程，知道如何从ref C ++ / CLI类提高.NET事件，这足以完成你的任务。

This gives you idea how unmanaged class and managed wrapper can play together. If you know Qt programming and know how to raise .NET event from ref C++/CLI class, this is enough to accomplish your task.

这篇关于如何映射Qt信号到事件在托管C ++（C ++ / CLI）的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！