C# SqlConnectionStringBuilder.Remove方法代码示例

        /// <summary>
        /// Instantiates the object that holds the credentials for accessing SQL Servers 
        /// containing the shard map manager data.
        /// </summary>
        /// <param name="connectionString">Connection string for Shard map manager data source.</param>
        public SqlShardMapManagerCredentials(string connectionString)
        {
            ExceptionUtils.DisallowNullArgument(connectionString, "connectionString");

            // Devnote: If connection string specifies Active Directory authentication and runtime is not
            // .NET 4.6 or higher, then below call will throw.
            SqlConnectionStringBuilder connectionStringBuilder = new SqlConnectionStringBuilder(connectionString);

            #region GSM Validation

            // DataSource must be set.
            if (string.IsNullOrEmpty(connectionStringBuilder.DataSource))
            {
                throw new ArgumentException(
                    StringUtils.FormatInvariant(
                        Errors._SqlShardMapManagerCredentials_ConnectionStringPropertyRequired,
                        "DataSource"),
                    "connectionString");
            }

            // InitialCatalog must be set.
            if (string.IsNullOrEmpty(connectionStringBuilder.InitialCatalog))
            {
                throw new ArgumentException(
                    StringUtils.FormatInvariant(
                        Errors._SqlShardMapManagerCredentials_ConnectionStringPropertyRequired,
                        "Initial Catalog"),
                    "connectionString");
            }

            // Ensure credentials are specified for GSM connectivity.
            SqlShardMapManagerCredentials.EnsureCredentials(connectionStringBuilder, "connectionString");

            #endregion GSM Validation

            // Copy the input connection strings.
            _connectionStringShardMapManager = new SqlConnectionStringBuilder(connectionStringBuilder.ConnectionString);

            _connectionStringShardMapManager.ApplicationName = ApplicationNameHelper.AddApplicationNameSuffix(
                _connectionStringShardMapManager.ApplicationName,
                GlobalConstants.ShardMapManagerInternalConnectionSuffixGlobal);

            _connectionStringShard = new SqlConnectionStringBuilder(connectionStringBuilder.ConnectionString);

            _connectionStringShard.Remove("Data Source");
            _connectionStringShard.Remove("Initial Catalog");

            _connectionStringShard.ApplicationName = ApplicationNameHelper.AddApplicationNameSuffix(
                _connectionStringShard.ApplicationName,
                GlobalConstants.ShardMapManagerInternalConnectionSuffixLocal);
        }

		public void RemoveTest ()
		{
			builder = new SqlConnectionStringBuilder ("SERVER = localhost ;Network=DBMSSOCN");
			// non existing key
			Assert.AreEqual (false, builder.Remove ("ABCD"),
					 "#RT1 cannot remove non existant key");
			Assert.AreEqual (true, builder.Remove ("NETWORK library"),
					 "#RT2 should remove the key");
			Assert.AreEqual ("Data Source=localhost", builder.ConnectionString,
					 "#RT3 should have removed the key");
		}

        /// <summary>
        /// Creates a proxy server from the server in the given connection string using the default construction parameters and starts the proxy
        /// </summary>
        /// <param name="connectionString">Connection string to the server to proxy</param>
        /// <param name="newConnectionString">Connection string to the proxy server (using the same parameters as <paramref name="connectionString"/>)</param>
        /// <returns>The created and started proxy server</returns>
        public static ProxyServer CreateAndStartProxy(string connectionString, out string newConnectionString)
        {
            // Build builders
            SqlConnectionStringBuilder connStringbuilder = new SqlConnectionStringBuilder(connectionString);
            DataSourceBuilder dataSourceBuilder = new DataSourceBuilder(connStringbuilder.DataSource);

            // Setup proxy
            Task<System.Net.IPHostEntry> ipEntryTask = Dns.GetHostEntryAsync(dataSourceBuilder.ServerName);
            ipEntryTask.Wait();
            System.Net.IPHostEntry serverIpEntry = ipEntryTask.Result;

            ProxyServer proxy = new ProxyServer();
            proxy.RemoteEndpoint = new IPEndPoint(serverIpEntry.AddressList[0], dataSourceBuilder.Port ?? 1433);
            proxy.Start();

            // Switch connection over
            dataSourceBuilder.Protocol = "tcp";
            dataSourceBuilder.ServerName = "127.0.0.1";
            dataSourceBuilder.Port = proxy.LocalPort;
            connStringbuilder.DataSource = dataSourceBuilder.ToString();
            connStringbuilder.Remove("Network Library");

            newConnectionString = connStringbuilder.ToString();
            return proxy;
        }

        internal static string RemoveDatabaseNameFromConnectionString(string connectionString)
        {
            //need to remove the actual database name so that it will not try and login to that individual database, but the whole DB server
            var builder = new SqlConnectionStringBuilder
            {
                ConnectionString = connectionString
            };

            if (connectionString.ToLower().Contains("database"))
            {
                builder.Remove("Database");
            }

            if (connectionString.ToLower().Contains("initial catalog"))
            {
                builder.Remove("initial catalog");
            }

            return builder.ConnectionString;
        }

 private void Save()
 {
     var sqlBuilder = new SqlConnectionStringBuilder(ConnectionString);
     sqlBuilder.DataSource = DataSource;
     sqlBuilder.InitialCatalog = InitialCatalog;
     sqlBuilder.IntegratedSecurity = IsIntegratedSecurity;
     if (!IsIntegratedSecurity)
     {
         sqlBuilder.UserID = UserId;
         sqlBuilder.Password = Password;
     }
     else
     {
         sqlBuilder.Remove("User Id");
         sqlBuilder.Remove("Password");
     }
     ConnectionString = sqlBuilder.ConnectionString;
 }

        private static string FixUpConnectionString(string connectionString, string providerName)
        {
            DebugCheck.NotEmpty(providerName);

            if (providerName != "System.Data.SqlClient")
            {
                return connectionString;
            }

            var builder = new SqlConnectionStringBuilder(connectionString)
                {
                    MultipleActiveResultSets = true
                };
            builder.Remove("Pooling");

            return builder.ToString();
        }

		static void EnsureDataBase(string connectionString) {
			var qs = new SqlConnectionStringBuilder(connectionString);
			var dbName = qs.InitialCatalog;
			qs.Remove("Initial Catalog");
			using(var db = new SqlConnection(qs.ConnectionString)) {
				db.Open();
				using(var cmd = new SqlCommand("select db_id(@db)" ,db)) {
					cmd.Parameters.AddWithValue("@db", dbName);
					if(cmd.ExecuteScalar() is DBNull) {
						cmd.CommandText = $"create database [{dbName}]";
						cmd.ExecuteNonQuery();
					}
				}
			}
		}

 public static string GetSafeConnectionString(string connectionString){
     var sb = new SqlConnectionStringBuilder(connectionString);
     sb.Remove("Password");
     sb.Remove("User ID");
     return sb.ToString();
 }

        private static string FixUpConnectionString(string connectionString, string providerName)
        {
            Contract.Requires(!string.IsNullOrWhiteSpace(providerName));

            if (providerName != "System.Data.SqlClient")
            {
                return connectionString;
            }

            var builder = new SqlConnectionStringBuilder(connectionString)
                {
                    MultipleActiveResultSets = true
                };
            builder.Remove("Pooling");

            return builder.ToString();
        }

        /// <summary>
        /// Removes the Initial Catalog setting from the connection string
        /// </summary>
        /// <param name="connectionString">
        /// The connection string 
        /// </param>
        /// <param name="initialCatalog">
        /// The catalog to connect to 
        /// </param>
        /// <returns>
        /// A connection string without the InitialCatalog 
        /// </returns>
        private static string ConfigureConnection(string connectionString, string initialCatalog = null)
        {
            var builder = new SqlConnectionStringBuilder(connectionString);
            builder.Remove(InitialCatalog);
            if (!string.IsNullOrWhiteSpace(initialCatalog))
            {
                builder.InitialCatalog = initialCatalog;
            }

            builder.Remove("Pooling");
            builder.Pooling = false;
            return builder.ConnectionString;
        }

 /// <summary>
 /// Determines if the database exists or not
 /// </summary>
 /// <param name="databaseName">
 /// The database name. 
 /// </param>
 /// <param name="connectionString">
 /// The connection string. 
 /// </param>
 /// <returns>
 /// true if the database exists 
 /// </returns>
 public static bool InstanceStoreExists(string databaseName, string connectionString)
 {
     var builder = new SqlConnectionStringBuilder(connectionString);
     builder.Remove(InitialCatalog);
     using (var conn = new SqlConnection(builder.ConnectionString))
     using (var command = new SqlCommand(DatabaseExistsSql, conn))
     {
         conn.Open();
         command.Parameters.AddWithValue(DatabaseNameParameter, databaseName);
         var result = command.ExecuteScalar();
         return result != null && (int)result == 1;
     }
 }