C# DbConnectionStringBuilder.TryGetValue方法代码示例

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

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

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

        /// <summary>
        ///     Parses semicolon-delimited parameter string,
        ///     which has same format as connection strings,
        ///     and extracts a value for given key.
        ///     Returns defaultValue if key was not found.
        /// </summary>
        /// <param name="delimiteParamString"></param>
        /// <param name="paramKey"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static string GetParameterValue(string delimiteParamString, string paramKey, string defaultValue = null)
        {
            DbConnectionStringBuilder paramStringParse = new DbConnectionStringBuilder
            {
                ConnectionString = delimiteParamString
            };

            object val;
            if(!paramStringParse.TryGetValue(paramKey, out val))
                return defaultValue;

            return val.ToStringEx();
        }

        public LogServerConnection([NotNull] string connStringOrName)
        {
            if (connStringOrName == null) throw new ArgumentNullException("connStringOrName");

            var connString = connStringOrName;
            try
            {
                connString = ConfigurationManager.ConnectionStrings[connStringOrName].ConnectionString;
            }
            // ReSharper disable EmptyGeneralCatchClause
            catch { }
            // ReSharper restore EmptyGeneralCatchClause

            var csb = new DbConnectionStringBuilder();
            try
            {
                csb.ConnectionString = connString;
            }
            catch (ArgumentException ex)
            {
                throw new FormatException(string.Format("The connection string '{0}' is not formatted correctly. " +
                                                        "Example connection string: " +
                                                        "url=http://logserver.company.com:123;username=johndoe;password=secret",
                                                        connString), ex);
            }

            object value;
            if (csb.TryGetValue("url", out value))
                Url = (string)value;
            else
                throw new FormatException("A url was not specified in the connection string.");

            if (csb.TryGetValue("username", out value))
                Username = (string)value;

            if (csb.TryGetValue("password", out value))
                Password = (string)value;
        }

        private static string GetProviderName(string connectionString)
        {
            var builder = new DbConnectionStringBuilder();
            builder.ConnectionString = connectionString;

            object providerObject;

            if (!builder.TryGetValue("provider", out providerObject))
            {
                return (string)providerObject;
            }

            // TODO - look at deducing provider from related config
            throw new ConnectionProviderException(connectionString);
        }

        internal static string GetLocalDbFilePath(string providerInvariantName, string providerConnectionString)
        {
            var filePathKey = GetFilePathKey(providerInvariantName, providerConnectionString);
            if (string.IsNullOrEmpty(filePathKey))
            {
                return null;
            }

            var providerConnectionStringBuilder = new DbConnectionStringBuilder();
            providerConnectionStringBuilder.ConnectionString = providerConnectionString;
            object filePathObject;
            providerConnectionStringBuilder.TryGetValue(filePathKey, out filePathObject);
            var filePath = filePathObject as string;
            if (string.IsNullOrEmpty(filePath))
            {
                return null;
            }

            return filePath;
        }

        internal static bool IsSqlLocalConnectionString(string providerInvariantName, string providerConnectionString)
        {
            if (null == providerInvariantName
                || null == providerConnectionString)
            {
                return false;
            }

            if (0 == string.CompareOrdinal(providerInvariantName, PROVIDER_NAME_SQLCLIENT))
            {
                var providerConnectionStringBuilder = new DbConnectionStringBuilder();
                providerConnectionStringBuilder.ConnectionString = providerConnectionString;
                object ignoreResult;
                if (providerConnectionStringBuilder.TryGetValue(CONNECTION_PROPERTY_ATTACH_DB_FILENAME, out ignoreResult))
                {
                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// Strips out the database instance name from a connectionString.
        /// </summary>
        /// <param name="connectionString">The connection string.</param>
        /// <param name="dbName">Name of the db.</param>
        /// <returns>The newly created connection string.</returns>
        private static string _StripDbName(string connectionString, string providerName, out string dbName, out string dbFile)
        {
            var builder = new DbConnectionStringBuilder
            {
                ConnectionString = connectionString
            };
            string dbname = null, dbfile = null;
            object tmp;

            // SQLServer.. minimal option..
            if (builder.TryGetValue("Initial Catalog", out tmp))
            {
                dbname = tmp.ToString();
                builder.Remove("Initial Catalog");
            }

            // SQLServer default option..
            if (builder.TryGetValue("Database", out tmp))
            {
                dbname = tmp.ToString();
                builder.Remove("Database");
            }

            // SQLite! (XXX: MsSql has 'Data Source' as a means to specify Server address)
            if ((providerName == SQLiteProvider || providerName == SqlCe) && builder.TryGetValue("Data Source", out tmp))
            {
                dbname = tmp.ToString();
                builder.Remove("Data Source");
            }

            // SQLServer (auto attach alternate)
            if (builder.TryGetValue("AttachDBFileName", out tmp))
            {
                dbfile = tmp.ToString();

                // Replace |DataDirectory| in connection string.
                dbfile = dbfile.Replace("|DataDirectory|", AppDomain.CurrentDomain.GetData("DataDirectory") as string);
                builder.Remove("AttachDBFileName");
            }

            // Oracle SID
            if (providerName == OracleDataProvider && builder.TryGetValue("Data Source", out tmp))
            {
                string connStr = tmp.ToString().Replace(" ", "").Replace("\r", "").Replace("\n", "");
                Match match = Regex.Match(connStr, @"SERVICE_NAME=([^\)]+)");

                if (match.Success)
                {
                    dbname = match.Groups[1].Value;
                }

                // Try EZ-Connect method..
                if (string.IsNullOrEmpty(dbname))
                {
                    match = Regex.Match(connStr, ".*/([^$]*)$");

                    if (match.Success)
                    {
                        dbname = match.Groups[1].Value;
                    }
                }
            }

            // If no database is specified at connStr, throw error..
            if (string.IsNullOrEmpty(dbname) && string.IsNullOrEmpty(dbfile))
            {
                throw new ArgumentException("ConnectionString should specify a database name or file");
            }

            // If not catalog nor database name passed, try to obtain it from db file path.
            if (string.IsNullOrEmpty(dbname))
            {
                dbname = dbfile;
            }

            // Save return values..
            dbName = dbname;
            dbFile = dbfile;

            return builder.ToString();
        }

        private void ParseEndpoints(DbConnectionStringBuilder builder)
        {
            object val;
            builder.TryGetValue("Source", out val);
            if (val == null)
                throw new CqlException("no \"Source\" param specified in connection string");

            string source = val as string;
            if (source.Contains(":"))
            {
                var parts = source.Split(':');

                ushort port;
                if (!ushort.TryParse(parts[1], out port))
                    throw new CqlException("cannot parse Source param: port number is not parsable");

                Host = parts[0];
                Port = port;
            }
            else
            {
                Host = source;
                Port = DEFAULT_CASSANDRA_PORT;
            }
        }

 private void ParseDefaultKeyspace(DbConnectionStringBuilder builder)
 {
     object val;
     if (builder.TryGetValue("Keyspace", out val))
     {
         DefaultKeyspace = EnsureKeyspaceNameIsValid(val as string);
     }
     else if (builder.TryGetValue("Database", out val))
     {
         DefaultKeyspace = EnsureKeyspaceNameIsValid(val as string);
     }
 }

 /// <summary>
 /// Gets the value of the specified item in the connection string.
 /// </summary>
 /// <param name="connectionStringBuilder">The connection string.</param>
 /// <param name="keyword">Name of the item.</param>
 /// <returns>The value of the item, or an empty string if not found.</returns>
 protected string GetConnectionStringValue(DbConnectionStringBuilder connectionStringBuilder, string keyword)
 {
     object value = null;
     connectionStringBuilder.TryGetValue(keyword, out value);
     return (string)value ?? String.Empty;
 }

        private string ConvertConnectionStringToNewPath(
            string providerInvariantName, string filePathKey, string oldConnectionString, string newFilePath, bool useDataDirectoryMacro)
        {
            if (string.IsNullOrEmpty(filePathKey))
            {
                Debug.Fail("requires non-null, non-empty filePathKey");
                return oldConnectionString;
            }

            if (LocalDataUtil.IsSqlMobileConnectionString(providerInvariantName))
            {
                // DbConnectionString does not support SQL Mobile
                return GenerateNewSqlMobileConnectionString(oldConnectionString, newFilePath, useDataDirectoryMacro);
            }

            var dbConnectionStringBuilder = new DbConnectionStringBuilder();
            dbConnectionStringBuilder.ConnectionString = oldConnectionString;
            object filePathObject;
            dbConnectionStringBuilder.TryGetValue(filePathKey, out filePathObject);
            var filePath = filePathObject as string;
            if (string.IsNullOrEmpty(filePath))
            {
                Debug.Fail("could not find filePath for filePathKey=" + filePathKey);
                return oldConnectionString;
            }

            // replace old path with new one
            dbConnectionStringBuilder.Remove(filePathKey);
            if (useDataDirectoryMacro)
            {
                dbConnectionStringBuilder.Add(filePathKey, DataDirectoryMacro + Path.DirectorySeparatorChar + Path.GetFileName(newFilePath));
            }
            else
            {
                dbConnectionStringBuilder.Add(filePathKey, newFilePath);
            }

            return dbConnectionStringBuilder.ConnectionString;
        }

		[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)] // File.Exists method call.
		void IProvider.CreateDatabase()
		{
			this.CheckDispose();
			this.CheckInitialized();
			// Don't need to call CheckNotDeleted() here since we allow CreateDatabase after DeleteDatabase
			// Don't need to call InitializeProviderMode() here since we don't need to know the provider to do this.
			string catalog = null;
			string filename = null;

			DbConnectionStringBuilder builder = new DbConnectionStringBuilder();
			builder.ConnectionString = _conManager.Connection.ConnectionString;

			if(_conManager.Connection.State == ConnectionState.Closed)
			{
				if(_mode == SqlServerProviderMode.SqlCE)
				{
					if(!File.Exists(_dbName))
					{
						Type engineType = _conManager.Connection.GetType().Module.GetType("System.Data.SqlServerCe.SqlCeEngine");
						object engine = Activator.CreateInstance(engineType, new object[] { builder.ToString() });
						try
						{
							engineType.InvokeMember("CreateDatabase", BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod, null, engine, new object[] { }, CultureInfo.InvariantCulture);
						}
						catch(TargetInvocationException tie)
						{
							throw tie.InnerException;
						}
						finally
						{
							IDisposable disp = engine as IDisposable;
							if(disp != null)
							{
								disp.Dispose();
							}
						}
					}
					else
					{
						throw Error.CreateDatabaseFailedBecauseSqlCEDatabaseAlreadyExists(_dbName);
					}
				}
				else
				{
					// get connection string w/o reference to new catalog
					object val;
					if(builder.TryGetValue("Initial Catalog", out val))
					{
						catalog = val.ToString();
						builder.Remove("Initial Catalog");
					}
					if(builder.TryGetValue("Database", out val))
					{
						catalog = val.ToString();
						builder.Remove("Database");
					}
					if(builder.TryGetValue("AttachDBFileName", out val))
					{
						filename = val.ToString();
						builder.Remove("AttachDBFileName");
					}
				}
				_conManager.Connection.ConnectionString = builder.ToString();
			}
			else
			{
				if(_mode == SqlServerProviderMode.SqlCE)
				{
					if(File.Exists(_dbName))
					{
						throw Error.CreateDatabaseFailedBecauseSqlCEDatabaseAlreadyExists(_dbName);
					}
				}
				object val;
				if(builder.TryGetValue("Initial Catalog", out val))
				{
					catalog = val.ToString();
				}
				if(builder.TryGetValue("Database", out val))
				{
					catalog = val.ToString();
				}
				if(builder.TryGetValue("AttachDBFileName", out val))
				{
					filename = val.ToString();
				}
			}

			if(String.IsNullOrEmpty(catalog))
			{
				if(!String.IsNullOrEmpty(filename))
				{
					catalog = Path.GetFullPath(filename);
				}
				else if(!String.IsNullOrEmpty(_dbName))
				{
					catalog = _dbName;
				}
				else
//.........这里部分代码省略.........