/// <summary>
/// Creates a new connection. If this is the first connection, it also creates an extra
/// "Keep Alive" connection to keep the database open.
/// If <paramref name="usePooledConnection"/> is true, than if this connection has been opened before,
/// the connection from the pool will be returned rather than creating a new one.
/// </summary>
/// <param name="db">The database instance that will be used to create a connection.</param>
/// <param name="usePooledConnection">If true, return an already created connection for this object. If
/// false, always create a new one.</param>
/// <returns>A new connection.</returns>
public static DatabaseConnectionWrapper CreateConnection(SqlCeDatabase db, bool usePooledConnection)
{
string connectionString = db.ConnectionStringWithoutCredentials;
DatabaseConnectionWrapper connection;
lock (connections)
{
if (!connections.TryGetValue(connectionString, out connection))
{
//
// We have to test this again in case another thread added a connection.
//
if (!connections.ContainsKey(connectionString))
{
DbConnection keepAliveConnection = new SqlCeConnection();
db.SetConnectionString(keepAliveConnection);
keepAliveConnection.Open();
connection = new DatabaseConnectionWrapper(keepAliveConnection);
connections.Add(connectionString, connection);
}
}
if (usePooledConnection)
{
connection.AddRef();
return connection;
}
return new DatabaseConnectionWrapper(new SqlCeConnection());
}
}
public void CannotGetCommandForStoredProcedure()
{
TestConnectionString testConnection = new TestConnectionString();
testConnection.CopyFile();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
db.GetStoredProcCommand("CustOrdersOrders");
}
/// <summary>
/// Creates a new connection. If this is the first connection, it also creates an extra
/// "Keep Alive" connection to keep the database open.
/// If <paramref name="usePooledConnection"/> is true, than if this connection has been opened before,
/// the connection from the pool will be returned rather than creating a new one.
/// </summary>
/// <param name="db">The database instance that will be used to create a connection.</param>
/// <param name="usePooledConnection">If true, return an already created connection for this object. If
/// false, always create a new one.</param>
/// <returns>A new connection.</returns>
public static DatabaseConnectionWrapper CreateConnection(SqlCeDatabase db, bool usePooledConnection)
{
string connectionString = db.ConnectionStringWithoutCredentials;
DatabaseConnectionWrapper connection;
lock (connections)
{
if (!connections.TryGetValue(connectionString, out connection))
{
//
// We have to test this again in case another thread added a connection.
//
if (!connections.ContainsKey(connectionString))
{
DbConnection keepAliveConnection = new SqlCeConnection();
db.SetConnectionString(keepAliveConnection);
keepAliveConnection.Open();
connection = new DatabaseConnectionWrapper(keepAliveConnection);
connections.Add(connectionString, connection);
}
}
if (usePooledConnection)
{
connection.AddRef();
return(connection);
}
return(new DatabaseConnectionWrapper(new SqlCeConnection()));
}
}
public void SetUp()
{
testConnection = new TestConnectionString();
testConnection.CopyFile();
db = new SqlCeDatabase(testConnection.ConnectionString);
DbCommand command = db.GetSqlStringCommand("Select count(*) from region");
baseFixture = new ExecuteScalarFixture(db, command);
}
public void ConnectionShouldRemainInPoolAfterReturnedConnectionDisposed()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db)) {}
DatabaseConnectionWrapper keepAlive = TestableSqlCeConnectionPool.GetConnection(0);
Assert.AreEqual(ConnectionState.Open, keepAlive.Connection.State);
}
public void GetConnectionAddsConnectionToPool()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db))
{
Assert.IsNotNull(connection);
Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize);
}
}
public void GetConnectionOpensConnectionInPool()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db))
{
DatabaseConnectionWrapper keepAlive = TestableSqlCeConnectionPool.GetConnection(0);
Assert.AreEqual(ConnectionState.Open, keepAlive.Connection.State);
}
}
public void CloseSharedConnectionsShouldClearPool()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db)) {}
Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize);
SqlCeConnectionPool.CloseSharedConnections();
Assert.AreEqual(0, TestableSqlCeConnectionPool.PoolSize);
}
public static DbConnection CreateConnection(SqlCeDatabase db)
{
string connectionString = db.ConnectionStringWithoutCredentials;
if (!connections.ContainsKey(connectionString))
{
lock (connections)
{
if (!connections.ContainsKey(connectionString))
{
DbConnection keepAliveConnection = new SqlCeConnection();
db.SetConnectionString(keepAliveConnection);
keepAliveConnection.Open();
connections.Add(connectionString, keepAliveConnection);
}
}
}
return(new SqlCeConnection());
}
/// <summary>
/// Creates a new connection. If this is the first connection, it also creates an extra
/// "Keep Alive" connection to keep the database open.
/// </summary>
/// <param name="db">The database instance that will be used to create a connection.</param>
/// <returns>A new connection.</returns>
internal static DbConnection CreateConnection(SqlCeDatabase db)
{
string connectionString = db.ConnectionStringWithoutCredentials;
if (!connections.ContainsKey(connectionString))
{
lock (connections)
{
//
// We have to test this again in case another thread added a connection.
//
if (!connections.ContainsKey(connectionString))
{
DbConnection keepAliveConnection = new SqlCeConnection();
db.SetConnectionString(keepAliveConnection);
keepAliveConnection.Open();
connections.Add(connectionString, keepAliveConnection);
}
}
}
return new SqlCeConnection();
}
/// <summary>
/// Creates a new connection. If this is the first connection, it also creates an extra
/// "Keep Alive" connection to keep the database open.
/// </summary>
/// <param name="db">The database instance that will be used to create a connection.</param>
/// <returns>A new connection.</returns>
internal static DbConnection CreateConnection(SqlCeDatabase db)
{
string connectionString = db.ConnectionStringWithoutCredentials;
if (!connections.ContainsKey(connectionString))
{
lock (connections)
{
//
// We have to test this again in case another thread added a connection.
//
if (!connections.ContainsKey(connectionString))
{
DbConnection keepAliveConnection = new SqlCeConnection();
db.SetConnectionString(keepAliveConnection);
keepAliveConnection.Open();
connections.Add(connectionString, keepAliveConnection);
}
}
}
return(new SqlCeConnection());
}
/// <summary>
/// Creates a new connection. If this is the first connection, it also creates an extra
/// "Keep Alive" connection to keep the database open. Always returns a new <see cref="SqlCeConnection"/>
/// object, not a pooled one.
/// </summary>
/// <param name="db">The database instance that will be used to create a connection.</param>
/// <returns>A new connection.</returns>
public static DatabaseConnectionWrapper CreateConnection(SqlCeDatabase db)
{
return(CreateConnection(db, false));
}
public void GetConnectionWithPoolingReturnsSameConnection()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DatabaseConnectionWrapper connection1 = SqlCeConnectionPool.CreateConnection(db, true))
{
using (DatabaseConnectionWrapper connection2 = SqlCeConnectionPool.CreateConnection(db, true))
{
Assert.AreSame(connection1, connection2);
Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize);
}
}
}
/// <summary>
/// Creates a new connection. If this is the first connection, it also creates an extra
/// "Keep Alive" connection to keep the database open. Always returns a new <see cref="SqlCeConnection"/>
/// object, not a pooled one.
/// </summary>
/// <param name="db">The database instance that will be used to create a connection.</param>
/// <returns>A new connection.</returns>
public static DatabaseConnectionWrapper CreateConnection(SqlCeDatabase db)
{
return CreateConnection(db, false);
}
public void GetConnectionReturnsDifferentConnectionThanOneInPool()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db))
{
DatabaseConnectionWrapper keepAlive = TestableSqlCeConnectionPool.GetConnection(0);
Assert.AreNotSame(connection, keepAlive);
}
}
public void CanCreateNewDatabaseFile()
{
string filename = Path.Combine(Environment.CurrentDirectory, "newfile.sdf");
string connectionString = "Data Source='{0}'";
connectionString = String.Format(connectionString, filename);
if (File.Exists(filename))
File.Delete(filename);
Assert.IsFalse(File.Exists(filename));
SqlCeDatabase database = new SqlCeDatabase(connectionString);
database.CreateFile();
Assert.IsTrue(File.Exists(filename));
File.Delete(filename);
}
public void SetUp()
{
testConnection = new TestConnectionString();
testConnection.CopyFile();
db = new SqlCeDatabase(testConnection.ConnectionString);
}
public void DatabaseShouldCloseSharedConnection()
{
TestConnectionString file = new TestConnectionString();
SqlCeDatabase database = new SqlCeDatabase(file.ConnectionString);
using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(database)) {}
Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize);
database.CloseSharedConnection();
Assert.AreEqual(0, TestableSqlCeConnectionPool.PoolSize);
}
public void CreateNewDatabaseThrowsWhenFileAlreadyExists()
{
TestConnectionString file = new TestConnectionString();
Assert.IsTrue(File.Exists(file.Filename));
SqlCeDatabase database = new SqlCeDatabase(file.ConnectionString);
database.CreateFile();
}
public void ShouldNotAddConnectionToPoolIfOpenFails()
{
SqlCeDatabase db = new SqlCeDatabase("Data Source='invalid.sdf'");
try
{
DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db);
}
catch (SqlCeException) {}
Assert.AreEqual(0, TestableSqlCeConnectionPool.PoolSize);
}
public void ExecuteSqlCreatesConnectionInPool()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
DbCommand command = db.GetSqlStringCommand("select count(*) from region");
Assert.AreEqual(0, TestableSqlCeConnectionPool.PoolSize);
int result = (int)db.ExecuteScalar(command);
Assert.AreEqual(4, result);
Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize);
}
public void GetConnectionForTwoFilesAddsTwoConnectionsToPool()
{
TestConnectionString file1 = new TestConnectionString();
TestConnectionString file2 = new TestConnectionString("test2.sdf");
file2.CopyFile();
SqlCeDatabase db1 = new SqlCeDatabase(file1.ConnectionString);
SqlCeDatabase db2 = new SqlCeDatabase(file2.ConnectionString);
using (DatabaseConnectionWrapper connection1 = SqlCeConnectionPool.CreateConnection(db1))
{
using (DatabaseConnectionWrapper connection2 = SqlCeConnectionPool.CreateConnection(db2)) {}
}
Assert.AreEqual(2, TestableSqlCeConnectionPool.PoolSize);
SqlCeConnectionPool.CloseSharedConnections();
file2.DeleteFile();
}
public void CanOpenSqlCeDatabase()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase database = new SqlCeDatabase(testConnection.ConnectionString);
using (DbConnection connection = database.CreateConnection())
{
connection.Open();
Assert.AreEqual(ConnectionState.Open, connection.State);
}
}
public void GetConnectionReturnsNewConnectionButHasOnlyOneInPool()
{
TestConnectionString testConnection = new TestConnectionString();
SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString);
using (DatabaseConnectionWrapper connection1 = SqlCeConnectionPool.CreateConnection(db))
{
using (DatabaseConnectionWrapper connection2 = SqlCeConnectionPool.CreateConnection(db))
{
Assert.AreNotSame(connection1, connection2);
Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize);
}
}
}
