Semaphores.cs

using System;
using System.Threading.Tasks;
using Waher.Runtime.Cache;
 
namespace Waher.Runtime.Threading
{
    public static class Semaphores
    {
        private static readonly Cache<string, MultiReadSingleWriteObject> semaphores;
 
        static Semaphores()
        {
            semaphores = new Cache<string, MultiReadSingleWriteObject>(int.MaxValue, TimeSpan.MaxValue, TimeSpan.FromHours(1), true);
            semaphores.Removed += Semaphores_Removed;
        }
 
        private static Task Semaphores_Removed(object Sender, CacheItemEventArgs<string, MultiReadSingleWriteObject> e)
        {
            e.Value.Dispose();
 
            return Task.CompletedTask;
        }
 
        private static MultiReadSingleWriteObject GetSemaphore(string Key)
        {
            lock (semaphores)
            {
                if (semaphores.TryGetValue(Key, out MultiReadSingleWriteObject Result))
                    return Result;
 
                Result = new MultiReadSingleWriteObject(Key);
                semaphores[Key] = Result;
 
                return Result;
            }
        }
 
        public static async Task<Semaphore> BeginRead(string Key)
        {
            await GetSemaphore(Key).BeginRead();
            return new Semaphore(Key, 1);
        }
 
        public static Task EndRead(string Key)
        {
            return GetSemaphore(Key).EndRead();
        }
 
        public static Task<bool> TryBeginRead(string Key, int Timeout)
        {
            return GetSemaphore(Key).TryBeginRead(Timeout);
        }
 
        public static async Task<Semaphore> BeginWrite(string Key)
        {
            await GetSemaphore(Key).BeginWrite();
            return new Semaphore(Key, true);
        }
 
        public static Task EndWrite(string Key)
        {
            return GetSemaphore(Key).EndWrite();
        }
 
        public static Task<bool> TryBeginWrite(string Key, int Timeout)
        {
            return GetSemaphore(Key).TryBeginWrite(Timeout);
        }
    }
}