Cách ánh xạ Tín hiệu Qt đến Sự kiện trong Managed C++ (C++/CLI)

Question

Tôi đang viết một trình bao bọc trong .NET (C++/CLI) để có thể sử dụng một số mã C++ Qt gốc trong .NET. Làm thế nào tôi có thể ánh xạ một tín hiệu Qt vào một sự kiện .NET được quản lý, để khi mã Qt của tôi kích hoạt một tín hiệu, tôi có thể chuyển tiếp mã này sang mã .NET.

Lớp được quản lý của tôi xác định sự kiện, nhưng nếu tôi cố gắng sử dụng phương pháp kết nối QObject :: bình thường để kết nối với tín hiệu, nó yêu cầu bộ thu QObject * ... tôi đoán tôi phải thực hiện một số phép thuật một số loại?

Answer 1

Xác định trình xử lý sự kiện Qt không được quản lý bình thường. Từ trình xử lý này, hãy tăng sự kiện được quản lý.

Chỉnh sửa: nếu bạn có kinh nghiệm trước đó trong Qt, bạn biết cách xử lý tín hiệu Qt trong lớp không được quản lý. Đừng cố gắng làm cho lớp này được quản lý. Thay vào đó, hãy viết trình bao bọc C++/CLI có chứa lớp dẫn xuất QObject này.

Sửa 2. Tạo ứng dụng C++/CLI Console, gọi nó là test1, và thêm đoạn mã sau vào nó:

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:

 
#pragma once 

class UnmanagedClass; 

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

private: 
    UnmanagedClass* m_pUnmanagedClass; 
}; 

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:

 
#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:

 
#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(); 
} 

này cung cấp cho bạn ý tưởng như thế nào lớp không được quản lý và wrapper quản lý có thể chơi với nhau. Nếu bạn biết lập trình Qt và biết cách nâng cao sự kiện .NET từ lớp ref C++/CLI, điều này là đủ để thực hiện nhiệm vụ của bạn.