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 = new SqlConnection(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 = new SqlConnection(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);
}
public IDisposable TryAcquire(int timeoutMillis, SqlApplicationLock.Mode mode, IDisposable contextHandle)
{
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, mode, contextHandle: lockScope.InternalHandle);
return(internalHandle != null
? new LockScope(internalHandle, lockScope.InternalLock, lockScope.Keepalive, ownsKeepalive: false)
: null);
}
finally
{
// always restart, even if the acquisition fails
lockScope.Keepalive.Start();
}
}
var connection = new SqlConnection(this.connectionString);
LockScope result = null;
try
{
connection.Open();
var internalLock = new ConnectionScopedSqlDistributedLock(this.lockName, connection);
var internalHandle = internalLock.TryAcquire(timeoutMillis, mode, contextHandle: null);
if (internalHandle != null)
{
var keepalive = new KeepaliveHelper(connection);
keepalive.Start();
result = new LockScope(internalHandle, internalLock, keepalive, ownsKeepalive: true);
}
}
finally
{
if (result == null)
{
connection.Dispose();
}
}
return(result);
}