通过c＃在非托管c ++ dll中使用循环进行操作（回调）

Question

I have written an unmanaged c++ dll that works good (IPinvoke))) There is one resource-consuming function in it - there is a loop with complex time consuming logic. What is the best way to calculate percentage of this loop progress and sending break to this loop - using callbacks or may be passing parameters? If callbacks is the most good variant - could anyone provide sample?

in dll:

extern "C" _declspec(dllexport) uint8* resourceConsumingFunction(uint8* dataBufer)
{
  //there is a loop with many math here
  return dataBuffer;
}

in c#

[DllImport("MyLib.DLL", CallingConvention = CallingConvention.Cdecl)]
public unsafe static extern byte* resourceConsumingFunction(byte* dataBuf);
//.....
byte* bufbuf = resourceConsumingFunction(data);//there I need to break this function and to get //percentage

Answer 1

Sure, a callback can work. You'll need a function pointer in the C++ code, something like this:

typedef void (__stdcall * pfnCallback)(int progress, int* cancel);

extern "C" _declspec(dllexport) 
uint8* resourceConsumingFunction(uint8* dataBuffer, pfnCallback callback)
{
    for (int progress = 0;;) {
        int cancel = 0;
        callback(progress, &cancel);
        if (cancel) return null;
        // More code
        //...
    }
    return dataBuffer;
}

And the equivalent C# code would be:

private void delegate pfnCallback(int progress, out bool cancel);

private void makeCall() {
    var callback = new pfnCallback(showProgress);
    var bufptr = resourceConsumingFunction(somebuf, callback);
    GC.KeepAlive(callback);
    // etc...
}

private void showProgress(int progress, out bool cancel) {
   // etc...
}

Using __stdcall for the callback helps keep the delegate declaration simple. The GC.KeepAlive() call is necessary to stop the garbage collector from collecting the delegate object too soon.

Answer 2

Based on the info you provided, I think you'll have to rewrite your dll from scratch.

I'd make it a BackgroundWorker, like this (pseudocode, look it up on MSDN):

BackgroundWorker worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;

worker.DoWork += (s,e) => 
{
    loop(loopcondition)
    {
        ... math magic, in which you also calculate percentage ...
        worker.ReportProgress(percentage); // fire 'ProgressChanged' event handled below
    }
};

worker.ProgressChanged += (s,e) => { /*e.ProgressPercentage is the value you passed, here you handle it*/ };

//WARNING: i don't remember the exact event name right now, look it up!
worker.WorkerCompleted += (s,e) => { /*when job is done, you can do something here*/ };

you can interact with UI in the ProgressChanged and WorkerCompleted events, not in DoWork (it's being run in a separate thread).