Utilizando SGBD FireBird 2.0 com ADO.NET
por Wilker Silva de Oliveira

De forma básica, irei falar um pouco do ADO.NET antes de exemplificar a utilização com o FireBird 2.0.

ADO.NET é uma “reconstrução”, do antigo ADO, sendo completamente integrado com o .NET Framework, disponibilizando um grande número de classes e possibilitando em uma comunicação bem mais fácil com os SGBD’s.
Ou seja, ele nada mais é que um conjunto de classes definidas pelo .NET Framework, que auxilia na comunicação com os SGBD’s.

Vantagens de Usar o ADO.NET

Algumas das vantagens em utilizar o ADO.NET é que você contará com uma alta escalabilidade, desempenho, segurança, performance em seu sistema e maior produtividade.
Agora com o ADO.NET, ao utilizar um DataSet, o mesmo, por padrão, trabalha desconectado. Os dados ficam armazenados em um cachê local, assim a conexão pode ser fechada e o cliente pode trabalhar desconectado, e caso seja necessário uma atualização dos dados, basta efetuar uma nova conexão.

Arquitetura

fig. 1: Arquitetura .Net
Os componentes que formam a arquitetura do ADO.NET são: Data Source, Data Provider e o DataSet.
• Data Source: representa um banco de dados físico ou um arquivo XML;
• Data Provider: se encarrega de criar as conexões e processar comandos;
• DataSet: representa um ou mais data source na memória.

Componentes do ADO.NET

fig. 2: Arquitetura .Net
As classes do ADO.NET estão divididas em dois grupos: Managed Providers e DataClasses.

• Managed providers: objetos que não armazenam dados e são usados para ler e escrever em banco de dados: Connection, DataAdapter, Command e DataReader. Para cada SGBD, existe uma classe para fazer a comunicação com o banco de dados.
• DataClasses: são os objetos que podem armazenar e manipular dados: DataSets, DataTables, DataRows, DataColumns, DataRelations, Constraints e DataView.

Detalhando um pouco os objetos do grupo Managed Providers e DataClasses, temos:

Managed providers:

• Connection: é através dessa classe, que será feita a comunicação com o banco de dados. Ela recebe uma string de conexão, onde serão informados os dados para acesso ao banco.

• Command: recebe uma string com o comando SQL;

• DataAdapter: um repositório para o Command. Dependendo da string passada para o Command, ele será preenchido com os dados resultantes do processamento. Através dos comandos informados, ele realizará junto ao banco de dados, algumas tarefas, como: pesquisar (SelectCommand), inserir (InsertCommand), alterar (UpdateCommand) ou excluir (DeleteCommand). Dependendo do comando, será usado para executar o DataAdapter um desses objetos: ExecuteNonQuery() - usado para INSERT, UPDATE e DELETE, retorna o número de registros afetados; ExcuteEscalar() – usado em consultas, quando deseja-se retornar apenas uma linha e uma coluna, ex.: verificar o saldo total da conta, código do cliente com o cpf XXX, mesmo que a consulta retorne mais de uma linha, ele irá pegar apenas a primeira linha e a primeira coluna; ExecuteReader() – utilizado quando a consulta irá retornar mais de um valor, após a execução, ele preenche o DataReader com os resultados.

• DataReader: utilizado para fazer leituras dos registros no banco de dados. Após a execução de uma consulta, o DataReader será preenchido com os resultados das consultas, para posterior leitura e preenchimentos de alguns objetos, como por exemplo um TextBox.

Para cada SGBD, existe um provider específico, porém, mudando apenas o seu prefixo. Ex: para SGBD Sql Server, possui o prefixo SqlXXX (SqlConnection), para SGBD Oracle, possui o prefixo OracleXXX (OracleCommand), para SGBD FireBird, possui um prefixo FbXXX (FbDataAdapter).
Para poder usar um SGBD através do ADO.NET e com acesso direto ao banco, é necessário verificar se existe um provider para o banco que será utilizado, caso exista, será necessária à instalação do mesmo.

DataClasses:

• DataSet: objeto que armazena os dados, uma copia exata ou parcial do banco de dados, possibilitando o trabalho com o banco desconectado. Funciona como um banco de dados em memória, possuindo coleções de tabelas (DataTables), campos (DataColumns), registros (DataRows), constraints (Constraints) e relacionamentos (DataRelations). Os dados que armazenam são manipulados em XML por padrão. Podendo ser passado entre camadas sem nenhum problema.

• DataTable: esse objeto representa uma tabela de dados na memória, usado por diversos outros objetos, como o DataSet. Possui alguns métodos que auxiliam na criação de DataTables: DataColumn, DataRow dentre outros. Esse objeto pode tanto ser criado independente como usados por outros objetos.

Existem outros componentes do DataClasses que não serão vistos aqui.

Exemplo de utilização do ADO.NET com Visual Studio 2005

Compreendido o básico do ADO.NET, irei demonstrar como é fácil a utilização do ADO.NET com qualquer banco de dados.
Nesse exemplo, será mostrada a utilização com o SGBD FireBird 2.0.

Lembrando, para que o mesmo possa ser utilizado, é necessária a instalação do provider referente a esse SGBD, que pode ser encontado no link:
http://www.firebirdsql.org/index.php?op=files&id=netprovider

Para baixar o SGBD FireBird 2.0, utilize o link:
http://prdownloads.sourceforge.net/firebird/Firebird-2.0.0.12748-0-Win32.exe?Download

A instalação do SGB FireBird 2.0 é muito simples, basta ir clicando em avançar, seguindo as informações.
Feita a instalação do SGBD FireBird, instale o provider, seguindo as informações passadas pelo assistente de instalação.

Exemplificaremos através da tabela abaixo, a utilização dos principais comandos para trabalhar com banco de dados no ADO.NET, através de uma aplicação simples - cadastro de cliente - utilizando os comandos SQL INSERT, UPDATE, DELETE E SELECT.


fig. 3: Tabela

Após ter criado a tabela no banco de dados, conforme figura 3, podemos iniciar o processo de construção de nossa aplicação.

Nesse Artigo, utilizaremos o Visual Studio 2005.
Primeiramente iremos criar uma classe para a conexão com o banco de dados:

Dica: Para poder usar essa conexão em qualquer projeto futuro, aconselha-se criar uma DLL (Class Library).

No Visual Studio 2005, clique em File > New > Project. Será aberta a janela de New Project, clique em Visual C# > Windows. Na parte de Templates clique em Class Library e escolha o nome do seu projeto. No nosso caso, o nome escolhido foi Conexao_FireBird.
Para que possamos ter acesso ao provider do FireBird, temos que criar um referência ao mesmo. No Solution Explorer, clique com o botão direito do mouse em cima do nome do projeto, Conexao_FireBird, e escolha Add Reference, aparecerá a janela conforme Figura 4:


fig. 4: Add Reference

Na aba .Net, procure por FireBirdClient – ADO.NET 2.0 Data Provider, e clique no botão OK. Agora basta escrever seu código conforme o exemplo abaixo:

using System;
using System.Collections.Generic;
using System.Text;

using FirebirdSql.Data.FirebirdClient;//provider do SGBD FireBird

// Conexao_FireBird
// Classe: classe_ConexaoFB

namespace classe_conexao
{
    public class classe_ConexaoFB
    {      
            
        private string strConexao;//STRING PARA CONEXÃO
        private FbConnection conexao;//OBJETO CONEXÃO

        /// <SUMMARY>
        /// Construtor Padrão
        /// </SUMMARY>
        public classe_ConexaoFB() { }

        /// <SUMMARY>
        /// Construtor 
        ///  Recebe como parametro os dados para conexão
        /// </SUMMARY>
        public classe_ConexaoFB(string strConexao)
        {
            //seta a string de conexão
            set_strConexao(strConexao); 

            // configura a conexão
            faz_Conexao();
        }

        /// <SUMMARY>
        /// Configura a Conexão
        ///  Passa para o construtor da classe FbConnection
        ///  os dados para conexão
        /// </SUMMARY>
        private void faz_Conexao()
        {
            this.conexao = new FbConnection(get_strConexao());
        }

        /// <SUMMARY>
        /// Abre a conexão com o banco de dados
        /// </SUMMARY>
        public void abre_Conexao()
        {
            this.conexao.Open();
        }

        /// <SUMMARY>
        /// Fecha a conexão com o banco de dados
        /// </SUMMARY>
        public void fecha_Conexao()
        {
            this.conexao.Close();
        }

        /// <SUMMARY>
        /// Retorna uma conexao com o banco de dados
        /// </SUMMARY>
        /// <RETURNS>Conexão com o banco de dados</RETURNS>
        public FbConnection get_Conexao()
        {
            return this.conexao;
        }

        /// <SUMMARY>
        /// Seta os dados da conexão recebidos
        /// pelo construtor
        /// </SUMMARY>       
        public void set_strConexao(string strConexao)
        {
            this.strConexao = strConexao;
        }

        /// <SUMMARY>
        /// Retorna a string com os dados
        /// para conexao
        /// </SUMMARY>
        /// <RETURNS>String com os dados</RETURNS>
        public string get_strConexao()
        {
            return this.strConexao;
        }
    }
}
Salve as alterações e clique em Build > Build Solution. 
Feito isso, 
voçê poderá notar que dentro da pasta Bin/Debug, localizada dentro da 
pasta de seu projeto, foi criado nossa dll para conexão com o banco FireBird. 


Para poder utilizar essa dll com os programas criados, basta adicionar a 
mesma ao projeto. 

Vamos então criar um novo projeto para podermos testar 
essa conexão e os comandos SQL. 

No Visual Studio 2005, clique em File 
> New > Project. Será aberta a janela de New Project, clique em Visual C# 
> Windows. Na parte de Templates clique em Windows Application e escolha o 
nome do seu projeto. No nosso caso, o nome escolhido foi Comunicacao_Banco. 

Crie novamente a referência do provider FireBird para esse novo projeto, 
conforme orientações acima 

Crie um formulário conforme a imagem da 
Figura 5: 



fig. 5: Layout

Teste a 
aplicação clicando em Debug > Start Debugging ou apertando a tecla F5. 


Após ter testado nosso novo projeto, temos que adicionar a DLL criada ao 
nosso projeto. 
No Solution Explorer, clique com o botão direito do mouse no 
nome do nosso projeto, Comunicacao_Banco, na aba Browse, conforme 
Figura 6. 



fig. 6: Add 
Reference


Clique em Examinar, e procure pela 
classe_conexao.dll, na pasta do nosso projeto criado anteriormente. 

Clique no botão OK para incluir a DLL ao nosso projeto. 

Pronto, 
agora podemos trabalhar com o acesso a dados através do ADO.NET e com o SGBD 
FireBird 2.0. 

Após a criação do formulário conforme a Figura 1, vá até o 
código fonte do seu projeto e coloque os seguintes namespaces: 
 using classe_conexao;
 using FirebirdSql.Data.FirebirdClient;
para poder trabalhar com a DLL que nos criamos e o provider do FireBird. 


Para esse projeto, criei algumas variáveis conforme abaixo: 
       //caminho para o banco de dados
        private string caminho;
        //string com os dados para conexão
        private string strConexao;
        //objeto do tipo classe_ConexaoFB
        private classe_ConexaoFB conexao_FB;
        //objeto FbDataAdapter para poder trabalhar com SQL
        private FbDataAdapter adapt;
        //objto FbDataReader para poder trabalhar com as consultas
        private FbDataReader reader;

Criei também um método inicialize() para poder inicializar minhas 
variáveis. 
        /// <SUMMARY>
        /// Inicializa os dados
        /// </SUMMARY>
        private void inicialize()
        {
           this.caminho = @"D:\Apostial ADO.NET\Codigo Fonte\Banco\" +
                          "BANCOFB.FDB";
           this.strConexao = "User=SYSDBA;" +
                             "Password=masterkey;" +
                             "DataBase=" + caminho + ";Dialect=3";
           this.reader = null;
           this.adapt = new FbDataAdapter();
           this.conexao_FB = new classe_ConexaoFB(); 

        }
Uma observação para as varíáveis this.caminho e this.strConexao, pois são 
elas as responsáveis para a conexão com o banco de dados, onde: this.caminho 
esta recebendo a string com o caminho para o banco de dados e this.strConexao 
recebe os dados necessário para fazer a conexão com o banco, como usuário e 
senha, qual o banco de dados, que no caso esta em this.caminho e o dialeto do 
banco. 
Mude as informações do caminho e usuário e senha conforme necessário. 


No botão Cadastrar, de dois clique em cima dele, e informe o código 
conforme abaixo: 
/// <SUMMARY>
/// Cadastra o cliente no banco de dados     
/// </SUMMARY>  
private void bt_cadastrar_Click(object sender, EventArgs e)
{
   //cria uma string com o comando SQL para inserir os dados
   string sql_Insert = "insert into tb_cliente values( " +
                       "@codigo, @nome_cliente, @fone_cliente, @cel_cliente)";
            
    //tenta fazer o insert no banco
    try
    {
        //abre a conexão com o banco de dados
        this.conexao_FB.abre_Conexao();

       //cria uma nova instancia para FbDataAdapter passando como
       //parâmetos a string com o comando SQL e a conexão com o banco de dados
        this.adapt = new FbDataAdapter(sql_Insert, this.conexao_FB.get_Conexao());

        //limpa os parâmetros caso exista 
        this.adapt.SelectCommand.Parameters.Clear();

        // informa para o FbDataAdapter quais são os conteudos de cada
	    //parâmetro
        // obs: o código esta como null devido que o banco de dados
	    //está configurado para auto incremento
        this.adapt.SelectCommand.Parameters.Add("@codigo", null);
        this.adapt.SelectCommand.Parameters.Add("@nome_cliente", tx_nome_cliente.Text);
        this.adapt.SelectCommand.Parameters.Add("@fone_cliente", tx_fone_cliente.Text);
        this.adapt.SelectCommand.Parameters.Add("@cel_cliente", tx_celular_cliente.Text);

        // executa o FbDataAdapter com o comando ExecuteNonQuery
        this.adapt.SelectCommand.ExecuteNonQuery();

        //mensagem para cadastro OK
        MessageBox.Show("Cadastro ok", "Atenção", MessageBoxButtons.OK, MessageBoxIcon.Information); 
                
   }
   // caso de algum erro
   catch (Exception er)
   {
        // mensagem de erro
        MessageBox.Show("Erro ao fazer inclusão: " + er.Message, "Atenção", MessageBoxButtons.OK, 
MessageBoxIcon.Error);
   }
   //fecha a conexao com o banco de dados
   finally
   {
         this.conexao_FB.fecha_Conexao();
   }
}
Uma observação sobre o comando this.adapt.SelectCommand.Parameters.Add(), 
a forma como foi apresentada é apenas uma das maneiras de se utilizar esse 
comando para fazer uma comunicação com o banco de dados, existem várias outras 
formas como o exemplo abaixo: 
this.adapt.SelectCommand.Parameters.Add("@codigo", FbDbType.Integer);
this.adapt.SelectCommand.Parameters[0].Value = null;
Dessa forma, você está informando que o parâmetro "@codigo", é do tipo 
Integer. Na segunda linha é informado que na possição 0 do, digamos assim, 
“array de parametros”, o valor é null. 

Bom, agora que já temos como 
cadastrar os dados no banco, podemos partir para a parte de Atualização dos 
Dados. Para não estender muito, vamos fazer uma atualização de acordo com o Nome 
do Cliente. 

No botão Atualizar, de dois clique, e informe o código 
conforme abaixo: 
 /// <SUMMARY>
 /// Atualiza os dados do Cliente
 ///  A atualização será feita através do nome do cliente
 /// </SUMMARY>
 private void bt_atualizar_Click(object sender, EventArgs e)
 {
       string sql_Update = "update tb_cliente set " +
             "nome_cliente = @nome, fone_cliente = @fone, celular_cliente = @cel " +
             "where nome_cliente = @nome";

       //tenta fazer o insert no banco
       try
       {
           //abre a conexão com o banco de dados
           this.conexao_FB.abre_Conexao();

          //cria uma nova instancia para FbDataAdapter passando como
	      //parâmetro a string com o comando SQL e a conexão com o banco de dados
          this.adapt = new FbDataAdapter(sql_Update, this.conexao_FB.get_Conexao());

          //limpa os parâmetros caso exista algum
          this.adapt.SelectCommand.Parameters.Clear();

          // informa para o FbDataAdapter quais são os conteudos de cada parâmetro
          this.adapt.SelectCommand.Parameters.Add("@nome", tx_nome_cliente.Text);
          this.adapt.SelectCommand.Parameters.Add("@fone", tx_fone_cliente.Text);
          this.adapt.SelectCommand.Parameters.Add("@cel", tx_celular_cliente.Text);              

          // executa o FbDataAdapter com o comando ExecuteNonQuery e retorna o total  de linhas afetadas
          int numero = this.adapt.SelectCommand.ExecuteNonQuery();

          //mensagem
          MessageBox.Show("Atualização ok: " + numero.ToString(), "Atenção",  MessageBoxButtons.OK, 
MessageBoxIcon.Information);

       }
       // caso de algum erro
       catch (Exception er)
       {
             // mensagem de erro
             MessageBox.Show("Erro ao fazer atualização: " + er.Message, "Atenção",
             MessageBoxButtons.OK, MessageBoxIcon.Error);
       }
       //fecha a conexão com o banco de dados
       finally
       {
            this.conexao_FB.fecha_Conexao();
       }

 }
Não existe muita diferença dos comando de inserir para o atualizar. E 
novamente repetido que existem outras formas de se fazer essa comunicação com o 
banco, e que o exemplo da outra forma citado acima, também vale para essa 
atualização, bastando fazer os ajustes necessários. 

No botão Deletar, de 
dois clique, e informe o código conforme abaixo: 
/// <SUMMARY>
/// Exclui Cliente
///  Exclui um cliente conforme o nome informado
/// </SUMMARY>
private void bt_deletar_Click(object sender, EventArgs e)
{
     string sql_Delete = "delete from tb_cliente where nome_cliente = @nome";

     //tenta fazer o insert no banco
     try
     {
          //abre a conexão com o banco de dados
          this.conexao_FB.abre_Conexao();

          //cria uma nova instancia para FbDataAdapter passando como
	      //parâmetro a string com o comando SQL e a conexão com o banco de dados
          this.adapt = new FbDataAdapter(sql_Delete, this.conexao_FB.get_Conexao());

          //limpa os parâmetros caso exista algum
          this.adapt.SelectCommand.Parameters.Clear();

          // informa para o FbDataAdapter quais são os conteudos de cada parâmetro 
          this.adapt.SelectCommand.Parameters.Add("@nome", tx_nome_cliente.Text);               

          // executa o FbDataAdapter com o comando ExecuteNonQuery e retorna o total de  linhas afetadas
          int numero = this.adapt.SelectCommand.ExecuteNonQuery();

        //mensagem
        MessageBox.Show("Clientes Excluídos: " + numero.ToString(), "Atenção", MessageBoxButtons.OK, 
MessageBoxIcon.Information);

     }
     // caso de algum erro
     catch (Exception er)
     {
           // mensagem de erro
           MessageBox.Show("Erro ao fazer exclusão: " + er.Message, "Atenção",
                        MessageBoxButtons.OK, MessageBoxIcon.Error);
     }
     //fecha a conexao com o banco de dados
     finally
     {
          this.conexao_FB.fecha_Conexao();
     }

}
Novamente a mesma observação feita para a Inserção e Atualização. 


Agora, após ter cadastrado, atualizado e apagado um cliente, podemos 
partir para a consulta de clientes. 
Nessa parte será introduzido o objeto 
DataReader, conforme explicado nos tópicos anteriores, é nele que ficará os 
resultados da consulta. 
A consulta será feita também pelo nome do cliente, 
usando a clausula Like do SQL. No botão Consultar, de dois clique, e 
informe o código conforme abaixo: 
/// <SUMMARY>
/// Realiza a busca pelos dados do cliente
/// através do nome
/// </SUMMARY>
private void bt_consultar_Click(object sender, EventArgs e)
{
     string sql_Select = "select nome_cliente, fone_cliente, celular_cliente " +
                          "from tb_cliente " +
                           "where nome_cliente like @nome";

     //tenta fazer o insert no banco
     try
     {
         //abre a conexão com o banco de dados
         this.conexao_FB.abre_Conexao();

        //cria uma novo instancia pra FbDataAdapter passando como
	    //parâmetro a string com o comando SQL e a conexão com o banco de dados
        this.adapt = new FbDataAdapter(sql_Select, this.conexao_FB.get_Conexao());

        //limpa os parâmetros caso exista algum
        this.adapt.SelectCommand.Parameters.Clear();

        // informa para o FbDataAdapter quais são os conteudos de cada parâmetro       
       this.adapt.SelectCommand.Parameters.Add("@nome", "%" + tx_nome_cliente.Text + "%" );

	   // executa o FbDataAdapter com o comando ExecuteReader e  
	   // retorna os dados para dentro do FbDataReader
       this.reader = this.adapt.SelectCommand.ExecuteReader();

       //realiza a leitura dos dados
       while (this.reader.Read())
       {
             tx_nome_cliente.Text    = this.reader[0].ToString();
             tx_fone_cliente.Text = this.reader[1].ToString();
             tx_celular_cliente.Text = this.reader[2].ToString();
       }
       //Importante: sempre feche o FbDataReader após fazer leituras
       this.reader.Close();

     }
     // caso de algum erro
     catch (Exception er)
     {
           // mensagem de erro
           MessageBox.Show("Erro ao fazer leitura dos dados: " + er.Message, "Atenção", 
MessageBoxButtons.OK, MessageBoxIcon.Error);
     }
     //fecha a conexao com o banco de dados
     finally
     {
          this.conexao_FB.fecha_Conexao();
     }

}
Caso seja uma consulta que irá retornar apenas um dado, como por exemplo o 
nome do cliente, aconselho utilizar ExecuteScalar, pois é mais rápido do que um 
ExecuteReader. 
Para se realizar uma consulta que retorne mais de um dado, 
deve-se utilizar ExecuteReader conforme o código acima. 
Para realizar a 
leitura dos dados, utilizo o comando que todo programador conhece, WHILE, que 
enquanto tiver dados dentro do this.reader, ele continuará passando as 
informações para os campos. Mas observe que, da forma que foi feito, caso exista 
mais de um cliente com o mesmo nome, os dados serão sobrepostos. 
Deve-se 
tomar muito cuidado ao utilziar esse componente, pois caso você não o feche, irá 
ocorrer um erro, então, sempre que utilizar, feche com o comando 
this.reader.Close(). 

Conforme demostrei acima, temos várias 
formas para interagir com os dados dentro de um banco. 
Os exemplos são 
apenas para mostrar uma das maneiras de utilização dos comandos, e nesse caso, 
não nos importamos com a regra de negócios e nem a validação dos campos. 

Um exemplo adicional
Irei demonstrar agora, de forma rápida, como podemos trabalhar com um 
componente DataGridView, mas lembrando que é apenas um exemplo rápido, para 
poder saber como iniciar um trabalho com esse componente. 

Acrescentei ao 
formulário um componente DataGridView, e dei o nome de dg_dados, acrescentei 
também um botão para que assim que for clicado, ira carregar o DataGridView com 
os dados da consulta. 



fig. 7: Layout 
2

Veja: 

/// <SUMMARY>
/// Carrega os dados no DataGridView
/// </SUMMARY>
private void bt_dataSet_Click(object sender, EventArgs e)
{
    //cria um DataTable para carregar os dados da consulta
    DataTable dataTable = new DataTable();

    string sql_Select = "select * " +
                        "from tb_cliente ";                                

    //tenta fazer o insert no banco
    try
    {
         //abre a conexão com o banco de dados
         this.conexao_FB.abre_Conexao();

         //cria uma nova instancia pra FbDataAdapter passando como
	     //parâmetro
         // a string com o comando SQL e a conexão com o banco de
	     //dados
         this.adapt = new FbDataAdapter(sql_Select,this.conexao_FB.get_Conexao());

         //limpa os parâmetros caso exista algum
         this.adapt.SelectCommand.Parameters.Clear();

         //executa a consulta
         this.adapt.SelectCommand.ExecuteNonQuery();

	     //preenche o dataTable com os dados da consulta
         this.adapt.Fill(dataTable);

         
        // preenche o DataGridView com os dados
         this.dg_dados.DataSource = dataTable;

    }
    // caso de algum erro
    catch (Exception er)
    {
         // mensagem de erro
         MessageBox.Show("Erro ao fazer leitura dos dados: " + er.Message, "Atenção",
                        MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
    //fecha a conexao com o banco de dados
    finally
    {
           this.conexao_FB.fecha_Conexao();
    }
}


Conclusão
Chegamos então ao final desse Artigo sobre Utilização do SGBD FireBird 2.0 
com o ADO.NET, onde podemos ver de forma básica, como fazer para comunicar e 
trocar informações com o banco de dados, além de conhecer um pouco da parte 
teórica, que é muito importante para o desenvolvimento correto de uma aplicação. 

Referências
http://www.linhadecodigo.com.br/artigos.asp?id_ac=296&pag=1 

http://www.linhadecodigo.com.br/artigos.asp?id_ac=435&sub=0 

http://www.linhadecodigo.com.br/artigos.asp?id_ac=216 

http://linhadecodigo.com.br/artigos.asp?id_ac=1254&pag=1 

http://www.microsoft.com/brasil/msdn/adonet/default.mspx 

http://msdn2.microsoft.com/pt-br/default.aspx