using System;

using System.Threading;

using System.Threading.Tasks;

using System.Runtime.CompilerServices;

​

public class Program

{

    public static async Task Main()

    {

        Message message = new Message();

        ScheduleMessageCompletion();

        Print("Before await message");

        await message;

        Print("After await message");

​

        async void ScheduleMessageCompletion()

        {

            await Task.Delay(1000); // Simulate an I/O bound operation

            message.SetCompleted();

        }

    }

​

    public class Message : INotifyCompletion

    {

        private static readonly Action _completedSentinel = new(() => { });

        private Action _continuation;

​

        public Message GetAwaiter() { return this; }

        public bool IsCompleted

            => ReferenceEquals(Volatile.Read(ref _continuation), _completedSentinel);

        public void OnCompleted(Action continuation)

        {

            Action original = Interlocked.CompareExchange(ref _continuation,

                continuation, null);

            if (original is null) return; // Normal case

            if (ReferenceEquals(original, _completedSentinel))

                continuation(); // Rare case

            else

                throw new InvalidOperationException("Double await");

        }

        public void GetResult() { }

​

        public void SetCompleted()

        {

            Action continuation = Interlocked.Exchange(ref _continuation,

                _completedSentinel);

            if (continuation is null) return;

            ThreadPool.QueueUserWorkItem(state => ((Action)state).Invoke(), continuation);

        }

    }

​

    private static void Print(object value)

    {

        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff} [{Thread.CurrentThread.ManagedThreadId}] > {value}");

    }

}

​