Example #1
0
        /// <summary>
        /// ExecuteLock accepts a delegate to execute in the context of a lock, releasing the lock when completed.
        /// </summary>
        /// <param name="opts"></param>
        /// <param name="action"></param>
        /// <returns></returns>
        public async Task ExecuteLocked(LockOptions opts, Action action, CancellationToken ct = default(CancellationToken))
        {
            if (opts == null)
            {
                throw new ArgumentNullException(nameof(opts));
            }
            if (action == null)
            {
                throw new ArgumentNullException(nameof(action));
            }

            var l = await AcquireLock(opts, ct).ConfigureAwait(false);

            try
            {
                if (!l.IsHeld)
                {
                    throw new LockNotHeldException("Could not obtain the lock");
                }
                action();
            }
            finally
            {
                await l.Release().ConfigureAwait(false);
            }
        }
Example #2
0
 public Task ExecuteLocked(LockOptions opts, CancellationToken ct, Action action)
 {
     if (opts == null)
     {
         throw new ArgumentNullException(nameof(opts));
     }
     return(ExecuteLocked(opts, action, ct));
 }
Example #3
0
 /// <summary>
 /// CreateLock returns an unlocked lock which can be used to acquire and release the mutex. The key used must have write permissions.
 /// </summary>
 /// <param name="opts"></param>
 /// <returns></returns>
 public IDistributedLock CreateLock(LockOptions opts)
 {
     if (opts == null)
     {
         throw new ArgumentNullException(nameof(opts));
     }
     return(new Lock(this)
     {
         Opts = opts
     });
 }
Example #4
0
        /// <summary>
        /// AcquireLock creates a lock that is already acquired when this call returns.
        /// </summary>
        /// <param name="opts"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        public async Task <IDistributedLock> AcquireLock(LockOptions opts, CancellationToken ct = default(CancellationToken))
        {
            if (opts == null)
            {
                throw new ArgumentNullException(nameof(opts));
            }

            var l = CreateLock(opts);
            await l.Acquire(ct).ConfigureAwait(false);

            return(l);
        }