Connection Pooling w/ Dependency Injection Use HTTP Request Scope or Not? - ado.net

Question

Note: I am not planning to use the Entity Framework as it does NOT support async queries.
I am unable to figure out which approach would be better for the following scenario with Dependency Injection and SQL Connection Pooling.
SQL Server Connection Pooling (ADO.NET) MSDN article recommends to use using (sqlConn) since I don't take a hit on connection.Open() and connection.Close() with Connection Pooling enabled.
Technique 1:
Inject a SqlConnection dependency into my CustomerRepository class.
Use an instance per HTTP Request for the SqlConnection.
Call connection.Open() before it is injected into the CustomerRepository class.
Technique 2:
Only inject the Connection String into my CustomerRepository class.
Initialize using (SqlConnection) blocks in each of my CRUD methods?
Additional Things to Consider
I will be using async calls with my SqlCommand.BeginExecuteReader() for some SQL queries that takes about 2-4 seconds to execute.
In some special scenarios, I need to run 2-or-more parallel SQL query calls as well.
Please also keep in mind how the two techniques affect the coding style for IDisposable and using (connection) stuff.
Questions
Are there any differences between the two approaches given the fact that Connection Pooling is enabled?
Which technique should I use and why?
Code Sample for Technique 1:
// ------------------------------------------------------------
// Autofac Dependency Injection setup
// ------------------------------------------------------------
ContainerBuilder builder = new ContainerBuilder();
builder.Register(
c => {
var conn = new SqlConnection( "connectionString" );
conn.Open(); // open the connection ahead of time before injecting it into my CustomerRepository
return conn;
})
.Named("myNamedConnection", typeof(SqlConnection))
.InstancePerHttpRequest();
builder.Register(
c => {
new CustomerRepository(c.ResolveNamed<SqlConnection>("myNamedConnection")))
})
.As<ICustomerRepository>();
// ------------------------------------------------------------
// CustomerRepository
// ------------------------------------------------------------
public class CustomerRepository : ICustomerRepository, IDisposable
{
private SqlConnection conn;
private bool disposed;
public CustomerRepository(SqlConnection connection)
{
conn = connection;
disposed = false;
}
public Customer GetById(int id)
{
using (var cmd = conn.CreateCommand())
{
// code to retrieve Customer by id
}
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
if (conn != null)
{
conn.Dispose();
conn = null;
}
}
disposed = true;
}
}
}
Code Sample for Technique 2:
// ------------------------------------------------------------
// CustomerRepository
// ------------------------------------------------------------
public class CustomerRepository : ICustomerRepository
{
private readonly string strConn;
public CustomerRepository(string strConnection) // strConnection has Connection Pooling enabled
{
strConn = strConnection;
}
public Customer GetById(int id)
{
using (var conn = new SqlConnection(this.strConn))
{
using (var cmd = conn.CreateCommand())
{
// code to retrieve Customer by id
}
}
}
}
Thanks in advance for any thoughtful inputs :-)

Answer 1

Don't go for technique 1. Leaving the connection open for the complete request is not adviced: it should be closed as soon as possible, so don't leave it open for the complete request.
Don't go for technique 2. Injecting a connection string in each and every repository is cumbersome and if you are doing that, it seems to me that you are missing an abstraction, in your code. You probably don't want every repository create a new SqlConnection by itself.
You might be better of by injecting an IDatabase abstraction of some sort into your repositories. You can inject the connection string in your IDatabase implementation. This abstraction can have a BeginExecuteReader method or perhaps even some higher level abstraction.