public void Commit(Enlistment enlistment)
{
if (_transaction != null && !_transaction.IsUpdated)
{
_transaction.Commit();
_transaction = null;
if (Completed != null)
{
Completed(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();
}
}
static FbConnectionInternal CreateNewConnection(FbConnectionString connectionString)
{
var result = new FbConnectionInternal(connectionString);
result.Connect();
return(result);
}
public void CheckIn(FbConnectionInternal connection)
{
connection.OwningConnection = null;
connection.Created = System.DateTime.Now.Ticks;
this.MoveConnection(connection, MoveType.LockedToUnlocked);
}
protected override void Dispose(bool disposing)
{
lock (this)
{
if (!this.disposed)
{
try
{
// release any unmanaged resources
this.Close();
if (disposing)
{
// release any managed resources
this.innerConnection = null;
this.options = null;
this.connectionString = null;
}
this.disposed = true;
}
catch
{
}
finally
{
base.Dispose(disposing);
}
}
}
}
public FbEnlistmentNotification(FbConnectionInternal connection, Transaction systemTransaction)
{
_connection = connection;
_transaction = connection.BeginTransaction(systemTransaction.IsolationLevel);
_systemTransaction = systemTransaction;
_systemTransaction.EnlistVolatile(this, System.Transactions.EnlistmentOptions.None);
}
public FbEnlistmentNotification(FbConnectionInternal connection, Transaction systemTransaction)
{
this.connection = connection;
this.transaction = connection.BeginTransaction(systemTransaction.IsolationLevel);
this.systemTransaction = systemTransaction;
this.systemTransaction.EnlistVolatile(this, System.Transactions.EnlistmentOptions.None);
}
public FbEnlistmentNotification(FbConnectionInternal connection, Transaction systemTransaction)
{
_connection = connection;
_transaction = connection.BeginTransaction(systemTransaction.IsolationLevel, new AsyncWrappingCommonArgs(false)).GetAwaiter().GetResult();
_systemTransaction = systemTransaction;
_systemTransaction.EnlistVolatile(this, EnlistmentOptions.None);
}
static FbConnectionInternal CreateNewConnection(FbConnectionString connectionString, FbConnection owner)
{
var result = new FbConnectionInternal(connectionString);
result.SetOwningConnection(owner);
result.Connect();
return(result);
}
public override void Close()
{
if (!this.IsClosed && this.innerConnection != null)
{
lock (this)
{
try
{
lock (this.innerConnection)
{
// Close the Remote Event Manager
this.innerConnection.CloseEventManager();
// Unbind Warning messages event
if (this.innerConnection.Database != null)
{
this.innerConnection.Database.WarningMessage = null;
}
// Dispose Transaction
this.innerConnection.DisposeTransaction();
// Dispose all active statemenets
this.innerConnection.ReleasePreparedCommands();
// Close connection or send it back to the pool
if (this.innerConnection.Pooled)
{
if (this.innerConnection.CancelDisabled)
{
// Enable fb_cancel_operation if going into pool
this.innerConnection.EnableCancel();
}
// Send connection to the Pool
FbPoolManager.Instance.GetPool(this.connectionString).CheckIn(this.innerConnection);
}
else
{
if (!this.innerConnection.IsEnlisted)
{
this.innerConnection.Dispose();
}
this.innerConnection = null;
}
}
}
catch
{
}
finally
{
// Update connection state
this.OnStateChange(this.state, ConnectionState.Closed);
}
}
}
}
public void Dispose()
{
if (_disposed)
return;
_disposed = true;
Created = default(DateTimeOffset);
Connection.Dispose();
Connection = null;
}
public FbRemoteEvent(string connectionString)
{
_connection = new FbConnectionInternal(new FbConnectionString(connectionString));
_connection.Connect();
_revent = new RemoteEvent(_connection.Database);
_revent.EventCountsCallback = OnRemoteEventCounts;
_revent.EventErrorCallback = OnRemoteEventError;
_synchronizationContext = SynchronizationContext.Current ?? new SynchronizationContext();
}
internal void Release(FbConnectionInternal connection, bool returnToAvailable)
{
CheckDisposed();
if (_pools.TryGetValue(connection.Options.NormalizedConnectionString, out var pool))
{
pool.ReleaseConnection(connection, returnToAvailable);
}
}
private FbConnectionInternal GetConnection()
{
FbConnectionInternal result = null;
long check = -1;
lock (this.unlocked.SyncRoot)
{
FbConnectionInternal[] connections = (FbConnectionInternal[])this.unlocked.ToArray(typeof(FbConnectionInternal));
for (int i = connections.Length - 1; i >= 0; i--)
{
if (connections[i].Verify())
{
if (this.lifeTime != 0)
{
long now = DateTime.Now.Ticks;
long expire = connections[i].Created + this.lifeTime;
if (now >= expire)
{
if (this.CheckMinPoolSize())
{
this.unlocked.Remove(connections[i]);
this.Expire(connections[i]);
}
}
else
{
if (expire > check)
{
check = expire;
result = connections[i];
}
}
}
else
{
result = connections[i];
break;
}
}
else
{
this.unlocked.Remove(connections[i]);
this.Expire(connections[i]);
}
}
if (result != null)
{
this.MoveConnection(result, MoveType.UnlockedToLocked);
}
}
return(result);
}
private FbConnectionInternal Create()
{
FbConnectionInternal connection = new FbConnectionInternal(this.options);
connection.Connect();
connection.Pooled = true;
connection.Created = DateTime.Now.Ticks;
return(connection);
}
public void Dispose()
{
if (_disposed)
{
return;
}
_disposed = true;
Created = default(long);
Connection.Dispose();
Connection = null;
}
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 void Dispose()
{
if (_disposed)
{
return;
}
_disposed = true;
Created = default(DateTimeOffset);
Connection.Dispose();
Connection = 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();
}
if (!_innerConnection.Database.ConnectionBroken)
{
FbConnectionPoolManager.Instance.Release(_innerConnection);
}
else
{
if (!_innerConnection.IsEnlisted)
{
_innerConnection.Dispose();
}
_innerConnection = null;
}
}
else
{
if (!_innerConnection.IsEnlisted)
{
_innerConnection.Dispose();
}
_innerConnection = null;
}
}
catch
{ }
finally
{
OnStateChange(_state, ConnectionState.Closed);
}
}
}
private async Task DisposeHelper(AsyncWrappingCommonArgs async)
{
if (!_disposed)
{
_disposed = true;
await CloseImpl(async).ConfigureAwait(false);
_innerConnection = null;
_options = null;
_connectionString = null;
}
}
internal async Task CloseImpl(AsyncWrappingCommonArgs async)
{
if (!IsClosed && _innerConnection != null)
{
try
{
await _innerConnection.CloseEventManager(async).ConfigureAwait(false);
if (_innerConnection.Database != null)
{
_innerConnection.Database.WarningMessage = null;
}
await _innerConnection.DisposeTransaction(async).ConfigureAwait(false);
await _innerConnection.ReleasePreparedCommands(async).ConfigureAwait(false);
if (_options.Pooling)
{
if (_innerConnection.CancelDisabled)
{
await _innerConnection.EnableCancel(async).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.Disconnect(async).ConfigureAwait(false);
}
_innerConnection = null;
}
}
private void Expire(FbConnectionInternal connection)
{
try
{
connection.Dispose();
connection = null;
}
catch (Exception)
{
// Do not raise an exception as the connection could be invalid due to several reasons
// ( network problems, server shutdown, ... )
}
}
public void ReleaseConnection(FbConnectionInternal connection)
{
lock (_syncRoot)
{
CheckDisposedImpl();
var removed = _busy.Remove(connection);
if (removed)
{
_available.Enqueue(new Item(DateTimeOffset.UtcNow, connection));
}
}
}
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)
{
lock (_syncRoot)
{
CheckDisposedImpl();
var removed = _busy.Remove(connection);
if (removed)
{
_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 void DropDatabase(string connectionString)
{
FbConnectionString options = new FbConnectionString(connectionString);
options.Validate();
try
{
FbConnectionInternal db = new FbConnectionInternal(options);
db.DropDatabase();
}
catch (IscException ex)
{
throw new FbException(ex.Message, ex);
}
}
private static void CreateDatabaseImpl(string connectionString, int pageSize = 4096, bool forcedWrites = true, bool overwrite = false)
{
FbConnectionString options = new FbConnectionString(connectionString);
options.Validate();
try
{
DatabaseParameterBuffer dpb = new DatabaseParameterBuffer();
dpb.Append(IscCodes.isc_dpb_version1);
dpb.Append(IscCodes.isc_dpb_dummy_packet_interval, new byte[] { 120, 10, 0, 0 });
dpb.Append(IscCodes.isc_dpb_sql_dialect, new byte[] { options.Dialect, 0, 0, 0 });
if (!string.IsNullOrEmpty(options.UserID))
{
dpb.Append(IscCodes.isc_dpb_user_name, options.UserID);
}
if (options.Charset.Length > 0)
{
Charset charset = Charset.GetCharset(options.Charset);
if (charset == null)
{
throw new ArgumentException("Character set is not valid.");
}
else
{
dpb.Append(IscCodes.isc_dpb_set_db_charset, charset.Name);
}
}
dpb.Append(IscCodes.isc_dpb_force_write, (short)(forcedWrites ? 1 : 0));
dpb.Append(IscCodes.isc_dpb_overwrite, (overwrite ? 1 : 0));
if (pageSize > 0)
{
dpb.Append(IscCodes.isc_dpb_page_size, pageSize);
}
using (FbConnectionInternal db = new FbConnectionInternal(options))
{
db.CreateDatabase(dpb);
}
}
catch (IscException ex)
{
throw new FbException(ex.Message, ex);
}
}
public static void CreateDatabase(string connectionString, int pageSize = 4096, bool forcedWrites = true, bool overwrite = false)
{
var options = new ConnectionString(connectionString);
options.Validate();
try
{
using (var db = new FbConnectionInternal(options))
{
db.CreateDatabase(pageSize, forcedWrites, overwrite);
}
}
catch (IscException ex)
{
throw new FbException(ex.Message, ex);
}
}
private void MoveConnection(FbConnectionInternal connection, MoveType moveType)
{
if (connection != null)
{
lock (this.unlocked.SyncRoot)
{
switch (moveType)
{
case MoveType.LockedToUnlocked:
this.locked.Remove(connection);
this.unlocked.Add(connection);
break;
case MoveType.UnlockedToLocked:
this.unlocked.Remove(connection);
this.locked.Add(connection);
break;
}
}
}
}
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 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 void Rollback(Enlistment enlistment)
{
if (_transaction != null && !_transaction.IsCompleted)
{
_transaction.Rollback();
_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 override void Close()
{
if (!this.IsClosed && this.innerConnection != null)
{
lock (this)
{
try
{
lock (this.innerConnection)
{
// Close the Remote Event Manager
this.innerConnection.CloseEventManager();
// Unbind Warning messages event
if (this.innerConnection.Database != null)
{
this.innerConnection.Database.WarningMessage = null;
}
// Dispose Transaction
this.innerConnection.DisposeTransaction();
// Dispose all active statemenets
this.innerConnection.ReleasePreparedCommands();
// Close connection or send it back to the pool
if (this.innerConnection.Pooled)
{
if (this.innerConnection.CancelDisabled)
{
// Enable fb_cancel_operation if going into pool
this.innerConnection.EnableCancel();
}
// Send connection to the Pool
FbPoolManager.Instance.GetPool(this.connectionString).CheckIn(this.innerConnection);
}
else
{
if (!this.innerConnection.IsEnlisted)
{
this.innerConnection.Dispose();
}
this.innerConnection = null;
}
}
}
catch
{
}
finally
{
// Update connection state
this.OnStateChange(this.state, ConnectionState.Closed);
}
}
}
}
public override void Open()
{
lock (this)
{
if (string.IsNullOrEmpty(this.connectionString))
{
throw new InvalidOperationException("Connection String is not initialized.");
}
if (!this.IsClosed && this.state != ConnectionState.Connecting)
{
throw new InvalidOperationException("Connection already Open.");
}
#if (!NET_CF)
if (this.options.Enlist && System.Transactions.Transaction.Current == null)
{
throw new InvalidOperationException("There is no active TransactionScope to enlist transactions.");
}
#endif
this.DemandPermission();
try
{
this.OnStateChange(this.state, ConnectionState.Connecting);
if (this.options.Pooling)
{
this.innerConnection = FbPoolManager.Instance.GetPool(this.connectionString).CheckOut();
this.innerConnection.OwningConnection = this;
}
else
{
// Do not use Connection Pooling
this.innerConnection = new FbConnectionInternal(this.options, this);
this.innerConnection.Connect();
}
#if (!NET_CF)
try
{
this.innerConnection.EnlistTransaction(System.Transactions.Transaction.Current);
}
catch
{
// if enlistment fails clean up innerConnection
this.innerConnection.DisposeTransaction();
if (this.innerConnection.Pooled)
{
// Send connection return back to the Pool
FbPoolManager.Instance.GetPool(this.connectionString).CheckIn(this.innerConnection);
}
else
{
this.innerConnection.Dispose();
this.innerConnection = null;
}
throw;
}
#endif
// Bind Warning messages event
this.innerConnection.Database.WarningMessage = new WarningMessageCallback(this.OnWarningMessage);
// Update the connection state
this.OnStateChange(this.state, ConnectionState.Open);
}
catch (IscException ex)
{
this.OnStateChange(this.state, ConnectionState.Closed);
throw new FbException(ex.Message, ex);
}
catch
{
this.OnStateChange(this.state, ConnectionState.Closed);
throw;
}
}
}
protected override void Dispose(bool disposing)
{
lock (this)
{
if (!this.disposed)
{
try
{
// release any unmanaged resources
this.Close();
if (disposing)
{
// release any managed resources
this.innerConnection = null;
this.options = null;
this.connectionString = null;
}
this.disposed = true;
}
catch
{
}
finally
{
base.Dispose(disposing);
}
}
}
}
public static void DropDatabase(string connectionString)
{
// Configure Attachment
FbConnectionString options = new FbConnectionString(connectionString);
options.Validate();
try
{
// Drop the database
FbConnectionInternal db = new FbConnectionInternal(options);
db.DropDatabase();
}
catch (IscException ex)
{
throw new FbException(ex.Message, ex);
}
}
public void Commit(Enlistment enlistment)
{
if (this.transaction != null && !this.transaction.IsUpdated)
{
this.transaction.Commit();
this.transaction = null;
if (this.Completed != null)
{
this.Completed(this, new EventArgs());
}
if (this.connection != null)
{
if (!this.connection.Pooled && (this.connection.OwningConnection == null || this.connection.OwningConnection.IsClosed))
{
this.connection.Disconnect();
}
}
this.connection = null;
this.systemTransaction = null;
// Declare done on the enlistment
enlistment.Done();
}
}
public override void Open()
{
lock (this)
{
if (string.IsNullOrEmpty(_connectionString))
{
throw new InvalidOperationException("Connection String is not initialized.");
}
if (!IsClosed && _state != ConnectionState.Connecting)
{
throw new InvalidOperationException("Connection already Open.");
}
if (_options.Enlist && System.Transactions.Transaction.Current == null)
{
throw new InvalidOperationException("There is no active TransactionScope to enlist transactions.");
}
DemandPermission();
try
{
OnStateChange(_state, ConnectionState.Connecting);
if (_options.Pooling)
{
_innerConnection = FbConnectionPoolManager.Instance.Get(_options, this);
}
else
{
// Do not use Connection Pooling
_innerConnection = new FbConnectionInternal(_options);
_innerConnection.SetOwningConnection(this);
_innerConnection.Connect();
}
try
{
_innerConnection.EnlistTransaction(System.Transactions.Transaction.Current);
}
catch
{
// if enlistment fails clean up innerConnection
_innerConnection.DisposeTransaction();
if (_options.Pooling)
{
// Send connection return back to the Pool
FbConnectionPoolManager.Instance.Release(_innerConnection);
}
else
{
_innerConnection.Dispose();
_innerConnection = null;
}
throw;
}
// Bind Warning messages event
_innerConnection.Database.WarningMessage = new WarningMessageCallback(OnWarningMessage);
// Update the connection state
OnStateChange(_state, ConnectionState.Open);
}
catch (IscException ex)
{
OnStateChange(_state, ConnectionState.Closed);
throw new FbException(ex.Message, ex);
}
catch
{
OnStateChange(_state, ConnectionState.Closed);
throw;
}
}
}
public void Commit(Enlistment enlistment)
{
if (_transaction != null && !_transaction.IsUpdated)
{
_transaction.Commit();
_transaction = null;
if (Completed != null)
{
Completed(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();
}
}
private void Expire(FbConnectionInternal connection)
{
try
{
connection.Dispose();
connection = null;
}
catch
{
// Do not raise an exception as the connection could be invalid due to several reasons
// ( network problems, server shutdown, ... )
}
}
private FbConnectionInternal Create()
{
FbConnectionInternal connection = new FbConnectionInternal(this.options);
connection.Connect();
connection.Pooled = true;
connection.Created = DateTime.Now.Ticks;
return connection;
}
static FbConnectionInternal CreateNewConnection(FbConnectionString connectionString, FbConnection owner)
{
var result = new FbConnectionInternal(connectionString);
result.SetOwningConnection(owner);
result.Connect();
return result;
}
static FbConnectionInternal CreateNewConnection(FbConnectionString connectionString)
{
var result = new FbConnectionInternal(connectionString);
result.Connect();
return result;
}
internal void Release(FbConnectionInternal connection)
{
CheckDisposed();
_pools.GetOrAdd(connection.Options.NormalizedConnectionString, _ => new Pool(connection.Options)).ReleaseConnection(connection);
}
public static void CreateDatabase(string connectionString, int pageSize, bool forcedWrites, bool overwrite)
{
FbConnectionString options = new FbConnectionString(connectionString);
options.Validate();
try
{
// DPB configuration
DatabaseParameterBuffer dpb = new DatabaseParameterBuffer();
// Dpb version
dpb.Append(IscCodes.isc_dpb_version1);
// Dummy packet interval
dpb.Append(IscCodes.isc_dpb_dummy_packet_interval, new byte[] { 120, 10, 0, 0 });
// User name
dpb.Append(IscCodes.isc_dpb_user_name, options.UserID);
// User password
dpb.Append(IscCodes.isc_dpb_password, options.Password);
// Database dialect
dpb.Append(IscCodes.isc_dpb_sql_dialect, new byte[] { options.Dialect, 0, 0, 0 });
// Character set
if (options.Charset.Length > 0)
{
Charset charset = Charset.GetCharset(options.Charset);
if (charset == null)
{
throw new ArgumentException("Character set is not valid.");
}
else
{
dpb.Append(IscCodes.isc_dpb_set_db_charset, charset.Name);
}
}
// Forced writes
dpb.Append(IscCodes.isc_dpb_force_write, (short)(forcedWrites ? 1 : 0));
// Database overwrite
dpb.Append(IscCodes.isc_dpb_overwrite, (overwrite ? 1 : 0));
// Page Size
if (pageSize > 0)
{
dpb.Append(IscCodes.isc_dpb_page_size, pageSize);
}
// Create the new database
FbConnectionInternal db = new FbConnectionInternal(options);
db.CreateDatabase(dpb);
}
catch (IscException ex)
{
throw new FbException(ex.Message, ex);
}
}
private void MoveConnection(FbConnectionInternal connection, MoveType moveType)
{
if (connection != null)
{
lock (this.unlocked.SyncRoot)
{
switch (moveType)
{
case MoveType.LockedToUnlocked:
this.locked.Remove(connection);
this.unlocked.Add(connection);
break;
case MoveType.UnlockedToLocked:
this.unlocked.Remove(connection);
this.locked.Add(connection);
break;
}
}
}
}
public void ReleaseConnection(FbConnectionInternal connection)
{
lock (_syncRoot)
{
CheckDisposedImpl();
var removed = _busy.Remove(connection);
if (removed)
_available.Enqueue(new Item(DateTimeOffset.UtcNow, connection));
}
}
public void ReleaseConnection(FbConnectionInternal connection)
{
lock (_syncRoot)
{
CheckDisposedImpl();
var removed = _busy.Remove(connection);
if (removed && _available.Count < _connectionString.MaxPoolSize)
{
_available.Push(new Item(DateTimeOffset.UtcNow, connection));
}
else
{
connection.Dispose();
}
}
}
public void CheckIn(FbConnectionInternal connection)
{
connection.OwningConnection = null;
connection.Created = System.DateTime.Now.Ticks;
this.MoveConnection(connection, MoveType.LockedToUnlocked);
}
public Item(DateTimeOffset created, FbConnectionInternal connection)
: this()
{
Created = created;
Connection = connection;
}
