Cpp/Cli Kích hoạt sự kiện

Question

Tôi có một dự án cpp, một dự án cpp cli và dự án biểu mẫu C# win. Tôi muốn bắn một phương thức từ mã cpp gốc của tôi và bắt nó trong dự án C#. Tôi có thể làm cái này như thế nào?

Answer 1

Có thể có nhiều cách để trả lời câu hỏi này, vì yêu cầu phụ thuộc giữa các dự án đó là quan trọng. Tôi sẽ cố gắng trả lời cho trường hợp phổ biến nhất (tôi đoán): trong đó bạn đã có một thư viện C++ gốc và bạn muốn sử dụng thư viện đó trong một ứng dụng C#. Trong kịch bản đó, dự án C# phụ thuộc vào dự án thư viện gốc. Trong trường hợp này, bạn có thể sử dụng một thư viện cli/C++ cổng cli/C++ để chuyển đổi các sự kiện native C++ thành các sự kiện .NET.

Đây là một mẫu mã hoàn chỉnh, nhưng trước đó, xin lưu ý:

• Nó có thể không phải là giải pháp ngắn nhất, nhưng nó hoạt động tốt. Ngoài ra, nó có thể cung cấp nhiều quyền kiểm soát hơn đối với việc chuyển đổi dữ liệu gốc thành các loại .net.
• Tôi đã sử dụng phương pháp này trong VS 2005. Tôi không biết liệu có một công cụ tốt hơn trong các phiên bản mới hơn của VS cho mục đích tương thích cụ thể đó hay không.
• Nếu sự kiện gốc của bạn được kích hoạt từ một chủ đề không phải là chuỗi GUI, thì hãy cẩn thận với that.

Thư viện Quê quán:

#ifndef _NATIVE_CODE_H_ 
#define _NATIVE_CODE_H_ 

//NativeCode.h 
//A simple native library which emits only one event. 

#include <stdlib.h> 
#include <iostream> 
using namespace std; 

#define NATIVELIBRARY_API __declspec(dllexport) 

//An argument class to wrap event parameters 
class NativeEventArgs{ 
public: 
    //a 32bit integer argument 
    //any other primitives can be here, just be careful about the byte size 
    int argInt32; 

    //null terminated ascii string 
    const char* argString; 

    //null terminated wide/unicode string 
    const wchar_t* argWString; 
}; 

//A simple mechanism to fire an event from native code. 
//Your library may have a DIFFERENT triggering mechanism (e.g. function pointers) 
class INativeListener 
{ 
public: 
    virtual void OnEvent(const NativeEventArgs& args)=0; 
}; 

//The actual native library code, source of native events 
class NATIVELIBRARY_API NativeCode 
{ 
public: 
    NativeCode() 
     :theListener_(NULL) 
    {} 

    //Listener registration method 
    void registerListener(INativeListener* listener) { 
     theListener_ = listener; 
    } 

    //this is the very first source of the event 
    //native code emits the event via the listener mechanism 
    void eventSourceMethod() { 
     //... other stuff 

     //fire the native event to be catched 
     if(theListener_){ 
      //prepare event parameters 
      NativeEventArgs args; 
      wstring wstr(L"A wide string"); 
      string str("A regular string"); 

      //build-up the argument object 
      args.argInt32 = 15; 
      args.argString = str.c_str(); 
      args.argWString = wstr.c_str(); 

      //fire the event using argument 
      theListener_->OnEvent(args); 
     } 
    } 

private: 

    //native code uses a listener object to emit events 
    INativeListener* theListener_; 
}; 

#endif 

Thư viện Cổng mẫu:

//GatewayCode.h 
//GatewayLibrary is the tricky part, 
//Here we listen events from the native library 
//and propagate them to .net/clr world 

#ifndef _GATEWAY_CODE_H_ 
#define _GATEWAY_CODE_H_ 

#include "../NativeLibrary/NativeCode.h" //include native library 
#include <vcclr.h> //required for gcroot 
using namespace System; 
using namespace System::Runtime::InteropServices; 

namespace GatewayLibrary{ 

    //.net equvelant of the argument class 
    public ref class DotNetEventArg{ 
    internal: 

     //contructor takes native version of argument to transform 
     DotNetEventArg(const NativeEventArgs& args) { 

      //assign primitives naturally 
      argInt32 = args.argInt32; 

      //convert wide string to CLR string 
      argWString = Marshal::PtrToStringUni(IntPtr((void*)args.argWString)); 

      //convert 8-bit native string to CLR string 
      argString = Marshal::PtrToStringAnsi(IntPtr((void*)args.argString)); 

      //see Marshal class for rich set of conversion methods (e.g. buffers) 
     } 
    private: 
     String^ argString; 
     String^ argWString; 
     Int32 argInt32; 

    public: 
     //define properties 
     property String^ ArgString { 
      String^ get() { 
       return argString; 
      } 
     } 

     property String^ ArgWString { 
      String^ get() { 
       return argWString; 
      } 
     } 

     property Int32 ArgInt32 { 
      Int32 get() { 
       return argInt32; 
      } 
     } 
    }; 

    //EventGateway fires .net event when a native event happens. 
    //It is the actual gateway class between Native C++ and .NET world. 
    //In other words, It RECEIVES NATIVE events, TRANSFORMS/SENDS them into CLR. 
    public ref class EventGateway { 
    public: 

     //ctor, its implementation placed below 
     EventGateway(); 

     //required to clean native objects 
     ~EventGateway(); 
     !EventGateway(); 

     //the SENDER part 
     //.net event stuff defined here 
     delegate void DotNetEventHandler(DotNetEventArg^ arg); 
     event DotNetEventHandler^ OnEvent; 

    private: 
     //our native library code 
     //notice you can have pointers to native objects in ref classes. 
     NativeCode* nativeCode_; 

     //the required device to listen events from the native library 
     INativeListener* nativeListener_; 

    internal: //hide from .net assembly 

     //the RECEIVER part, called when a native event received 
     void OnNativeEvent(const NativeEventArgs& args){ 
      //you can make necessary transformation between native types and .net types 

      //create .net argument using native argument 
      //required conversion is done by DotNetEventArg class 
      DotNetEventArg^ dotNetArgs = gcnew DotNetEventArg(args); 

      //fire .net event 
      OnEvent(dotNetArgs); 
     } 

    }; 
} 

//A concrete listener class. we need this class to register native library events. 
//Its our second gateway class which connects Native C++ and CLI/C++ 
//It basically gets events from NativeLibary and sends them to EventGateway 
class NativeListenerImp : public INativeListener { 
public: 
    NativeListenerImp(gcroot<GatewayLibrary::EventGateway^> gatewayObj){ 
     dotNetGateway_ = gatewayObj; 
    } 

    //this is the first place we know that a native event has happened 
    virtual void OnEvent(const NativeEventArgs& args) { 

     //inform the .net gateway which is responsible of transforming native event to .net event 
     dotNetGateway_->OnNativeEvent(args); 
    } 

private: 
    //class member to trigger .net gateway. 
    //gcroot is required to declare a CLR type as a member of native class. 
    gcroot<GatewayLibrary::EventGateway^> dotNetGateway_; 
}; 

////ctor and dtors of EventGateway class 
GatewayLibrary::EventGateway::EventGateway() 
{ 
    nativeCode_ = new NativeCode(); 

    //note; using 'this' in ctor is not a good practice 
    nativeListener_ = new NativeListenerImp(this); 

    //register native listener 
    nativeCode_->registerListener(nativeListener_); 
} 

GatewayLibrary::EventGateway::~EventGateway() 
{ 
    //call the non-deterministic destructor 
    this->!EventGateway(); 
} 

GatewayLibrary::EventGateway::!EventGateway() 
{ 
    //clean up native objects 
    delete nativeCode_; 
    delete nativeListener_; 
} 

#endif 

Và việc áp dụng chính thức trong C# (hoặc trong bất kỳ ngôn ngữ .net khác):

//Program.cs 
//C# the final evet consumer application 

using System; 
using System.Collections.Generic; 
using System.Text; 
using GatewayLibrary; 

namespace SharpClient 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      //create the gateway 
      EventGateway gateway = new EventGateway(); 

      //listen on .net events using the gateway 
      gateway.OnEvent += new EventGateway.DotNetEventHandler(gateway_OnEvent); 

     } 

     static void gateway_OnEvent(DotNetEventArg args) 
     { 
      //use the argument class 
      Console.WriteLine("On Native Event"); 
      Console.WriteLine(args.ArgInt32); 
      Console.WriteLine(args.ArgString); 
      Console.WriteLine(args.ArgWString); 
     } 
    } 
}