public FbEnlistmentNotification(FbConnectionInternal connection, Transaction systemTransaction)
{
_connection = connection;
_transaction = connection.BeginTransaction(systemTransaction.IsolationLevel);
_systemTransaction = systemTransaction;
_systemTransaction.EnlistVolatile(this, EnlistmentOptions.None);
}
internal void Release(FbConnectionInternal connection, bool returnToAvailable)
{
CheckDisposed();
if (_pools.TryGetValue(connection.Options.NormalizedConnectionString, out var pool))
{
pool.ReleaseConnection(connection, returnToAvailable);
}
}
public override async Task CloseAsync()
#endif
{
if (!IsClosed && _innerConnection != null)
{
try
{
await _innerConnection.CloseEventManagerAsync(CancellationToken.None).ConfigureAwait(false);
if (_innerConnection.Database != null)
{
_innerConnection.Database.WarningMessage = null;
}
await _innerConnection.DisposeTransactionAsync(CancellationToken.None).ConfigureAwait(false);
await _innerConnection.ReleasePreparedCommandsAsync(CancellationToken.None).ConfigureAwait(false);
if (_options.Pooling)
{
if (_innerConnection.CancelDisabled)
{
await _innerConnection.EnableCancelAsync(CancellationToken.None).ConfigureAwait(false);
}
var broken = _innerConnection.Database.ConnectionBroken;
FbConnectionPoolManager.Instance.Release(_innerConnection, !broken);
if (broken)
{
await DisconnectEnlistedHelper().ConfigureAwait(false);
}
}
else
{
await DisconnectEnlistedHelper().ConfigureAwait(false);
}
}
catch
{ }
finally
{
OnStateChange(_state, ConnectionState.Closed);
}
}
async Task DisconnectEnlistedHelper()
{
if (!_innerConnection.IsEnlisted)
{
await _innerConnection.DisconnectAsync(CancellationToken.None).ConfigureAwait(false);
}
_innerConnection = null;
}
}
public override void Close()
{
if (!IsClosed && _innerConnection != null)
{
try
{
_innerConnection.CloseEventManager();
if (_innerConnection.Database != null)
{
_innerConnection.Database.WarningMessage = null;
}
_innerConnection.DisposeTransaction();
_innerConnection.ReleasePreparedCommands();
if (_options.Pooling)
{
if (_innerConnection.CancelDisabled)
{
_innerConnection.EnableCancel();
}
var broken = _innerConnection.Database.ConnectionBroken;
FbConnectionPoolManager.Instance.Release(_innerConnection, !broken);
if (broken)
{
DisconnectEnlistedHelper();
}
}
else
{
DisconnectEnlistedHelper();
}
}
catch
{ }
finally
{
OnStateChange(_state, ConnectionState.Closed);
}
}
void DisconnectEnlistedHelper()
{
if (!_innerConnection.IsEnlisted)
{
_innerConnection.Disconnect();
}
_innerConnection = null;
}
}
public override async ValueTask DisposeAsync()
{
if (!_disposed)
{
_disposed = true;
await CloseAsync().ConfigureAwait(false);
_innerConnection = null;
_options = null;
_connectionString = null;
}
await base.DisposeAsync().ConfigureAwait(false);
}
public void ReleaseConnection(FbConnectionInternal connection, bool returnToAvailable)
{
lock (_syncRoot)
{
CheckDisposedImpl();
var removed = _busy.Remove(connection);
if (removed && returnToAvailable)
{
_available.Push(new Item(GetTicks(), connection));
}
}
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (!_disposed)
{
_disposed = true;
Close();
_innerConnection = null;
_options = null;
_connectionString = null;
}
}
base.Dispose(disposing);
}
public static async Task CreateDatabaseAsync(string connectionString, int pageSize = 4096, bool forcedWrites = true, bool overwrite = false, CancellationToken cancellationToken = default)
{
var options = new ConnectionString(connectionString);
options.Validate();
try
{
var db = new FbConnectionInternal(options);
try
{
await db.CreateDatabaseAsync(pageSize, forcedWrites, overwrite, cancellationToken).ConfigureAwait(false);
}
finally
{
await db.DisconnectAsync(cancellationToken).ConfigureAwait(false);
}
}
catch (IscException ex)
{
throw FbException.Create(ex);
}
}
public static void CreateDatabase(string connectionString, int pageSize = 4096, bool forcedWrites = true, bool overwrite = false)
{
var options = new ConnectionString(connectionString);
options.Validate();
try
{
var db = new FbConnectionInternal(options);
try
{
db.CreateDatabase(pageSize, forcedWrites, overwrite);
}
finally
{
db.Disconnect();
}
}
catch (IscException ex)
{
throw FbException.Create(ex);
}
}
public static async Task DropDatabaseAsync(string connectionString, CancellationToken cancellationToken = default)
{
var options = new ConnectionString(connectionString);
options.Validate();
try
{
var db = new FbConnectionInternal(options);
try
{
await db.DropDatabaseAsync(cancellationToken).ConfigureAwait(false);
}
finally
{
await db.DisconnectAsync(cancellationToken).ConfigureAwait(false);
}
}
catch (IscException ex)
{
throw FbException.Create(ex);
}
}
public static void DropDatabase(string connectionString)
{
var options = new ConnectionString(connectionString);
options.Validate();
try
{
var db = new FbConnectionInternal(options);
try
{
db.DropDatabase();
}
finally
{
db.Disconnect();
}
}
catch (IscException ex)
{
throw FbException.Create(ex);
}
}
public void Commit(Enlistment enlistment)
{
if (_transaction != null && !_transaction.IsCompleted)
{
_transaction.Commit();
_transaction = null;
Completed?.Invoke(this, new EventArgs());
if (_connection != null)
{
if (!_connection.Options.Pooling && (_connection.OwningConnection == null || _connection.OwningConnection.IsClosed))
{
_connection.Disconnect();
}
}
_connection = null;
_systemTransaction = null;
// Declare done on the enlistment
enlistment.Done();
}
}
public FbRemoteEvent(string connectionString)
{
_connection = new FbConnectionInternal(new ConnectionString(connectionString));
}
public override async Task OpenAsync(CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(_connectionString))
{
throw new InvalidOperationException("Connection String is not initialized.");
}
if (!IsClosed && _state != ConnectionState.Connecting)
{
throw new InvalidOperationException("Connection already Open.");
}
try
{
OnStateChange(_state, ConnectionState.Connecting);
var createdNew = default(bool);
if (_options.Pooling)
{
_innerConnection = FbConnectionPoolManager.Instance.Get(_options, out createdNew);
}
else
{
_innerConnection = new FbConnectionInternal(_options);
createdNew = true;
}
if (createdNew)
{
try
{
await _innerConnection.ConnectAsync(cancellationToken).ConfigureAwait(false);
}
catch (OperationCanceledException ex)
{
cancellationToken.ThrowIfCancellationRequested();
throw new TimeoutException("Timeout while connecting.", ex);
}
catch
{
if (_options.Pooling)
{
FbConnectionPoolManager.Instance.Release(_innerConnection, false);
}
throw;
}
}
_innerConnection.SetOwningConnection(this);
if (_options.Enlist)
{
try
{
EnlistTransaction(System.Transactions.Transaction.Current);
}
catch
{
// if enlistment fails clean up innerConnection
await _innerConnection.DisposeTransactionAsync(cancellationToken).ConfigureAwait(false);
if (_options.Pooling)
{
FbConnectionPoolManager.Instance.Release(_innerConnection, true);
}
else
{
await _innerConnection.DisconnectAsync(cancellationToken).ConfigureAwait(false);
_innerConnection = null;
}
throw;
}
}
// Bind Warning messages event
_innerConnection.Database.WarningMessage = OnWarningMessage;
// Update the connection state
OnStateChange(_state, ConnectionState.Open);
}
catch (IscException ex)
{
OnStateChange(_state, ConnectionState.Closed);
throw FbException.Create(ex);
}
catch
{
OnStateChange(_state, ConnectionState.Closed);
throw;
}
}
public Item(long created, FbConnectionInternal connection)
{
Created = created;
Connection = connection;
}
