ADO Exemplo
public interface IStorage<T>
{
T Get(string key, Func<T> builder);
void Remove(string key);
}
public abstract class InstanceStorage<T> : IStorage<T>
{
public abstract IDictionary Storage { get; }
public T Get(string key, Func<T> builder)
{
if (!Storage.Contains(key))
{
BuildInstance(key, builder);
}
return (T)Storage[key];
}
public void Remove(string key)
{
if (Storage.Contains(key))
{
Storage.Remove(key);
}
}
private void BuildInstance(string key, Func<T> builder)
{
if(!Storage.Contains(key)
{
lock(Storage.SyncRoot)
{
if(!Storage.Contains(key))
{
Storage.Add(key, builder.Invoke());
}
}
}
}
}
public class HttpInstanceStorage : InstanceStorage<IConnectionManager>
{
public override IDictionary Storage
{
get { return GetHttpContext().Items; }
}
private HttpContext GetHttpContext()
{
return HttpContext.Current;
}
}
public interface IConnectionStringProvider
{
string ConnectionString { get; }
string Provider { get; }
}
public class ConnectionStringProvider : IConnectionStringProvider
{
public string ConnectionString
{
get { throw new NotImplementedException(); }
}
public string Provider
{
get { throw new NotImplementedException(); }
}
}
public interface IConnectionManager
{
bool IsOpen { get; }
void BeginTransaction();
void Commit();
void Rollback();
}
public class ConnectionManager : IConnectionManager, IDisposable
{
private readonly IConnectionStringProvider _connectionString;
private IDbConnection _connection;
private IDbTransaction _transaction;
public ConnectionManager(IConnectionStringProvider connectionString)
{
_connectionString = connectionString;
Open();
}
public bool IsOpen
{
get { return _connection.State == ConnectionState.Open; }
}
public void BeginTransaction()
{
if (_transaction != null)
return;
_transaction = _connection.BeginTransaction();
}
public void Commit()
{
if (_transaction == null)
throw new NullReferenceException("Não existe transação ativa.");
_transaction.Commit();
}
public void Rollback()
{
if (_transaction == null)
throw new NullReferenceException("Não existe transação ativa.");
_transaction.Rollback();
}
private void Create()
{
_connection = GetProviderFactory()
.CreateConnection();
_connection.ConnectionString = _connectionString.ConnectionString;
}
private void Open()
{
Create();
if (_connection.State != ConnectionState.Open)
_connection.Open();
}
private DbProviderFactory GetProviderFactory()
{
return DbProviderFactories
.GetFactory(_connectionString.Provider);
}
public void Dispose()
{
if (_transaction != null)
{
_transaction.Commit();
}
_connection.Close();
_connection.Dispose();
}
}
public interface IConnectionBuilder
{
IConnectionManager Get();
}
public class ConnectionBuilder : IConnectionBuilder
{
private const string SESSION_MANAGER = "Session.Manager";
private readonly IStorage<IConnectionManager> storage;
public ConnectionBuilder()
{
storage = new InstanceStorage<IConnectionManager>();
}
public IConnectionManager Get()
{
var connection = GetInstance();
if (!connection.IsOpen)
{
storage.Remove(SESSION_MANAGER);
return GetInstance();
}
return connection;
}
private IConnectionManager GetInstance()
{
return storage.Get(SESSION_MANAGER, BuildConnection);
}
private IConnectionManager BuildConnection()
{
//Aqui seria legal usar um service locator para criar o ConnectionManager
return new ConnectionManager(
new ConnectionStringProvider());
}
}