locker.cs

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;
 
 namespace WB.Core.GenericSubdomains.Portable
 {
     /// </remarks>
     public class NamedLocker
     {
        private readonly ConcurrentDictionary<string, LockHolder>
            locks = new ConcurrentDictionary<string, LockHolder>();
 
        public NamedLocker()
         {
            Task.Factory.StartNew(async () =>
            {
                await Task.Delay(TimeSpan.FromMinutes(1));
                 
                cleanupLock.EnterWriteLock();
                try
                {
                    var currentTicks = DateTime.UtcNow.Ticks;
                    var threshold = TimeSpan.FromMinutes(1).Ticks;
                     
                    foreach (var key in locks.Keys)
                     {
                        if (locks.TryGetValue(key, out var holder))
                         {
                            if (currentTicks - holder.Ticks > threshold)
                             {
                                locks.TryRemove(key, out _);
                            }
                        }
                     }
                 }
                 finally
                 {
                    cleanupLock.ExitWriteLock();
                 }
            });
         }

        private readonly ReaderWriterLockSlim cleanupLock = new ReaderWriterLockSlim();

        private class LockHolder
        {
            public long Ticks = 0;
         }
 
        public TResult RunWithLock<TResult>(string name, Func<TResult> body)
         {
            cleanupLock.EnterReadLock();
             try
             {
                var l = this.locks.GetOrAdd(name, s => new LockHolder());

                lock (l)
                 {
                    l.Ticks = DateTime.UtcNow.Ticks;
                    return body();
                 }
             }
             finally
             {
                cleanupLock.ExitReadLock();
             }
         }
     }