C# DbConnectionStringBuilder.ContainsKey方法代码示例

 public void Initialize(string connectionString)
 {
     var parser = new DbConnectionStringBuilder {ConnectionString = connectionString};
     var fileName = parser.ContainsKey("Filename")
         ? parser["Filename"].ToString()
         : Path.Combine(Directory.GetCurrentDirectory(), "PlayPass.log");
     var appendMode = !parser.ContainsKey("Append") || (parser["Append"].ToString() == "1");
     _file = new StreamWriter(fileName, appendMode) {AutoFlush = true};
 }

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

        /// <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");
        }

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

        public IDbConnection Get(string connectionString)
        {
            var csb = new DbConnectionStringBuilder();
            csb.ConnectionString = connectionString;

            string providerName = string.Empty;
            if (csb.ContainsKey("Provider"))
                providerName = InterpretProviderName(csb["Provider"].ToString());

            if (string.IsNullOrEmpty(providerName) && csb.ContainsKey("Driver"))
                providerName= "Odbc";

            if (string.IsNullOrEmpty(providerName))
                providerName="SqlClient";

            if (string.IsNullOrEmpty(providerName))
                throw new ArgumentException(string.Format("No provider found for connectionString '{0}'", connectionString));

            return Get(providerName, connectionString);
        }

        /// <summary>
        /// Extracts the provider from the connection string or uses the default.
        /// </summary>
        /// <param name="csb">The DbConnectionStringBuilder object to use.</param>
        /// <returns>the string type of the provider.</returns>
        private static string GetProvider(DbConnectionStringBuilder csb)
        {
            string provider = "System.Data.SqlClient"; // default factory provider

            if (csb.ContainsKey("provider"))
            {
                provider = csb["provider"].ToString();
                csb.Remove("provider");
            }

            return provider;
        }

        public void CanUploadFileToRootDirUsingProperties()
        {
            using (var file = new DummyFile(1024 * 1024 * 3))
            {
                var csb = new DbConnectionStringBuilder { ConnectionString = Cs };
                Sftp.Host = csb["host"] as string;
                Sftp.Username = csb["username"] as string;
                Sftp.Password = csb["password"] as string;
                Sftp.Hostkey = csb["hostkey"] as string;
                Sftp.Port = csb.ContainsKey("port") ? csb["port"] as string : string.Empty;

                Sftp.UploadFile(file.FileInfo.FullName, true);
            }
        }

 /// <summary>
 ///     Initializes the Queue List with custom settings
 /// </summary>
 public void Initialize(string connectionString)
 {
     var parser = new DbConnectionStringBuilder {ConnectionString = connectionString};
     if (parser.ContainsKey("Data Source"))
         _skipFilePath = parser["Data Source"].ToString();
     else
     {
         var mediaStorageLocation = PlayOnSettings.GetMediaStorageLocation();
         if (mediaStorageLocation == "")
             throw new Exception("Unable to find PlayLater's Media Storage Location");
         _skipFilePath = mediaStorageLocation;
     }
     if (!Directory.Exists(_skipFilePath))
         throw new Exception(String.Format("Queue List data path does not exists: {0}", _skipFilePath));
 }

        protected DynamicModel(DbConnectionStringBuilder connectionStringBuilder, string tableName = "",
            string primaryKeyField = "", string descriptorField = "")
        {
            TableName = tableName == "" ? this.GetType().Name : tableName;
            PrimaryKeyField = string.IsNullOrEmpty(primaryKeyField) ? "ID" : primaryKeyField;
            DescriptorField = descriptorField;

            string _providerName =
                connectionStringBuilder.ContainsKey("ProviderName")
                    ? (string) connectionStringBuilder["ProviderName"]
                    : "System.Data.SqlClient";

            _factory = DbProviderFactories.GetFactory(_providerName);
            ConnectionString = connectionStringBuilder.ConnectionString;
        }

        public static IQueueList GetQueueList(string connectionString)
        {
            var parser = new DbConnectionStringBuilder {ConnectionString = connectionString};
            if (!parser.ContainsKey("Provider"))
                throw new Exception("Queue List Provider Type is not specified");

            var providerType = parser["Provider"].ToString().ToUpper();

            if (!Classes.ContainsKey(providerType))
                throw new Exception(String.Format("Unregistered Queue List Provider Type: {0}", providerType));

            var type = Classes[providerType];
            var instance = (IQueueList) Activator.CreateInstance(type);
            instance.Initialize(connectionString);
            return instance;
        }

        public void CanCreateConnection()
        {
            var provider = new MicrOrmConnectionProvider(DbUtility.ConnectionStringName);

              var connection = provider.CreateConnection();

              Assert.NotNull(connection);
              Assert.AreEqual(ConnectionState.Closed, connection.State);

              var connectionStringActual = new DbConnectionStringBuilder {ConnectionString = connection.ConnectionString};

              foreach (string key in provider.ConnectionString.Keys)
              {
            Assert.True(connectionStringActual.ContainsKey(key));
            Assert.AreEqual(provider.ConnectionString[key], connectionStringActual[key]);
              }
        }

        public static ILogger GetLogger(string connectionString, bool debugMode, bool verboseMode)
        {
            var parser = new DbConnectionStringBuilder {ConnectionString = connectionString};
            if (!parser.ContainsKey("Provider"))
                throw new Exception("Logger Provider Type is not specified");

            var providerType = parser["Provider"].ToString().ToUpper();

            if (!Classes.ContainsKey(providerType))
                throw new Exception(String.Format("Unregistered Logger Provider Type: {0}", providerType));

            var type = Classes[providerType];
            var instance = (ILogger) Activator.CreateInstance(type);
            instance.DebugMode = debugMode;
            instance.VerboseMode = verboseMode;
            instance.Initialize(connectionString);
            return instance;
        }

        public static string ExtractSchemaName(this string connectionString, out string schemaName)
        {
            const string key = "Queue Schema";

            var connectionStringParser = new DbConnectionStringBuilder
            {
                ConnectionString = connectionString
            };
            if (connectionStringParser.ContainsKey(key))
            {
                schemaName = (string) connectionStringParser[key];
                connectionStringParser.Remove(key);
                connectionString = connectionStringParser.ConnectionString;
            }
            else
            {
                schemaName = null;
            }
            return connectionString;
        }

        /// <summary>
        /// Gets the command timeout (in seconds) from
        /// the connection string (if the CommandTimeout key is specified).
        /// </summary>
        private static int? GetCommandTimeout(DbConnectionStringBuilder csb)
        {
            const string key = "CommandTimeout";

            int? value = null;
            if (csb.ContainsKey(key))
            {
                int iValue;
                if (Int32.TryParse(csb[key].ToString(), out iValue))
                {
                    // ignore negative values
                    if (iValue >= 0)
                    {
                        value = iValue;
                    }
                }
                csb.Remove(key);
            }

            return value;
        }

        /// <summary>
        /// Initialize the Connection Parameters using the Connection String Settings
        /// </summary>
        /// <param name="settings"></param>
        public void ReadConnectionParameters(ConnectionStringSettings settings)
        {
            var connectionString = new DbConnectionStringBuilder { ConnectionString = settings.ConnectionString };

            if (connectionString.ContainsKey("Database"))
            {
                DatabaseName = (string)connectionString["Database"];
            }

            if (connectionString.ContainsKey("DriverClass"))
            {
                Connection_DriverClass = (string)connectionString["DriverClass"];
                connectionString.Remove("DriverClass");
            }
            else
                throw new ConnectionElementNotFoundException("DriverClass");

            if (connectionString.ContainsKey("Dialect"))
            {
                Dialect = (string)connectionString["Dialect"];
                connectionString.Remove("Dialect");
            }
            else
                throw new ConnectionElementNotFoundException("Dialect");

            if (connectionString.ContainsKey("proxyfactory.factory_class"))
            {
                ProxyFactoryClass = (string)connectionString["proxyfactory.factory_class"];
                connectionString.Remove("proxyfactory.factory_class");
            }

            if (connectionString.ContainsKey("TablePrefix"))
            {
                TablePrefix = (string)connectionString["TablePrefix"];
                connectionString.Remove("TablePrefix");
            }

            if (connectionString.ContainsKey("show_sql"))
            {
                ShowSql = (string)connectionString["NHibernateInterceptor"] == "true";
                connectionString.Remove("show_sql");
            }
            if (connectionString.ContainsKey("NHibernateInterceptor"))
            {
                Interceptor = (string)connectionString["NHibernateInterceptor"];
                connectionString.Remove("NHibernateInterceptor");
            }

            if (connectionString.ContainsKey("CreatedOn"))
            {
                FieldCreatedOn = (string)connectionString["CreatedOn"];
                connectionString.Remove("CreatedOn");
            }

            if (connectionString.ContainsKey("UpdatedOn"))
            {
                FieldUpdatedOn = (string)connectionString["UpdatedOn"];
                connectionString.Remove("UpdatedOn");
            }

            if (connectionString.ContainsKey("CreatedBy"))
            {
                FieldCreatedBy = (string)connectionString["CreatedBy"];
                connectionString.Remove("CreatedBy");
            }

            if (connectionString.ContainsKey("UpdatedBy"))
            {
                FieldUpdatedBy = (string)connectionString["UpdatedBy"];
                connectionString.Remove("UpdatedBy");
            }

            Connection_ConnectionString = connectionString.ConnectionString;
        }