Caso não, o usuário poderá trocar o endereço do servidor, usuário, senha e schema manualmente.

Se ao trocar os dados a conexão for efetuada com sucesso, salvar uma connectionString no app.config com os novos dados de conexão, para relembrar ao reiniciar o aplicativo.

Agora vamos por a mão na massa:

1. Cria a interface do usuário, no meu caso fico da seguinte maneira:
   Figura 1
2. Criar o arquivo app.config:

   <?xml version="1.0" encoding="utf-8" ?>
   <configuration>
   
     <!-- A sessão a baixo armazena os valores de conexão para serem amostrados nos textBox   -->
     <appSettings>
       <add key="hostDB" value="nevada" />
       <add key="userDB" value="alexandre" />
       <add key="passwdDB" value="123456" />
       <add key="schemaDB" value="ddc" />
     </appSettings>
   
     <!-- A sessão abaixo armazena a connectionString utilizada para efetuar a conexão -->
     <connectionStrings>
       <add  name ="ddcConnectionString"
             connectionString ="server=nevada;User Id=alexandre;password=123456;Persist Security Info=True;database=ddc"
             providerName ="MySql.Data.MySqlClientt"  />
     </connectionStrings>
   
   </configuration>
   

3. No meu caso eu dei preferência a criar uma classe chamada “Database” para se uma espécie de “Connection Factory”. Mas só tomei essa decisão por estar trabalhando com ADO.NET

   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   using System.Diagnostics;
   using System.Configuration;
   using System.Data;
   using System.Data.Common;
   using MySql.Data;
   using MySql.Data.MySqlClient;
   
   namespace Relatorios.Classes
   {
       class Database
       {
           /// <summary>
           /// Variável onde fica armazenado o Objeto da classe, para ser utilizado no padrão singleton
           /// </summary>
           private static Database instance;
           String strConn = ConfigurationManager.ConnectionStrings["awuConnectionString"].ConnectionString;
           MySqlConnection conn = new MySqlConnection();
           MySqlConnectionStringBuilder myCSB = new MySqlConnectionStringBuilder();
   
           /// <summary>
           /// Propriedade que armazena a instância da classe
           /// </summary>
           private Database() { }
   
           /// <summary>
           /// Método get que fornece a instância da classe (Padrão Singleton, lembrando que não existe o método 'set' neste caso)
           /// </summary>
           public static Database Instance
           {
               get
               {
                   if (instance == null)
                   {
                       instance = new Database();
                   }
                   return instance;
               }
           }
   
           // Fim da implementação do padrão singleton
   
           /// <summary>
           /// Endereço do servidor do Banco de Dados
           /// </summary>
           public String hostDB { get; set; }
           /// <summary>
           /// Usuário do Banco de dados
           /// </summary>
           public String userDB { get; set; }
           /// <summary>
           /// Senha para acessar o Banco de Dados
           /// </summary>
           public String passwdDB { get; set; }
           /// <summary>
           /// Schema a ser acessado no Banco de Dados
           /// </summary>
           public String schemaDB { get; set; }
   
           /// <summary>
           /// Cria a conexão com o banco de dados e retorna um objeto do tipo DBConnection (System.Data.Common)
           /// </summary>
           /// <returns>DbConnection</returns>
           public DbConnection connectar()
           {
   
               try
               {
                   conn.ConnectionString = strConn;
                   conn.Open(); // Abrindo conexão...
               }
               catch(Exception ex)
               {
                   Console.WriteLine(ex.Message);
               }
                   // Se a conexão ñ for bem sucedida, tenta usar os parâmetros da classe
                   if (conn.State != ConnectionState.Open)
                   {
                       // Cria uma nova string de conexão com o MySQLConnectionStringBuilder
                       myCSB.Server = this.hostDB;
                       myCSB.UserID = this.userDB;
                       myCSB.Password = this.passwdDB;
                       myCSB.Database = this.schemaDB;
   
                       // Passa a nova ConnectionString para o objeto de conexão
                       conn.ConnectionString = myCSB.ConnectionString;
                       try
                       {
                           conn.Open(); // Tenta se conectar novamente
                       }
                       catch (Exception ex)
                       {
                           Console.WriteLine(ex.Message);
                       }
                   }
   
               return conn;
           }
   
           /// <summary>
           /// Cria uma string de conexão e retorna-o
           /// </summary>
           /// <returns>string</returns>
           public string createStringConnection()
           {
   
               myCSB.Server = this.hostDB;
               myCSB.UserID = this.userDB;
               myCSB.Password = this.passwdDB;
               myCSB.Database = this.schemaDB;
   
               return myCSB.ConnectionString;
           }
       }
   }
   

4. Nesse projeto, eu estou utilizando windows form, abaixo segue a imagem do Form principal (o primeiro a ser aberto), mapeado com o nome dos objetos mais importantes:
   
5. Agora segue o código do form, fazendo a mágica…

   using System;
   using System.Collections.Generic;
   using System.ComponentModel;
   using System.Data;
   using System.Data.Common;
   using System.Drawing;
   using System.Linq;
   using System.Text;
   using System.Windows.Forms;
   using System.Configuration;
   using MySql.Data;
   using MySql.Data.MySqlClient;
   
   namespace Relatorios
   {
       public partial class FMain : Form
       {
   
           public FMain()
           {
               InitializeComponent();
           }
   
           // Busca o arquivo de configuração
           Configuration configFile = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
   
          // Ao abrir a janela principal, executar:
           private void FMain_Load(object sender, EventArgs e)
           {
               // Pucha as variáveis pré definidas do app.config
               txtServer.Text = ConfigurationManager.AppSettings["hostDB"];
               txtUser.Text = ConfigurationManager.AppSettings["userDB"];
               txtPassword.Text = ConfigurationManager.AppSettings["passwdDB"];
               txtDatabase.Text = ConfigurationManager.AppSettings["schemaDB"];
   
               // Tentar se conectar
               Classes.Database db = Classes.Database.Instance;
               DbConnection conn = db.connectar();
   
               if (conn.State == ConnectionState.Open)
               {
                   lblStatus.Text = "Conectado";
                   lblStatus.ForeColor = Color.Blue;
               }
               else
               {
                   lblStatus.Text = "Não foi possível conectar ao Banco de Dados";
                   lblStatus.ForeColor = Color.Red;
               }
   
           }
   
           /** Ao clicar no botão "connectar", criar a conexão com os parâmetros
            *   passados pelo usuário na janela principal
           */
           private void button1_Click(object sender, EventArgs e)
           {
               AppSettingsSection appSetSec = configFile.AppSettings;
   
               Classes.Database db = Classes.Database.Instance;
               db.hostDB = txtServer.Text;
               db.userDB = txtUser.Text;
               db.passwdDB = txtPassword.Text;
               db.schemaDB = txtDatabase.Text;
   
               DbConnection conn = db.connectar();
   
               if (conn.State == ConnectionState.Open)
               {
                   lblStatus.Text = "Conectado";
                   lblStatus.ForeColor = Color.Blue;
                   appSetSec.Settings["hostDB"].Value = txtServer.Text;
                   appSetSec.Settings["userDB"].Value = txtUser.Text;
                   appSetSec.Settings["passwdDB"].Value = txtPassword.Text;
                   appSetSec.Settings["schemaDB"].Value = txtDatabase.Text;
   
                   // Retorna a seção do connectionStrings.
                   ConnectionStringsSection csSection = configFile.ConnectionStrings;
   
                   // apaga a connectionString atual
                   csSection.ConnectionStrings.Remove("awuConnectionString");
   
                   // adiciona a nova connectionString
                   csSection.ConnectionStrings.Add(new ConnectionStringSettings("awuConnectionString", "server=" + txtServer.Text + ";User Id=" + txtUser.Text + ";password=" + txtPassword.Text + ";Persist Security Info=True;database=" + txtDatabase.Text + "", "MySql.Data.MySqlClient"));
   
                   // Salva a nova connectionStriong
                   configFile.Save();
   
                   // Atualiza a nova seção (faz o aplicativo reler do HD a connectionString se for utilizada novamente
                   ConfigurationManager.RefreshSection("connectionStrings");
                   // Atualiza a seção do appString também
                   ConfigurationManager.RefreshSection("appSettings");
               }
               else
               {
                   lblStatus.Text = conn.ConnectionString;
               }
   
           }
   
           // Item do menu da caixa de dialogo "Sobre"
           private void sobreToolStripMenuItem_Click(object sender, EventArgs e)
           {
               AboutBox abox = new AboutBox();
               abox.ShowDialog();
           }
   
           // Item do menu da janela de relatório "Resumo Financeiro Angolano"
           private void angolanoToolStripMenuItem_Click(object sender, EventArgs e)
           {
               Academicos.frmResumoFinanceiroAng frmReport = new Relatorios.Academicos.frmResumoFinanceiroAng();
               frmReport.Show();
           }
   
       }
   }
   

Pronto!

Quero agradecer e dar créditos também ao nosso amigo Paulo Diogo que me ajudou muito a fazer isso.

Abraços….

public enum   ConfigFileType
{
 WebConfig ,
 AppConfig
}

<span id="more-17"></span>

public class AppConfig : System.Configuration.AppSettingsReader
{
 public string  docName = String.Empty;
 private  XmlNode node=null;
    private int _configType;

 public   int ConfigType
 {
  get
  {
   return _configType;
  }
  set
  {
   _configType=value;
  }
 }

 public bool SetValue(string key, string value)
 {
  XmlDocument cfgDoc = new XmlDocument();
  loadConfigDoc(cfgDoc);
   // retrieve the appSettings node
        node = cfgDoc.SelectSingleNode(&quot;//connectionStrings&quot;);

   if( node == null )
   {
                throw new System.InvalidOperationException(&quot;connectionStrings section not found&quot;);
   }

  try
  {
   // XPath select setting &quot;add&quot; element that contains this key
   XmlElement addElem= (XmlElement)node.SelectSingleNode(&quot;//add[@name='&quot; +key +&quot;']&quot;) ;
   if (addElem!=null)
   {
    addElem.SetAttribute(&quot;value&quot;,value);
   }
    // not found, so we need to add the element, key and value
   else
   {
    XmlElement entry = cfgDoc.CreateElement(&quot;add&quot;);
    entry.SetAttribute(&quot;name&quot;,key);
                entry.SetAttribute(&quot;connectionString&quot;, value);
    node.AppendChild(entry);
   }
   //save it
   saveConfigDoc(cfgDoc,docName);
   return true;
  }
  catch
  {
   return false;
  }
 }

 private void saveConfigDoc(XmlDocument cfgDoc,string cfgDocPath)
 {
  try
  {
   XmlTextWriter writer = new XmlTextWriter( cfgDocPath , null );
   writer.Formatting = Formatting.Indented;
   cfgDoc.WriteTo( writer );
   writer.Flush();
   writer.Close();
   return;
  }
  catch
  {
   throw;
  }
 }

 public bool removeElement ( string elementKey)
 {
  try
  {
   XmlDocument cfgDoc = new XmlDocument();
   loadConfigDoc(cfgDoc);
   // retrieve the appSettings node
            node = cfgDoc.SelectSingleNode(&quot;//connectionStrings&quot;);
   if( node == null )
   {
                throw new System.InvalidOperationException(&quot;connectionStrings section not found&quot;);
   }
   // XPath select setting &quot;add&quot; element that contains this key to remove
   node.RemoveChild( node.SelectSingleNode(&quot;//add[@name='&quot; +elementKey +&quot;']&quot;) );

   saveConfigDoc(cfgDoc,docName);
   return true;
  }
  catch
  {
   return false;
  }
 }

 private XmlDocument loadConfigDoc( XmlDocument cfgDoc )
 {
  // load the config file
        Console.WriteLine(Convert.ToInt32(ConfigFileType.AppConfig)+&quot;___&quot;+Convert.ToInt32(ConfigType));

  if(  Convert.ToInt32(ConfigType)==0)
  {

   docName= ((Assembly.GetEntryAssembly()).GetName()).Name;
   docName +=   &quot;.exe.config&quot;;
  }
  else
  {
   docName=System.Web.HttpContext.Current.Server.MapPath(&quot;web.config&quot;);
  }
  cfgDoc.Load( docName );
  return cfgDoc;
 }

}

2º Na hora de usar

AppConfig config = new AppConfig();
            config.removeElement("localhostcs");
            config.SetValue("QUAL KEY QUER MUDAR?", "O QUE QUER ADD?");

ps. o codigo da classe Appconfig.cs esta pronto para mudar a connectio string
portanto prestar atenção na hora de mudar… mude para aquilo que vc quer mudar no seu app.config =D

flw