Como já é de conhecimento da maioria dos desenvolvedores, ConnectionString é uma string que contém informações à respeito de uma determinada base de dados. É dentro dela que contém os dados necessários para se conectar ao servidor de banco de dados ou até mesmo à um arquivo de banco de dados. As principais informações que aqui temos são: servidor de banco de dados, caminho do arquivo de banco de dados, usuário e senha.

A ConnectionString é composta por uma lista de chave/valor, que são separadas por ponto e vírgula “;”. Abaixo temos alguns exemplos de ConnectionString, sendo:

• Servidor de Banco de Dados – SQL Server
  • “Data Source=Aron1;Initial Catalog=pubs;User Id=sa;Password=123;”
• Arquivo de Banco de Dados – Access
  • “Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:Base.mdb;User Id=admin;Password=123;”

Em ambos os exemplos, podemos reparar que as informações são sempre compostas da seguinte forma: key=valor;, independentemente de qual tipo de base de dados estamos utilizando. Mas vale lembrar que as configurações param por aí. Existem além dessas que vimos acima, uma série de outras opções que podemos definir dentro da ConnectionString, mas já foge um pouco do escopo desta seção/artigo.

Para constar, fica aqui uma referência para um site que contém as possíveis Strings de conexões com várias bases de dados existentes no mercado.

Devido a grande importância que tem as strings de conexões dentro de uma aplicação, a Microsoft decidiu incluir dentro do arquivo de configuração um elemento, chamado de connectionStrings, que permite a configuração destas, sem a necessidade de criarmos chaves dentro da seção appSettings (também do arquivo de configuração) para armazenarmos a conexão com a base de dados.

Dentro deste elemento, podemos definir várias strings de conexões que serão utilizadas no decorrer da aplicação. Para exemplificar isso, vejamos o código abaixo, onde fazemos a conexão com uma base de dados SQL Server local, referenciando o banco de dados NorthWind. A autenticação é efetuada através de Integrated Security. Em outras palavras quer dizer que a autenticação é efetuada com as credenciais do usuário que está logado no Windows:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <connectionStrings>
    <add 
      name="ConnString" 
      connectionString=
         "integrated security=SSPI;data source=localhost;initial catalog=Northwind" />
  </connectionStrings>
</configuration>

Através do elemento add adicionamos as conexões desejadas. Seus principais atributos são:

Como já era esperado, a Microsoft criou também uma classe chamada XXXConnectionStringBuilder (onde XXX representa o provider que já está contido dentro do .NET Framework: Sql, OleDb, Oracle e Odbc), que fornece uma forma de criar e gerenciar as ConnectionStrings que serão utilizados para criar a conexão com a Base de Dados. Todas essas classes herdam de uma classe base, chamada DbConnectionStringBuilder, que está contida dentro do namespace System.Data.Common.

Estas classes tem a finalidade de fornecer ao desenvolvedor um construtor de strings de conexão fortemente tipado, onde teremos propriedades exclusivas para cada provider. Isso possibilitará definir os valores para cada uma dessas propriedades de acordo com a base de dados que iremos acessar. Vale lembrar que isso não impossibilita o desenvolvedor a criar uma ConnectionString inválida, já que os dados são avaliados somente em tempo de execução e, caso sejam incompatíveis, uma Exception será atirada ao cliente.

Para exemplificar, utilizaremos um objeto do tipo SqlConnectionStringBuilder fornecendo os mesmos dados de conexão do código que vimos um pouco mais acima:

using System.Data.SqlClient;
//...
SqlConnectionStringBuilder sb = new SqlConnectionStringBuilder();
sb.DataSource = "localhost";
sb.InitialCatalog = "Northwind";
sb.IntegratedSecurity = true;
Console.WriteLine(sb.ConnectionString);

//Output:
//Data Source=localhost;Initial Catalog=Northwind;Integrated Security=True

Note que o output é dado através da propriedade ConnectionString, que retorna um valor idêntico ao qual definimos o primeiro código. Quando utilizamos esta forma de criação de ConnectionStrings, não precisamos nos preocupar com as keys que serão embutidas dentro dela, já que o .NET se encarrega de trazer os valores corretos. Apenas temos neste momento que nos preocupar em enviar os dados certos para que a conexão com a base de dados seja efetuada com sucesso.

Mas ainda há como integrarmos a classe XXXConnectionStringBuilder e o que temos dentro do arquivo de configuração da aplicação. As classes XXXConnectionStringBuilder fornece um construtor parametrizado, onde recebe uma ConnectionString. Para podermos recuperar as informações do arquivo de configuração, o .NET Framework fornece dentro do namespace System.Configuration, classes que possibilitam isso. O código abaixo mostra uma função que retorna a ConnectionString do arquivo de configuração e atribui à classe XXXConnectionStringBuilder:

using System.Configuration;
using System.Data.SqlClient;
//...
private static string GetConnStringFromConfigFile(string key) {
    Configuration config =
        ConfigurationManager.OpenExeConfiguration(
        ConfigurationUserLevel.None);

    ConnectionStringsSection conStrings =
        config.ConnectionStrings as ConnectionStringsSection;

    if (config != null) {
        SqlConnectionStringBuilder s = new
            SqlConnectionStringBuilder(
                conStrings.ConnectionStrings[key].ConnectionString);

        return s.ConnectionString;
    }

    return string.Empty;
}
//...
Console.WriteLine(GetConnStringFromConfigFile("ConnString"));

Analisando o código acima, vemos que através do método OpenExeConfiguration abrimos o arquivo de configuração da aplicação. Esse método retorna um objeto do tipo Configuration, contendo todas as informações/seções do arquivo *.config em questão e esta classe, por sua vez, tem uma propriedade chamada ConnectionStrings que retorna um objeto do tipo ConnectionStringsSection, contendo as possíveis strings de conexão daquele arquivo.

Com a instância do objeto ConnectionStringsSection em mãos, podemos alcançar uma string de conexão específica (uma instância da classe ConnectionStringSettings), passando o name que definimos no arquivo de configuração. Finalmente criamos uma instância da classe SqlConnectionStringBuilder, e em seu construtor passamos a string de conexão do arquivo de configuração, através da propriedade ConnectionString.

O fato de termos isso agora dentro do objeto XXXConnectionStringBuilder nos proporciona uma certa flexibilidade, já que podemos alterar os valores (lembrando que as alterações não refletem no arquivo de configuração). Para exemplificar, depois de carregado a string de conexão do arquivo de configuração, vamos alterar o banco de dados de Nothwind para pubs:

//...
if (config != null) {
    SqlConnectionStringBuilder s = new
        SqlConnectionStringBuilder(
            conStrings.ConnectionStrings[key].ConnectionString);

    s.InitialCatalog = "pubs";
    return s.ConnectionString;
}
//...

Nota: Por padrão a DLL System.Configuration.dll não vem referenciada no projeto, pois se não a tivermos, classes de acesso às configurações ficarão indisponíveis. Para isso, clique com o botão direito do mouse em cima do projeto, Add Reference…, aba .NET e selecione System.Configuration.dll.

ADONET20.zip (118.08 kb)