¿Hay algún analizador de cadenas de conexión en C #?

Tengo una cadena de conexión y quiero poder buscar, por ejemplo, “Fuente de datos”. ¿Hay un analizador, o tengo que buscar la cadena?

Sí, está la clase System.Data.Common.DbConnectionStringBuilder .

La clase DbConnectionStringBuilder proporciona la clase base desde la cual derivan los constructores de cadenas de conexión fuertemente tipados (SqlConnectionStringBuilder, OleDbConnectionStringBuilder, etc.). Los constructores de cadenas de conexión permiten a los progtwigdores crear cadenas de conexión sintácticamente correctas y analizar y reconstruir las cadenas de conexión existentes.

Las subclases de interés son:

 System.Data.EntityClient.EntityConnectionStringBuilder System.Data.Odbc.OdbcConnectionStringBuilder System.Data.OleDb.OleDbConnectionStringBuilder System.Data.OracleClient.OracleConnectionStringBuilder System.Data.SqlClient.SqlConnectionStringBuilder 

Por ejemplo, para “buscar el origen de datos” desde una cadena de conexión del servidor SQL, puede hacer:

 var builder = new SqlConnectionStringBuilder(connectionString); var dataSource = builder.DataSource; 

Hay constructores de cadenas de conexión específicas del proveedor de varios proveedores como SqlConnectionStringBuilder , MySqlConnectionStringBuilder , SQLiteConnectionStringBuilder , etc. (desafortunadamente esta vez no hay una interfaz pública de MS). De lo contrario, tiene DbProviderFactory.CreateConnectionStringBuilder que le dará una forma alternativa de escribirlo de manera independiente del proveedor. Debería especificar el proveedor en el archivo de configuración y tener la versión correcta de dll disponible. Por ejemplo,

 var c = "server=localhost;User Id=root;database=ppp"; var f = DbProviderFactories.GetFactory("MySql.Data.MySqlClient"); //your provider var b = f.CreateConnectionStringBuilder(); b.ConnectionString = c; var s = b["data source"]; var d = b["database"]; 

Una vez escribí un análisis manual para mí que no me dio ningún problema. Sería trivial extender esto para dar información sobre otros parámetros (ahora mismo es solo para cosas simples como nombre de db, fuente de datos, nombre de usuario y contraseña). Me gusta esto o algo así:

 static readonly string[] serverAliases = { "server", "host", "data source", "datasource", "address", "addr", "network address" }; static readonly string[] databaseAliases = { "database", "initial catalog" }; static readonly string[] usernameAliases = { "user id", "uid", "username", "user name", "user" }; static readonly string[] passwordAliases = { "password", "pwd" }; public static string GetPassword(string connectionString) { return GetValue(connectionString, passwordAliases); } public static string GetUsername(string connectionString) { return GetValue(connectionString, usernameAliases); } public static string GetDatabaseName(string connectionString) { return GetValue(connectionString, databaseAliases); } public static string GetServerName(string connectionString) { return GetValue(connectionString, serverAliases); } static string GetValue(string connectionString, params string[] keyAliases) { var keyValuePairs = connectionString.Split(';') .Where(kvp => kvp.Contains('=')) .Select(kvp => kvp.Split(new char[] { '=' }, 2)) .ToDictionary(kvp => kvp[0].Trim(), kvp => kvp[1].Trim(), StringComparer.InvariantCultureIgnoreCase); foreach (var alias in keyAliases) { string value; if (keyValuePairs.TryGetValue(alias, out value)) return value; } return string.Empty; } 

Para esto no necesita nada especial en el archivo de configuración, o cualquier dll en absoluto. Contains en la cláusula Where es importante solo si necesita eludir cadenas de conexiones mal formateadas como server = localhost;pp; donde pp agrega nada. Para comportarse como constructores normales (que explotarían en estos casos) cambie el

 .Where(kvp => !string.IsNullOrWhitespace(kvp)) 

Aquí hay un par de líneas de código que analizarían cualquier cadena de conexión en un diccionario:

 Dictionary connStringParts = connString.Split(';') .Select(t => t.Split(new char[] { '=' }, 2)) .ToDictionary(t => t[0].Trim(), t => t[1].Trim(), StringComparer.InvariantCultureIgnoreCase); 

Y luego puedes acceder a cualquier parte:

 string dataSource = connStringParts["Data Source"]; 

Utilice SqlConnectionStringBuilder Desafortunadamente, tendrá que usar un ConnectionStringBuilder específico de DB ya que las cadenas de conexión son diferentes.

Desea utilizar DbProviderFactory.CreateConnectionStringBuilder () que le proporciona un generador / analizador de cadenas de conexión específico para su conector, pero no requiere el uso de ninguna clase específica de conector.

Sí, puedes hacer esto usando clases ConnectionStringBuilder. Aquí está la lista de implementaciones de DbConnectionStringBuilder disponibles para proveedores de datos estándar:

 System.Data.Odbc.OdbcConnectionStringBuilder System.Data.OleDb.OleDbConnectionStringBuilder System.Data.OracleClient.OracleConnectionStringBuilder System.Data.SqlClient.SqlConnectionStringBuilder 

aquí hay un ejemplo de una cadena de conexión de análisis y muestra sus elementos.

  string conString = @"Data Source=.\sqlexpress;" + "Database=Northwind;Integrated Security=SSPI;" + "Min Pool Size=5;Max Pool Size=15;Connection Reset=True;" + "Connection Lifetime=600;"; // Parse the SQL Server connection string and display it's properties SqlConnectionStringBuilder objSB1 = new SqlConnectionStringBuilder(conString); Response.Write("Parsed SQL Connection String Parameters:"); Response.Write(" 
Database Source = " + objSB1.DataSource); Response.Write("
Database = " + objSB1.InitialCatalog); Response.Write("
Use Integrated Security = " + objSB1.IntegratedSecurity); Response.Write("
Min Pool Size = " + objSB1.MinPoolSize); Response.Write("
Max Pool Size = " + objSB1.MaxPoolSize); Response.Write("
Lifetime = " + objSB1.LoadBalanceTimeout);

Puede usar DbConnectionStringBuilder, y no necesita ningún proveedor específico:

El siguiente código:

 var cnstr = "Data Source=data source value;Server=ServerValue"; var builder = new DbConnectionStringBuilder(); builder.ConnectionString = cnstr; Console.WriteLine("Data Source: {0}", builder["Data Source"]); Console.WriteLine("Server: {0}", builder["Server"]); 

Salidas a la consola:

 Data Source: data source value Server: ServerValue 

EDITAR:

Como DbConnectionStringBuilder implementa IDictionary, puede enumerar los parámetros de la cadena de conexión:

 foreach (KeyValuePair kv in builder) { Console.WriteLine("{0}: {1}", kv.Key, kv.Value); } 

Entonces descubrí que todas las respuestas existentes eran más o menos incorrectas. Terminé con la siguiente solución trivial:

 class ConnectionStringParser: DbConnectionStringBuilder { ConnectionStringParser(string c) { Connection = c; } public override bool ShouldSerialize(string keyword) => true; } 

El analizador está en DbConnectionStringBuilder y es bastante fácil de conseguir. La única tontería que tenemos que hacer es configurar ShouldSerialize para que siempre devuelva verdadero para evitar la pérdida de componentes cuando intentemos el viaje de ida y vuelta en las cadenas de conexión arbitrarias.