Managed C++/CLI

<br />
delegate void MyFormMethod (void); // declare the delegate.<br />
typedef void (*PFUNC)(void);       // type for the method I want to call from outside.<br />
<br />
PFUNC pFunc (void);                // actually create a public pointer for my method.<br />

	<br />
public:<br />
    Form1(void)<br />
    {<br />
        InitializeComponent();<br />
<br />
        MyFormMethod^ m = gcnew MyFormMethod(this, &Form1::MyMethod); // create instance of my delegate.<br />
        IntPtr pint = Marshal::GetFunctionPointerForDelegate (m);     // get the pointer my method.<br />
        PFUNC pFunc = (PFUNC)pint.ToPointer ();                       // save it in the global pointer.<br />
    }<br />

public:
    Form1(void)
    {
        InitializeComponent();

        MyFormMethod^ m = gcnew MyFormMethod(this, &Form1::MyMethod); // create instance of my delegate.
        IntPtr pint = Marshal::GetFunctionPointerForDelegate (m); // get the pointer my method.
        PFUNC pFunc = (PFUNC)pint.ToPointer (); // save it in the global pointer.
        <code>pFunc();                   // works.</code>
    }

private: System::Void button1_Click(System::Object^  sender, System::EventArgs^  e) {
        <code>pFunc();                   // does not link, unresolved external pFunc.</code>
}

delegate void UpdateText( String^ );


ref class SomeClass
{
  public:
    event UpdateText^ OnUpdateText;
};


public ref class Form1 : Form
{
  public:

    Form1()
    {
      InitializeComponent();
      
      someClass_ = gcnew SomeClass();
      
      someClass_->OnUpdateText += gcnew UpdateText( this, &Form1::UpdateTextHandler );
    }

  private:
   
    SomeClass^ someClass_;
    
    void UpdateTextHandler( String^ text )
    {
      textBox->Text = text;
    }
};

<font color=green>// I added public here so compiler stops giving a warning: 
// 'OnUpdateText': signature of non-private member contains assembly private 
// type 'EventTest::UpdateText'.</font>
<code>public</code> delegate void UpdateText( String^ );

<font color=green>// Needed to add public here so I can use this class as a base class later.</font>
<code>public</code> ref class SomeClass
{
  public:
    event UpdateText^ OnUpdateText;
};

public ref class Form1 : Form
{
  public:
    Form1()
    {
      InitializeComponent();
      someClass_ = gcnew SomeClass();
      someClass_->OnUpdateText += gcnew UpdateText( UpdateTextHandler );
    }

  private:
    SomeClass^ someClass_;
    void UpdateTextHandler( String^ text )
    {
      textBox->Text = text;
    }

<font color=green>// This is just my button handler. It calls foo() located in MyCode.CPP, which calls
// MyClass_UpdateText(), which fires an OnUpdateText event.</font>
    System::Void button1_Click (System::Object^ sender, System::EventArgs^  e) {
                 void foo (String^ Text);
                 foo ("Text for textBox");
             }

};

#include "stdafx.h"
#include "Form1.h"

using namespace EventTest;

<font color=green>// I had to add MyClass based on SomeClass as otherwise the compiler gives the error:
// error C3767: 'EventTest::SomeClass::OnUpdateText::raise': candidate function(s) not accessible. I
// looked up the error at MSDN: "Compiler Error C3767" and they had the example to avoid it via an extra
// class MyClass.</font>

<code>public ref class MyClass: public SomeClass
{
public:
    void MyClass_UpdateText (String^ Text) {
        SomeClass^ EventKeeper = gcnew SomeClass;
        EventKeeper->OnUpdateText (Text);
    }
};</code>

void foo (String^ Text) {
    MyClass^ y = gcnew MyClass();
    y->MyClass_UpdateText (Text);
}

#include "WorkerClass.h"

namespace WinApp1
{
   public ref class Form1 : public Form
   {
   public:

      Form1()
      {
         InitializeComponent();

         workerClass_ = gcnew WorkerClass();

         workerClass_->OnUpdateText += gcnew UpdateText( this, &Form1::UpdateTextHandler );
      }

   private:

      TextBox^ textBox_;
      Button^ button_;

      WorkerClass^ workerClass_;

      void button__Click( System::Object^ sender, System::EventArgs^ e )
      {
         workerClass_->DoSomething();
      }

      void UpdateTextHandler( String^ text )
      {
         textBox_->Text = text;
      }
   };
}

namespace WinApp1
{
   delegate void UpdateText( String^ );

   ref class WorkerClass
   {
   public:

      event UpdateText^ OnUpdateText;

      void DoSomething()
      {
         ++serialNumber_;
         OnUpdateText( Convert::ToString( serialNumber_ ) );
      }

   private:

      int serialNumber_;
   };
}

Luc Pattyn wrote:

there is no such thing as a destructor

class Class1
{
   public Class1()
   {
      Console.WriteLine( "Class1 constructed." );
   }

   ~Class1()
   {
      Console.WriteLine( "Class1 destructed." );
   }
}

Dispose()<br />
{<br />
   Dispose(true);<br />
   GC::SuppressFinalize();<br />
}

iddqd515 wrote:

in C# when you declare ~Class1() this is actually mapped to the finalizer (Dispose(false)) in the dispose pattern.

Mark Salsbery
Microsoft MVP - Visual C++