Yönetilen C++ (C++/CLI) Olayı Qt Sinyali nasıl eşlenir

Question

.NET'te bazı yerel C++ Qt kodlarını kullanabilmek için .NET (C++/CLI) bir sarmalayıcı yazıyorum. Bir Qt sinyalini yönetilen bir .NET olayına nasıl eşleyebilirim, böylece Qt kodum bir sinyali kapattığında bunu .NET koduna iletebilirim.

Yönetilen sınıfım, olayı tanımlar, ancak sinyali almak için normal QObject :: connect yöntemini kullanmaya çalışırsam, bir QObject * alıcısı gerektirir ... Sanırım bir sihir sihri yapmak zorundayım bazı çeşitler?

Answer 1

Normal yönetilmeyen Qt olay işleyicisini tanımlayın. Bu işleyiciden yönetilen etkinliği kaldırın.

Düzenleme: Qt'de daha önce bir deneyiminiz varsa, yönetilmeyen bir sınıfta Qt sinyallerinin nasıl işleneceğini bilirsiniz. Bu sınıfı yönetmeyi denemeyin. Bunun yerine, bu QObject türetilmiş sınıf içeren C++/CLI sarıcı yazın.

Düzenleme 2. test1 diyoruz ve bunun için aşağıdaki kodu ekleyin C++/CLI Konsol uygulaması oluşturun:

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

Bu size yönetilmeyen sınıf ve yönetilen sarıcı birlikte oynayabilir nasıl bir fikir verir. Qt programlama bilgisini biliyorsanız ve .NET olayını ref C++/CLI sınıfından nasıl kaldıracağınızı biliyorsanız, bu görevinizi gerçekleştirmek için yeterlidir.