AsyncMutex.cs

using System;
using System.Threading;
using System.Threading.Tasks;
 
namespace Waher.Runtime.Threading.Sync
{
    public class AsyncMutex : IDisposable
    {
        private readonly object synchObj = new object();
        private ThreadExecutor executor = null;
        private Mutex mutex;
 
        public AsyncMutex()
            : this(new Mutex())
        {
        }
 
        public AsyncMutex(bool InitiallyOwned)
            : this(new Mutex(InitiallyOwned))
        {
        }
 
        public AsyncMutex(bool InitiallyOwned, string Name)
            : this(new Mutex(InitiallyOwned, Name))
        {
        }
 
        public AsyncMutex(bool InitiallyOwned, string Name, out bool CreatedNew)
            : this(new Mutex(InitiallyOwned, Name, out CreatedNew))
        {
        }
 
        public AsyncMutex(Mutex Mutex)
            : base()
        {
            this.mutex = Mutex;
        }
 
        public static AsyncMutex OpenExisting(string Name)
        {
            return new AsyncMutex(Mutex.OpenExisting(Name));
        }
 
        public static bool TryOpenExisting(string Name, out AsyncMutex Result)
        {
            if (!Mutex.TryOpenExisting(Name, out Mutex MutexObj))
            {
                Result = null;
                return false;
            }
 
            Result = new AsyncMutex(MutexObj);
 
            return true;
        }
 
        private ThreadExecutor Executor
        {
            get
            {
                lock (this.synchObj)
                {
                    if (this.executor is null)
                        this.executor = new ThreadExecutor();
 
                    return this.executor;
                }
            }
        }
 
        public void Dispose()
        {
            this.executor?.Dispose();
            this.executor = null;
 
            this.mutex?.Dispose();
            this.mutex = null;
        }
 
        public Task<bool> WaitOne()
        {
            return this.Executor.Execute(this.WaitOneSync);
        }
 
        private bool WaitOneSync()
        {
            return this.mutex.WaitOne();
        }
 
        public Task<bool> WaitOne(int MillisecondsTimeout)
        {
            return this.Executor.Execute(this.WaitOneSync, MillisecondsTimeout);
        }
 
        private bool WaitOneSync(int MillisecondsTimeout)
        {
            return this.mutex.WaitOne(MillisecondsTimeout);
        }
 
        public Task<bool> WaitOne(int MillisecondsTimeout, bool ExitContext)
        {
            return this.Executor.Execute(this.WaitOneSync, MillisecondsTimeout, ExitContext);
        }
 
        private bool WaitOneSync(int MillisecondsTimeout, bool ExitContext)
        {
            return this.mutex.WaitOne(MillisecondsTimeout, ExitContext);
        }
 
        public Task<bool> WaitOne(TimeSpan Timeout)
        {
            return this.Executor.Execute<bool, TimeSpan>(this.WaitOneSync, Timeout);
        }
 
        private bool WaitOneSync(TimeSpan Timeout)
        {
            return this.mutex.WaitOne(Timeout);
        }
 
        public Task<bool> WaitOne(TimeSpan Timeout, bool ExitContext)
        {
            return this.Executor.Execute(this.WaitOneSync, Timeout, ExitContext);
        }
 
        private bool WaitOneSync(TimeSpan Timeout, bool ExitContext)
        {
            return this.mutex.WaitOne(Timeout, ExitContext);
        }
 
        public async Task ReleaseMutex()
        {
            await this.Executor.Execute(this.ReleaseMutexSync);
        }
 
        private bool ReleaseMutexSync()
        {
            this.mutex.ReleaseMutex();
            return true;
        }
    }
}