public SisoConnectionInfo(IConnectionString connectionString)
        {
            if(connectionString == null)
                throw new ArgumentNullException("connectionString");

            Initialize(connectionString);
        }

        private static string ConvertToConnectionString(IConnectionString connectionString)
        {
            var cnStringBuilder = new SqlCeConnectionStringBuilder(connectionString.PlainString);
            cnStringBuilder.Enlist = false;

            return connectionString.ReplacePlain(cnStringBuilder.ConnectionString).PlainString;
        }

		public IDbConnection OpenServerConnection(IConnectionString connectionString)
		{
			var cn = new SqlCeConnection(connectionString.PlainString);
			cn.Open();

			return cn;
		}

        protected override IConnectionString OnFormatConnectionString(IConnectionString connectionString)
        {
            var cnString = base.OnFormatConnectionString(connectionString);
            var cnStringBuilder = new SqlCeConnectionStringBuilder(cnString.PlainString) { Enlist = false };

            return connectionString.ReplacePlain(cnStringBuilder.ConnectionString);
        }

        protected override IConnectionString OnFormatServerConnectionString(IConnectionString connectionString)
        {
            var cnString = base.OnFormatServerConnectionString(connectionString);
            var cnStringBuilder = new SqlConnectionStringBuilder(cnString.PlainString) { InitialCatalog = string.Empty };

            return cnString.ReplacePlain(cnStringBuilder.ConnectionString);
        }

        public DatabaseFactory(IConnectionString connectionString, ILogWriter logWriter)
        {
            Checks.Argument.IsNotNull(connectionString, "connectionString");

            _connectionString = connectionString.Value;
            _logWriter = logWriter;
        }

 public NHibernateSessionSource(IEnumerable<IMappingConfiguration> mappingConfigurations,
                                IConnectionString connectionString)
 {
     _mappingConfigurations = mappingConfigurations;
     _connectionString = connectionString;
     _configuration = AssembleConfiguration(null);
     _sessionFactory = _configuration.BuildSessionFactory();
 }

        public Sql2008ConnectionInfo(IConnectionString connectionString) 
            : base(connectionString)
        {
            if (ProviderType != StorageProviders.Sql2008)
                throw new SisoDbException(ExceptionMessages.ConnectionInfo_UnsupportedProviderSpecified.Inject(ProviderType, StorageProviders.Sql2008));

            InitializeDbNameAndServerConnectionString();
        }

        /// <summary>
        /// Adds the specified synced module index entry, together with the online connection string.
        /// </summary>
        /// <param name="connectionString">The connection string.</param>
        /// <param name="entry">The entry.</param>
        /// <remarks>Documented by Dev02, 2009-03-26</remarks>
        public static void Add(IConnectionString connectionString, LearningModulesIndexEntry entry)
        {
            if (!syncedModules.ContainsKey(connectionString.ConnectionString))
                syncedModules[connectionString.ConnectionString] = new List<LearningModulesIndexEntry>();

            syncedModules[connectionString.ConnectionString].RemoveAll(e => e.SyncedPath == entry.SyncedPath && e.ConnectionName == entry.ConnectionName && e.UserName == entry.UserName);
            syncedModules[connectionString.ConnectionString].Add(entry);
        }

        protected override string OnExtractDbName(IConnectionString connectionString)
        {
            var filePath = ExtractFilePath(ClientConnectionString);

            return filePath.Contains(Path.DirectorySeparatorChar.ToString())
                ? Path.GetFileNameWithoutExtension(filePath)
                : filePath;
        }

 public NHibernateConfigurationFactory(
     INHibernateMappingConfigurationFactory mappingConfigurationFactory,
     IConnectionString connectionString,
     IFoundationConfigurator foundationConfigurator)
 {
     this.mappingConfigurationFactory = mappingConfigurationFactory;
     this.connectionString = connectionString;
     this.foundationConfigurator = foundationConfigurator;
 }

		public BasicConfiguration(IConnectionString connectionString) {
			_configuration = new Configuration();
			_configuration.Proxy(p => p.ProxyFactoryFactory<DefaultProxyFactoryFactory>())
						  .DataBaseIntegration(db => {
							  db.ConnectionString = connectionString.FormattedConnectionString;
							  db.Dialect<MsSql2008Dialect>();
						  })
						  .AddAssembly(typeof(NHTestEntity).Assembly);
		}

        private void EnsureCorrectProviderIfItExists(IConnectionString connectionString)
        {
            var providerType = ExtractProviderType(connectionString);
            if (providerType == null)
                return;

            if (providerType != ProviderType)
                throw new SisoDbException(ExceptionMessages.ConnectionInfo_UnsupportedProviderSpecified.Inject(providerType, ProviderType));
        }

        public SqlCe4ConnectionInfo(IConnectionString connectionString)
            : base(StorageProviders.SqlCe4, connectionString)
        {
            _filePath = ExtractFilePath(ClientConnectionString);
            _serverPath = Path.GetDirectoryName(FilePath);

            if (string.IsNullOrWhiteSpace(DbName))
                throw new SisoDbException(ExceptionMessages.ConnectionInfo_MissingName);
        }

 private IConnectionString FormatServerConnectionString(IConnectionString connectionString)
 {
     try
     {
         return OnFormatServerConnectionString(connectionString);
     }
     catch (Exception ex)
     {
         throw new SisoDbException("Could not parse sent server connection string. If connection string name is passed. Ensure it has match in config-file. Inspect inner exception for more details.", new[] { ex });
     }
 }

 public SessionBuilder(IConnectionString connectionString)
 {
     this.connectionString = connectionString;
     if(sessionFactory!=null) return;
     lock (factorySyncRoot)
     {
         if(sessionFactory!=null) return;
         configuration = AssemblyConfiguration();
         sessionFactory = configuration.BuildSessionFactory();
     }
 }

		public IDbConnection OpenDbConnection(IConnectionString connectionString)
		{
			IDbConnection cn;

			var connectionsPerCnString = GetConnectionsForConnectionString(connectionString.PlainString);
			if (connectionsPerCnString.TryTake(out cn))
				return cn;

			cn = new SqlCeConnection(connectionString.PlainString);
			cn.Open();
			return cn;
		}

            public void SetUp()
            {
                _connectionString = MockRepository.GenerateMock<IConnectionString>();
                _fileConfiguration = MockRepository.GenerateMock<IFileConfiguration>();
                _dataProvider = new OleDbDataProvider(new ConnectionBuilder(_connectionString), _fileConfiguration);

                _xlsxFile = TestData.UsersXlsx;
                _xlsFile = TestData.UsersXls;
                _workSheetName = "User";

                _connectionString.Expect(x => x.Get(_xlsxFile)).Return(TestData.UsersXlsxConnectionString).Repeat.Any();
                _connectionString.Expect(x => x.Get(_xlsFile)).Return(TestData.UsersXlsConnectionString).Repeat.Any();
            }

        public ConnectionStringSelectorViewModel(IEventAggregator eventAggregator, IConnectionString connectionString, bool isEnabled)
        {
            this.eventAggregator = eventAggregator;

            this.connectionString = connectionString;
            this.IsEnabled = isEnabled;

            SelectConnectionStringCommand = new DelegateCommand<object>(SelectConnectionString);
            RefreshCommand = new DelegateCommand<object>(Refresh);

            var connectionStringChangedEvent = eventAggregator.GetEvent<ConnectionStringChangedEvent>();
            connectionStringChangedEvent.Subscribe(SetInactive);
        }

 public void SetCurrentUser(IConnectionString connectionString)
 {
     if (connectionString is TextualConnectionString)
     {
         var oracleConnectionString = new OracleConnectionString(((TextualConnectionString)connectionString).ConnectionString);
         SetCurrentUserToOracleConnectionString(oracleConnectionString);
         connectionString.ConnectionString = oracleConnectionString.ConnectionString;
     }
     else if (connectionString is OracleConnectionString)
     {
         SetCurrentUserToOracleConnectionString((OracleConnectionString)connectionString);
     }
 }