AsyncBlocker.NET 1.0.1.5

AsyncBlocker.NET

Start and Stop in a thread safe way using a very simple Semaphore

Prevents the blocked Method from executing again until Stop or ReleaseWhenTaken is called.

Usage

using System.Threading.Tasks

AsyncBlocker asyncBlocker = new AsyncBlocker();             // Lock
AsyncBlockerSimple asyncBlocker = new AsyncBlockerSimple(); // No Lock

Start

Calling Start will block the current Method from executing again until Stop or ReleaseWhenTaken is called.

public void Start()
{
    bool taken = asyncBlocker.Start();

    if (taken)
    {
        // Your Code
    }
    else
    {
        return;
    }
}

Stop

Calling Stop or ReleaseWhenTaken from any thread will allow the blocked Method to be called again

asyncBlocker.Stop();
asyncBlocker.ReleaseWhenTaken();

Test Console Example

Below is a full example of three threads fighting over one AsyncBlockerSimple

One and Two can not execute the Method again until Three calls Stop, preventing double execution.

One and Two can not execute the Method at the same time.

using System;
using System.Threading;
using System.Threading.Tasks;

namespace Test
{
    internal class Program
    {
        static bool run = true;

        static volatile int last1 = 0;
        static volatile int last2 = 0;
        static volatile int counter1 = 0;
        static volatile int counter2 = 0;
        static volatile int counter3 = 0;

        static void Main()
        {
            AsyncBlockerSimple asyncBlocker = new AsyncBlockerSimple();

            // One
            Task.Run(async () =>
            {
                while (run)
                {
                    bool one = asyncBlocker.Start();

                    if (one)
                    {
                        counter1++;
                    }
                    else
                    {
                        counter3++;
                    }

                    await Task.Delay(50);
                }
            });

            // Two
            ThreadPool.UnsafeQueueUserWorkItem(async (_) =>
            {
                while (run)
                {
                    bool two = asyncBlocker.Start();

                    if (two)
                    {
                        counter2++;
                    }
                    else
                    {
                        counter3++;
                    }

                    await Task.Delay(50);
                }
            }, null);

            // Three
            ThreadPool.UnsafeQueueUserWorkItem(async (_) =>
            {
                while (run)
                {
                    asyncBlocker.Stop();

                    await Task.Delay(300);

                    Console.SetCursorPosition(0, 0);

                    Console.WriteLine("One    : " + counter1);
                    Console.WriteLine("Two    : " + counter2);
                    Console.WriteLine("Skipped: " + counter3);

                    if (counter1 > last1)
                    {
                        if (counter2 != last2)
                        {
                            run = false;
                        }
                    }

                    if (counter2 > last2)
                    {
                        if (counter1 != last1)
                        {
                            run = false;
                        }
                    }

                    last1 = counter1;
                    last2 = counter2;
                }

                Console.WriteLine("Failed");
            }, null);

            Console.ReadLine();
        }
    }
}