Cacher is the code snippet organizer for pro developers

    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());
        }
    }