public async Task <IDisposable?> TryAcquireAsync <TLockCookie>(int timeoutMillis, ISqlSynchronizationStrategy <TLockCookie> strategy, CancellationToken cancellationToken, IDisposable?contextHandle) where TLockCookie : class { if (contextHandle != null) { return(await this.CreateContextLock <TLockCookie>(contextHandle).TryAcquireAsync(timeoutMillis, strategy, cancellationToken, contextHandle: null).ConfigureAwait(false)); } IDisposable?result = null; var connection = SqlHelpers.CreateConnection(this.connectionString); try { await connection.OpenAsync(cancellationToken).ConfigureAwait(false); var lockCookie = await strategy.TryAcquireAsync(connection, this.lockName, timeoutMillis, cancellationToken).ConfigureAwait(false); if (lockCookie != null) { result = new LockScope <TLockCookie>(connection, strategy, this.lockName, lockCookie); } } finally { // if we fail to acquire or throw, make sure to clean up the connection if (result == null) { connection.Dispose(); } } return(result); }
public IDisposable?TryAcquire <TLockCookie>(int timeoutMillis, ISqlSynchronizationStrategy <TLockCookie> strategy, IDisposable?contextHandle) where TLockCookie : class { if (contextHandle != null) { return(this.CreateContextLock <TLockCookie>(contextHandle).TryAcquire(timeoutMillis, strategy, contextHandle: null)); } IDisposable?result = null; var connection = SqlHelpers.CreateConnection(this.connectionString); try { connection.Open(); var lockCookie = strategy.TryAcquire(connection, this.lockName, timeoutMillis); if (lockCookie != null) { result = new LockScope <TLockCookie>(connection, strategy, this.lockName, lockCookie); } } finally { // if we fail to acquire or throw, make sure to clean up the connection if (result == null) { connection.Dispose(); } } return(result); }
public IDisposable?TryAcquire <TLockCookie>(int timeoutMillis, ISqlSynchronizationStrategy <TLockCookie> strategy, IDisposable?contextHandle) where TLockCookie : class { if (contextHandle != null) { return(this.CreateContextLock(contextHandle).TryAcquire(timeoutMillis, strategy, contextHandle: null)); } IDisposable? result = null; var connection = SqlHelpers.CreateConnection(this.connectionString); DbTransaction?transaction = null; try { connection.Open(); // when creating a transaction, the isolation level doesn't matter, since we're using sp_getapplock transaction = connection.BeginTransaction(); var lockCookie = strategy.TryAcquire(transaction, this.lockName, timeoutMillis); if (lockCookie != null) { result = new LockScope(transaction); } } finally { // if we fail to acquire or throw, make sure to clean up if (result == null) { transaction?.Dispose(); connection.Dispose(); } } return(result); }
public async Task <IDisposable?> TryAcquireAsync <TLockCookie>(int timeoutMillis, ISqlSynchronizationStrategy <TLockCookie> strategy, CancellationToken cancellationToken, IDisposable?contextHandle) where TLockCookie : class { if (contextHandle != null) { cancellationToken.ThrowIfCancellationRequested(); // if already canceled, exit immediately // if we are taking a nested lock, we don't want to start another keepalive on the same connection. // However, we do need to stop our current keepalive while we take the nested lock to avoid threading issues var lockScope = (LockScope)contextHandle; await lockScope.Keepalive !.StopAsync().ConfigureAwait(false); try { var internalHandle = await lockScope.InternalLock !.TryAcquireAsync(timeoutMillis, strategy, cancellationToken, contextHandle: lockScope.InternalHandle).ConfigureAwait(false); return(internalHandle != null ? new LockScope(internalHandle, lockScope.InternalLock, lockScope.Keepalive, connection: null) : null); } finally { // always restart, even if the acquisition fails lockScope.Keepalive.Start(); } } var connection = SqlHelpers.CreateConnection(this.connectionString); LockScope?result = null; try { await connection.OpenAsync(cancellationToken).ConfigureAwait(false); var internalLock = new ExternalConnectionOrTransactionSqlDistributedLock(this.lockName, connection); var internalHandle = await internalLock.TryAcquireAsync(timeoutMillis, strategy, cancellationToken, contextHandle : null).ConfigureAwait(false); if (internalHandle != null) { var keepalive = new KeepaliveHelper(connection); keepalive.Start(); result = new LockScope(internalHandle, internalLock, keepalive, connection); } } finally { if (result == null) { connection.Dispose(); } } return(result); }
public IDisposable?TryAcquire <TLockCookie>(int timeoutMillis, ISqlSynchronizationStrategy <TLockCookie> strategy, IDisposable?contextHandle) where TLockCookie : class { if (contextHandle != null) { // if we are taking a nested lock, we don't want to start another keepalive on the same connection. // However, we do need to stop our current keepalive while we take the nested lock to avoid threading issues var lockScope = (LockScope)contextHandle; lockScope.Keepalive !.Stop(); try { var internalHandle = lockScope.InternalLock !.TryAcquire(timeoutMillis, strategy, contextHandle: lockScope.InternalHandle); return(internalHandle != null ? new LockScope(internalHandle, lockScope.InternalLock, lockScope.Keepalive, connection: null) : null); } finally { // always restart, even if the acquisition fails lockScope.Keepalive.Start(); } } var connection = SqlHelpers.CreateConnection(this.connectionString); LockScope?result = null; try { connection.Open(); var internalLock = new ExternalConnectionOrTransactionSqlDistributedLock(this.lockName, connection); var internalHandle = internalLock.TryAcquire(timeoutMillis, strategy, contextHandle: null); if (internalHandle != null) { var keepalive = new KeepaliveHelper(connection); keepalive.Start(); result = new LockScope(internalHandle, internalLock, keepalive, connection); } } finally { if (result == null) { connection.Dispose(); } } return(result); }