ZFX + Developia

Code: Alles auswählen

void MyCallbackFunction(int[] param)
{
 doSomethingWithParam(param);
}

static void Main(string[] args)
{
 MyDLLClass theClass = new MyDLLClass();
 theClass.setCallbackFunc(MyCallbackFunction);
 while(theClass.isRunning)
 {
  theClass.doSomething();
 }
}

Code: Alles auswählen

void TheClass::setCallback(CallBackFunc^ theCallback)
{
	IntPtr ip = Marshal::GetFunctionPointerForDelegate(theCallback);

	array<int^>^ list;

	using SetCallBackFunc = int __stdcall (array<int^>^);
	auto toCallback = reinterpret_cast<SetCallBackFunc*>(ip.ToPointer());
	auto returnValue = (*toCallback)(list);
}

Code: Alles auswählen

[UnmanagedFunctionPointer(CallingConvention.Cdecl)] // Hier deine gewünschte Calling Convention
public delegate int MyCallback([MarshalAs(UnmanagedType.	LPArray)] int[] values);

public class Methods
{
    static MyCallback callback;
    public static IntPtr GetCallback() {
        if(callback == null)
            callback = MyImplementation; // Musst du bereit stellen
        return Marshal.GetFunctionPointerForDelegate(callback); // Liefere IntPtr auf Delegat zurück
    }
}

Code: Alles auswählen

using MyCCallback = int __cdecl (*) (int * array);

void someFunc(IntPtr ^ptr)
{
    auto myCallback = static_cast<MyCCallback>(ptr.ToPointer()); // reinterpret_cast doch bitte NUR bei virtueller Vererbung ;)
    int data[] = { 1, 2, 3, 4 };
    int result = myCallback(data);
}

Code: Alles auswählen

// Im header
typedef void (*FunctionPointer)(int args[]);
void invoke(FunctionPointer func);

// In cpp Datei
void invoke(FunctionPointer func)
{
    int[] nums = {1, 2, 3, 4};
    func(nums);
}

Code: Alles auswählen

[UnmanagedFunctionPointer (CallingConvention::Cdecl)]
delegate void CallbackFunc ([MarshalAs(UnmanagedType::LPArray, SizeConst = 4)] array<int>^ args);

Code: Alles auswählen

// header der C++ Lib einbinden

void TheClass::invokeCallback(CallBackFunc^ theCallback)
{
    auto funcPtr = static_cast<FunctionPointer>(Marshal::GetFunctionPointerForDelegate(theCallback).ToPointer());
   
    // Aufruf der C++ Funktion
    invoke(funcPtr);
   
    // Sorgt dafür, dass das Delegate nicht vorzeitig vom Garbage Collector eingesammelt wird
    GC::KeepAlive(theCallback);
}

Code: Alles auswählen

MyCallbckClass::onItemChange(CAtlMap<COPCItem *, OPCItemData *>& changes)
{
// hier dann der C#-Funktionsaufruf mit den Änderungen
}

Code: Alles auswählen

	[UnmanagedFunctionPointer(CallingConvention::Cdecl)]
	public delegate void CallbackFunc(array<OPCDAItemData^>^ args);

Code: Alles auswählen

	void OnDataChange(COPCGroup &group, CAtlMap<COPCItem*, OPCItemData*> &changes)
	{
		array<OPCDAItemData^>^ arr = gcnew array<OPCDAItemData^>(changes.GetCount());
		POSITION pos;
		COPCItem* key;
		OPCItemData* value;
		pos = changes.GetStartPosition();

		int index(0);

		while ( pos != NULL )
		{
			key = changes.GetKeyAt(pos);
			value = changes.GetNextValue(pos);
			arr[index] = gcnew OPCDAItemData(value);
			++index;
		}

		mFunctionPtr(arr); // <= ich denke mal hier läuft irgend etwas schief. Wie der Name es schon sagt, ist das der Funktionspointer, dem ich das Array überegeb
}

Code: Alles auswählen

typedef void(*FunctionPointer)(array<OPCDAItemData^>^ arr);

Code: Alles auswählen

	[UnmanagedFunctionPointer(CallingConvention::Cdecl)]
	public delegate void CallbackFunc(/*[MarshalAs(UnmanagedType::LPArray, SizeConst = 5)]*/ array<OPCDAItemData^>^ args);

Code: Alles auswählen

void OPCDAGroup::enableAsynch(CallbackFunc^ theCallback)
{
	auto funcPtr = static_cast<FunctionPointer>(Marshal::GetFunctionPointerForDelegate(theCallback).ToPointer());

	if (mCallback == NULL)
	{
		mCallback = new MyCallBack();
		mCallback->setCallBack(funcPtr);
	}

	mGroup->enableAsynch(*mCallback);

	// Sorgt dafür, dass das Delegate nicht vorzeitig vom Garbage Collector eingesammelt wird
	GC::KeepAlive(theCallback);
}