IConnectionStringProvider CreateConfigPerEndpointConnectionStringProvider(LocalConnectionParams localConnectionParams)
        {
            const string transportConnectionStringPrefix = "NServiceBus/Transport/";
            var configConnectionStrings =
                connectionStrings
                    .Where(x => x.Name.StartsWith(transportConnectionStringPrefix))
                    .Select(x =>
                    {
                        string schema;
                        var connectionString = x.ConnectionString.ExtractSchemaName(out schema);
                        var endpoint = x.Name.Replace(transportConnectionStringPrefix, String.Empty);
                        var connectionInfo = EndpointConnectionInfo.For(endpoint).UseSchema(schema);

                        var localConnectionStringBuilder = new DbConnectionStringBuilder { ConnectionString = localConnectionParams.ConnectionString };
                        var overriddenConnectionStringBuilder = new DbConnectionStringBuilder { ConnectionString = connectionString };

                        if (!localConnectionStringBuilder.EquivalentTo(overriddenConnectionStringBuilder))
                        {
                            connectionInfo = connectionInfo.UseConnectionString(connectionString);
                        }
                        return connectionInfo;
                    })
                    .ToArray();

            return new CollectionConnectionStringProvider(configConnectionStrings, localConnectionParams);
        }

		public static InstanceInfo ResolveInstance(
			DbConnectionStringBuilder builder,
			bool                      isOdbc,
			QuerySource               dbType
		)
		{
			InstanceInfo instance;

			if (dbType == QuerySource.SQLite || dbType == QuerySource.NetworkInformation)
			{
				instance = ResolveNonDatabase(
					builder.ConnectionString,
					dbType
				);
			}
			else
			{
				instance = ResolveDatabase(
					builder,
					dbType,
					isOdbc
				);
			}

			return instance;
		}

        private static void EnsureDatabase()
        {
            using (var connection = SqlConnections.NewByKey("Default"))
                try
                {
                    connection.Open();
                }
                catch
                {
                    var cb = new DbConnectionStringBuilder();
                    cb.ConnectionString = SqlConnections.GetConnectionString("Default").ConnectionString;
                    var catalog = cb["Initial Catalog"];
                    cb["Initial Catalog"] = null;
                    cb["AttachDBFilename"] = null;

                    using (var serverConnection = new SqlConnection(cb.ConnectionString))
                    {
                        serverConnection.Open();
                        serverConnection.Execute(String.Format(
                            @"CREATE DATABASE [{0}] ON PRIMARY (Name = N'{0}', FILENAME = '{1}\{0}.mdf') LOG ON (NAME = N'{0}_log', FILENAME = '{1}\{0}.ldf');",
                                catalog, HostingEnvironment.MapPath("~/App_Data")));
                    }

                    SqlConnection.ClearAllPools();
                }

            RunMigrations();
        }

        public void Test()
        {
            try
            {
                var connectionString = new DbConnectionStringBuilder();
                connectionString["Data Source"] = "ANNE\\OJB_NET";
                connectionString["Initial Catalog"] = "unittest";
                connectionString["Integrated Security"] = "SSPI";
                connectionString["MultipleActiveResultSets"] = true;
                var connection = new SqlConnection(connectionString.ConnectionString);

                var context = new Context {Connection = connection, IsSqlCeConnectionBug = true};
                context.UpdateDatabase();

                var address = new Address {Id = 1, Text = "5th Ave, City23"};
                var customer = new Customer {Id = 1, Name = "Cust co ldt.", Address = address};
                context.Container.Address.Add(address);
                context.Container.Customer.Add(customer);
                //context.SaveChanges();
                var customers = context.Container.Customer.Where(c => c.Id == 1).Where(c => c.Id == 1);
                var customersFound = customers.ToArray();
                var customerFound = customers.Single();
            }
            catch(Exception)
            {
                Debugger.Break();
                throw;
            }
        }

 public BaseNode(string text, DbConnectionStringBuilder builder,DataType nodetype)
     : base(text)
 {
     this.ConnectionStringBuilder = builder;
     this.datatype = nodetype;
     this.Nodes.Add(new DummyNode());
 }

 public IngresMetadataReader(string connectionStr)
 {
     _connectionString = connectionStr;
     DbConnectionStringBuilder connStr = new DbConnectionStringBuilder();
     connStr.ConnectionString = _connectionString;
     DatabaseName = connStr["Database"] as String;
 }

        static void Main()
        {
            DbConnectionStringBuilder dcsBuilder = new DbConnectionStringBuilder();
            dcsBuilder.Add("User ID", "wjzgis");
            dcsBuilder.Add("Password", "wjzgis");
            dcsBuilder.Add("Service Name", "sunz");
            dcsBuilder.Add("Host", "172.16.1.9");
            dcsBuilder.Add("Integrated Security", false);
            string licPath = Application.StartupPath + "\\DDTek.lic";
            //dcsBuilder.Add("License Path", licPath);
            //若路径中存在空格，则会在路径名称前加上"\""
            string conStr = dcsBuilder.ConnectionString;
            conStr = conStr.Replace("\"", "");

            Configuration config = new Configuration();
            config.AddDirectory(new System.IO.DirectoryInfo( System.IO.Path.Combine(Application.StartupPath, "DataMapping")));

            config.Properties["connection.connection_string"] = conStr;

            NHibernate.ISessionFactory sFactory = config.BuildSessionFactory();
            NHibernate.ISession session = sFactory.OpenSession();

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());
        }

        public Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
        {
            string connectionStringName = config.Properties["ConnectionStringName"];

            if (string.IsNullOrEmpty(connectionStringName))
            {
                this.Log.Info("Starting RavenDB Storage Provider InMemory");
                return this.InMemoryMode();
            }

            var settings = ConfigurationManager.ConnectionStrings[connectionStringName];

            var connectionStringBuilder = new DbConnectionStringBuilder
            {
                ConnectionString = settings.ConnectionString
            };

            object url;
            if (connectionStringBuilder.TryGetValue("Url", out url))
            {
                this.Log.Info("Starting RavenDB Storage Provider attached to server {0}", url);
                return this.ServerMode(connectionStringName);
            }

            object dataDir;
            if (connectionStringBuilder.TryGetValue("DataDir", out dataDir))
            {
                this.Log.Info("Starting RavenDB Storage Provider embedded in directory {0}", dataDir);
                return this.LocalMode(connectionStringName);
            }

            return TaskDone.Done;
        }

        /// <summary>
        /// Replaces any existing 'enlist' parameter in the connection string
        /// with a value indicating that manual enlist is necessary.
        /// </summary>
        /// <remarks>
        /// ODP.NET supports 3 values for 'enlist'; 'true', 'false' and 'dynamic'.
        ///  'dynamic' effectively works the same as 'false' in System.Data.OracleClient.
        /// </remarks>
        protected override void ReplaceEnlistInConnectionString(DbConnectionStringBuilder dbConnectionStringBuilder)
        {
            if (dbConnectionStringBuilder.ContainsKey("enlist"))
                dbConnectionStringBuilder.Remove("enlist");

            dbConnectionStringBuilder.Add("enlist", "dynamic");
        }

 public NpgsqlMetadataReader(string connectionStr)
 {
     this._connectionString = connectionStr;
     DbConnectionStringBuilder connStr = new DbConnectionStringBuilder();
     connStr.ConnectionString = _connectionString;
     DatabaseName = connStr["Database"] as String;
 }

        //TODO: Custom config section?
        //TODO: Combine constructors
        public DomainCredential(string connectionString)
        {
            //TODO: Custom parser?
            var builder = new DbConnectionStringBuilder();
            builder.ConnectionString = connectionString;

            object[] value = new object[6];
            builder.TryGetValue("NetBIOS", out value[0]);
            builder.TryGetValue("Domain", out value[1]);
            builder.TryGetValue("Container", out value[2]);
            builder.TryGetValue("Username", out value[3]);
            builder.TryGetValue("Password", out value[4]);
            builder.TryGetValue("SecureConnection", out value[5]);

            if (String.IsNullOrWhiteSpace(value[0] as string))
                throw new ArgumentNullException("netbios");
            if (String.IsNullOrWhiteSpace(value[1] as string))
                throw new ArgumentNullException("domain");
            if (String.IsNullOrWhiteSpace(value[2] as string))
                throw new ArgumentNullException("container");

            NetBIOS = value[0] as string;
            Domain = value[1] as string;
            Container = value[2] as string;
            Username = value[3] as string;
            Password = value[4] as string;
            SecureConnection = bool.Parse(value[5] as string ?? "False");
        }

 public ConnectionStringBuilder(GenDatabase db)
 {
     GenDatabase = db;
     DbConnectionStringBuilder = GenDatabase.DbProviderFactory.CreateConnectionStringBuilder();
     if (db.GenProviderType == GenProviderType.OleDb)
         ((OleDbConnectionStringBuilder)DbConnectionStringBuilder).Provider = GenDatabase.OleDbName;
 }

        protected DbProvider(string connectionString, System.Data.Common.DbProviderFactory dbProviderFactory)
        {
            this.dbConnectionStringBuilder = new DbConnectionStringBuilder();
            this.dbConnectionStringBuilder.ConnectionString = connectionString;
            this.dbProviderFactory = dbProviderFactory;

        }

        private void instancesComboBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            string server = (string)instancesComboBox.SelectedItem;

             DbConnectionStringBuilder builder = new DbConnectionStringBuilder();
             builder.Add("Data Source", server);
             builder.Add("Initial Catalog", "master");
             builder.Add("Integrated Security", "SSPI");

             using ( SqlConnection conn = new SqlConnection(builder.ConnectionString) )
             {
            SqlCommand cmd = new SqlCommand("select name from sys.databases", conn);
            conn.Open();

            using ( SqlDataReader reader = cmd.ExecuteReader() )
            {
               List<string> dbs = new List<string>();
               while ( reader.Read() )
               {
                  dbs.Add(reader.GetString(0));
               }
               dbsComboBox.DataSource = dbs;
            }
             }
        }

        public static string GetConnectionString()
        {
            System.Data.Common.DbConnectionStringBuilder sb= new DbConnectionStringBuilder();
            sb.ConnectionString = ConfigurationManager.ConnectionStrings["trackDBEntities2"].ConnectionString;

            return sb["provider connection string"].ToString();
        }

        /// <summary>
        /// This function returns login and password of user for a passed NpgsqlConnection
        /// </summary>
        /// <param name="connection">the current opened DbConnection</param>
        /// <param name="login">returned login corresponding to the NpgsqlConnection passed</param>
        /// <param name="password">returned password corresponding to the NpgsqlConnection passed</param>
        /// <returns>true if succeed, false otherwise (connection null or not opened)</returns>
        public static bool GetConnectionInformationsFrom(
                                      IDbConnection connection,
                                      out string login,
                                      out string password)
        {
            login = string.Empty;
            password = string.Empty;

            if ((connection != null) && (connection.State == System.Data.ConnectionState.Open))
            {
                DbConnectionStringBuilder builder = new DbConnectionStringBuilder();
                builder.ConnectionString = connection.ConnectionString;

                if (builder != null)
                {
                    object value = null;
                    bool result = builder.TryGetValue("User Id", out value);
                    if (result)
                    {
                        login = value.ToString();
                    }

                    result &= builder.TryGetValue("Password", out value);
                    if (result)
                    {
                        password = value.ToString();
                    }

                    builder.Clear();
                    return result;
                }
            }

            return false;
        }

        protected void CheckAssertions(string connectionString)
        {
            DbConnectionStringBuilder dbConnection = new DbConnectionStringBuilder { ConnectionString = connectionString };

            foreach (ConnectionStringSetting setting in StringSettings)
            {
                if (dbConnection.ContainsKey(setting.SettingName))
                {
                    AssertState.Equal(setting.ExpectedValue, dbConnection[setting.SettingName].ToString());
                }
                else
                {
                    throw new AssertionException(string.Format("Connection String setting [{0}] not found", setting.SettingName));
                }
            }

            if (dbConnection.Keys != null)
                AssertState.Equal(StringSettings.Count, dbConnection.Keys.Count);
            else
            {
                throw new AssertionException("No StringSetting values were found");
            }

            if (CheckConnectivity)
                using (SqlConnection sqlConnection = (new SqlConnection(connectionString)))
                    sqlConnection.Open();
        }

        public string GetConnectionString(AbstractConnection connection) {

            if (string.IsNullOrEmpty(ServerProperty))
                return string.Empty;

            var builder = new DbConnectionStringBuilder { { ServerProperty, connection.Server } };

            if (!string.IsNullOrEmpty(connection.Database)) {
                builder.Add(DatabaseProperty, connection.Database);
            }

            if (!String.IsNullOrEmpty(connection.User)) {
                builder.Add(UserProperty, connection.User);
                builder.Add(PasswordProperty, connection.Password);
            } else {
                if (!String.IsNullOrEmpty(TrustedProperty)) {
                    builder.Add(TrustedProperty, true);
                }
            }

            if (PersistSecurityInfoProperty != string.Empty && connection.PersistSecurityInfo != string.Empty) {
                builder.Add(PersistSecurityInfoProperty, connection.PersistSecurityInfo);
            }

            if (connection.Port <= 0)
                return builder.ConnectionString;

            if (PortProperty == string.Empty) {
                builder[ServerProperty] += "," + connection.Port;
            } else {
                builder.Add("Port", connection.Port);
            }
            return builder.ConnectionString;
        }

 /// <summary>
 /// Gets the provider information stored on the connection string
 /// </summary>
 /// <param name="connection">The connection object to get the connection string from</param>
 /// <returns>An string providing the provider information</returns>
 public static String GetConnectionProvider(DbConnection connection)
 {
     object result = String.Empty;
     DbConnectionStringBuilder builder = new DbConnectionStringBuilder();
     builder.ConnectionString = connection.ConnectionString;
     builder.TryGetValue("Provider", out result);
     return result == null ? string.Empty : (string)result;
 }

 private static string GetDataSourceFilePath(DbConnectionStringBuilder builder, string connectionString)
 {
     builder.ConnectionString = connectionString;
     if (!builder.ContainsKey("Data Source"))
     {
         throw new ArgumentException("A 'Data Source' parameter was expected in the supplied connection string, but it was not found.");
     }
     return ConnectionStringHelper.ResolveDataSourceFilePath(builder["Data Source"].ToString());
 }