C#.NET using async method to prevent user call the API twice at the same time

Question

using System;
using System.Threading;

namespace Examples.AdvancedProgramming.AsynchronousOperations
{
    public class AsyncMain
    {
        public static void Main()
        {
            // The asynchronous method puts the thread id here.
            int threadId;

            // Create an instance of the test class.
            AsyncDemo ad = new AsyncDemo();

            // Create the delegate.
            AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);

            // Initiate the asychronous call.
            IAsyncResult result = caller.BeginInvoke(3000,
                out threadId, null, null);

            Thread.Sleep(0);
            Console.WriteLine("Main thread {0} does some work.",
                Thread.CurrentThread.ManagedThreadId);

            // Call EndInvoke to wait for the asynchronous call to complete,
            // and to retrieve the results.
            string returnValue = caller.EndInvoke(out threadId, result);

            Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".",
                threadId, returnValue);
        }
    }
}

EndInvoke might block the calling thread because it does not return until the asynchronous call completes.

I will implement EndInvoke in a API, to prevent the user call the API twice. Am I using correct way to prevent same user calling the API twice at the same time?

Answer 1

If I can suppose that the AsyncDemo is implemented as in this MSDN article:

public class AsyncDemo
{
    // The method to be executed asynchronously.
    public string TestMethod(int callDuration, out int threadId)
    {
        Console.WriteLine("Test method begins.");
        Thread.Sleep(callDuration);
        threadId = Thread.CurrentThread.ManagedThreadId;
        return string.Format("My call time was {0}.", callDuration.ToString());
    }
}

and the related AsyncMethodCaller delegate is defined as this:

public delegate string AsyncMethodCaller(int callDuration, out int threadId);

then you have two options depending on the .NET version:

.NET Framework

Here we can use the Task.FromAsync (1) to convert the APM model to TPL.
I had to define two helper methods (Begin, End) to pass the extra parameters to the TestMethod.
The End method returns with a tuple (string, int) in order to avoid out parameter. (1)

public static async Task Main()
{
    var ad = new AsyncDemo();
    AsyncMethodCaller caller = ad.TestMethod;

    IAsyncResult Begin(AsyncCallback cb, object state = null)
        => caller.BeginInvoke(3000, out _, cb, state);
    (string, int) End(IAsyncResult iar)
    {
        var result = caller.EndInvoke(out var threadId, iar);
        return (result, threadId);
    };

    var task1 = Task.Factory.FromAsync(Begin, End, null);
    var task2 = Task.Factory.FromAsync(Begin, End, null);

    await Task.WhenAll(task1, task2);

    var (result1, threadId1) = await task1;
    var (result2, threadId2) = await task1;

    Console.WriteLine($"{threadId1}: {result1}");
    Console.WriteLine($"{threadId2}: {result2}");
}

The output would be:

Test method begins.
Test method begins.
3: My call time was 3000.
3: My call time was 3000.

.NET Core

Here we can't use BeginInvoke because it would throw a PlatformNotSupportedException.
The workaround here is the usage of Task.Run.

static async Task Main(string[] args)
{
    int threadId1 = 0, threadId2 = 0;

    var ad = new AsyncDemo();
    AsyncMethodCaller caller = ad.TestMethod;

    var task1 = Task.Run(() => caller(3000, out threadId1));
    var task2 = Task.Run(() => caller(3000, out threadId2));

    await Task.WhenAll(task1, task2);

    Console.WriteLine($"{threadId1}: {await task1}");
    Console.WriteLine($"{threadId2}: {await task2}");
}

The output would be:

Test method begins.
Test method begins.
4: My call time was 3000.
5: My call time was 3000.