Por:
Wilker Silva de Oliveirae-mail:
wilker.oliveira@gmail.comDe 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 2005Compreendido 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
///
/// Construtor Padrão
///
public classe_ConexaoFB() { }
///
/// Construtor
/// Recebe como parametro os dados para conexão
///
public classe_ConexaoFB(string strConexao)
{
//seta a string de conexão
set_strConexao(strConexao);
// configura a conexão
faz_Conexao();
}
///
/// Configura a Conexão
/// Passa para o construtor da classe FbConnection
/// os dados para conexão
///
private void faz_Conexao()
{
this.conexao = new FbConnection(get_strConexao());
}
///
/// Abre a conexão com o banco de dados
///
public void abre_Conexao()
{
this.conexao.Open();
}
///
/// Fecha a conexão com o banco de dados
///
public void fecha_Conexao()
{
this.conexao.Close();
}
///
/// Retorna uma conexao com o banco de dados
///
/// Conexão com o banco de dados
public FbConnection get_Conexao()
{
return this.conexao;
}
///
/// Seta os dados da conexão recebidos
/// pelo construtor
///
public void set_strConexao(string strConexao)
{
this.strConexao = strConexao;
}
///
/// Retorna a string com os dados
/// para conexao
///
/// String com os dados
public string get_strConexao()
{
return this.strConexao;
}
}
}
Salve as alterações e clique em Build - Build Solution.
Feito isso, você 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.
///
/// Inicializa os dados
///
private void inicialize()
{
this.caminho = @"D:\Artigo\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:
///
/// Cadastra o cliente no banco de dados
///
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:
///
/// Atualiza os dados do Cliente
/// A atualização será feita através do nome do cliente
///
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:
///
/// Exclui Cliente
/// Exclui um cliente conforme o nome informado
///
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:
///
/// Realiza a busca pelos dados do cliente
/// através do nome
///
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 adicionalIrei 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:
///
/// Carrega os dados no DataGridView
///
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ãoChegamos 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⊂=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
http://www.devmedia.com.br/curso/ecommerce2005/pdfs/modulo2.pdf
http://www.macoratti.net/vbn_fb2.htm
