如何创建异步功能？

Question

I have several member functions inside my C++ class which i packaged them as a dll and tried to used them in a C# application.
I tried to create two async functions by simply executing them using threads and then detaching them() so that they wouldn't block the caller thread till they end. in C++ based application whenever i use threads to call functions this way, they work, but when i tried to call one of my async functions from c#, my app either crashed or hangs!!
these are my so called async functions!:

void xGramManipulator::CreateMonoGramAsync()
{
    thread t(&xGramManipulator::ReadMonoGram, this);
    t.detach();
}

void xGramManipulator::CreateBiGramAsync()
{
    thread t = thread(&xGramManipulator::ReadBiGram, this);
    t.detach();
}

And this is the wrapper function in c which resides in a dll :

//header
CDLL_API void CreateMonoGramAsync(void);
//cpp
CDLL_API void CreateMonoGramAsync(void)
{
    xG.CreateMonoGramAsync();
}

and this is the c# application calling that function :

 private void btnTest_Click(object sender, EventArgs e)
 {
     try
     {
        CreateBiGramAsync();
        CreateMonoGramAsync();
     }
     catch (Exception)
     {
     }

}

What should i do to have a truly async and non blocking member functions in my class? What am i missing here?

Answer 1

My guess is that you are not specifying the calling convention when importing these into C# - by default C# will use stdcall while C++ will export as cdecl . You would have to :

[DllImport("CDll.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void CreateMonoGramAsync();

alternatively, you can of course specify returntype __stdcall when declaring your methods in C++. I'm also assuming you've otherwise declared the function properly (with extern "C" __declspec(dllexport) , etc.)

Answer 2

If you are using .NET 4.5, you could use the Task class in order to achieve an asynchronous method call.

Consider the following example:

    static void Foo()
    {
        Thread.Sleep(2000);
        Console.WriteLine("Foo called asynchronously!");
    }

    static void Main(string[] args)
    {
        var bar = Task.Factory.StartNew(() => { Foo(); });

        Console.WriteLine("Called synchronously!");

        Console.ReadLine();
    }

Whenever this code executes, an asynchronous call to Foo() will be started, which waits two seconds, and then writes Foo called asynchronously! to the console. The other Console.WriteLine call is synchronous, and is run right after the asynchronous call has been started.

The output would be:

Called synchronously!
Foo called asynchronously!

Since the caller's thread isn't blocked by the call to Foo() .

You could do the same with your code, and you could even remove the threading you currently have in your methods to make them asynchronous. Reason being is that even though they create their own thread, the .NET runtime is still going to wait for those functions to return. You would be better off calling them like so:

Task.Factory.StartNew(CreateBiGramAsync());

That way they'll actually be called asynchronously from .NET itself, and they won't block the caller thread.