Desenvolvendo .Net

Passei na Prova 70-528 Microsoft .NET Framework 2.0 - Web-Based Client Development

2008-02-03T07:54:00.000-08:00

Nessa sexta-feira dia 01/02/2008 passei na prova para 70-528, que é uma das duas provas obrigatórias para obter a certificação MCTS: .Net Framework 2.0 Web Applications. Ta certo que passei usando a “Second Shot”, mas não tinha estudo tudo que iria cair na prova, como WebParts e Mobile Web Applications.

Bom, vou falar um pouco sobre a prova. Ela não é difícil é bem simples, não teve nenhum “pega”, é composta por 45 questões que abrange grande parte das principais funcionalidades do Asp.Net. O que eu notei ao fazer a prova, foi que, o que mais caiu, como dito em outros blogs que andei olhando, foi WebParts, ligação entre componentes usando ConnectionsZone, configuração das aparências das WebParts com EditorZone entre as outras funcionalidades das WebParts. Cai na parte de Mobile Web Applications, configuração das imagens para fazer escolha automaticamente dependendo do dispositivo, se é um dispositivo móvel ou se é uma browser normal. Autenticação também foi uns dos tópicos mais cobrados na prova, parte de autorização por grupo de usuários, acesso a pastas do site por usuário protegidos, autenticação por Windows e Forms. Web Server Control também foi um conteúdo muito cobrado.

Bom, isso foi apenas alguns tópicos mais cobrados na prova que eu fiz, pode ater ter outros tópicos, mais não lembro agora.

Estudei pelo livro MCTS Self-Paced Training Kit (Exam 70-528) Microsoft.NET Framework 2.0 Web-Based Client Development. Ele abrange todo o conteúdo necessário para a prova, mas a experiência conta muito, muito mesmo. Não fique só nos exemplos do livro, faça mais.

E principalmente, faça simulados, muitos, tanto os simulados do Livro como outros que encontrar, eu fiz esse simulado também, CertGuaranteed - ExamSheet 70-528 v100906 97q, que por sinal, me ajudou muito.

Fica então essa dica pra quem quer fazer a prova.

Agora é estudar para a segunda prova, 70-536 - TS: Microsoft .NET Framework 2.0 Application Development Foundation, para assim conseguir meu certificado.

Qualquer duvida, é só mandar um e-mail.

Até mais...

Utilizando o Registro do Windows para gravar informações com C#.Net

2007-05-13T05:45:00.000-07:00

Quando precisamos gravar algum tipo de informações onde o banco de dados não pode ser utilizado, utilizamos outras formas, como um arquivo “.txt”, “.ini” entre outros. Podemos também, dependendo da informação que será guardada, utilizar o próprio registro do Windows.
Um exemplo para essa gravação e o caminho de um banco de dados ou uma string de conexão criptografada.

Nesse artigo irei demonstrar como podemos utilizar o registro do Windows para gravar o caminho de um arquivo “.txt”. Mas você pode escolher qualquer outro tipo de arquivo.

A chave de Registro que iremos utilizar será:
HKEY_LOCAL_MACHINE\Software
Nela podemos encontrar informações de todos os programas instalados no computador.

Iniciando a construção do Programa.

Estarei utilizando o Visual Studio 2005, mas você pode utilizar qualquer outro aplicativo para auxiliar no desenvolvimento.

Começaremos criando um projeto. No Visual Studio, clique em File/New/Project e escolha Windows Application. Escolha o nome para sua aplicação e o caminho que será salvo conforme Figura 1:.

Feito isso, crie então um formulário conforme imagem abaixo:

Componentes utilizados:
GroupBox: gb_gravaCaminho
Label: lb_caminho
TextBox: tbx_caminho
Button: bt_abrir
Button: bt_gravarCaminho

GroupBox: gb_leCaminho
Label: lb_caminhoGravado
TextBox:: tbx_caminhoGravado

Iremos utilizar também um outro componente, o OpenFileDialog para poder pegar o caminho do arquivo (para maiores informações sobre esse componente, acesse http://msdn2.microsoft.com/pt-br/library/system.windows.forms.openfiledialog(vs.80).aspx). Para usar esse componente no projeto, na barra Toolbox de dois clique em cima dele:

Agora vamos partir para a ação dos botões.
De dois clique no botão Abrir e insira o código abaixo:


 /// 
 /// Abri a janela para escolher o caminho do 
 /// banco de dados
 /// 

 private void bt_abrir_Click(object sender, EventArgs e)
 {
    // coloca o título na janela
    this.openFileDialog1.Title = "Escolha o banco de dados...";
    // informa qual será o diretório inicial
    this.openFileDialog1.InitialDirectory = "c:\\";
    // configura o filtro para tipo de arquivo
    this.openFileDialog1.Filter = "txt files (*.txt)|*.txt";
    // abre a janela para escolher o banco de dados
    this.openFileDialog1.ShowDialog();

    // pega o caminho escolhido
    this.tbx_caminho.Text = this.openFileDialog1.FileName;
 }

Feito isso, você já consegue selecionar o arquivo e pegar seu caminho.
Agora vamos para a parte principal, gravar essa informação no registro do Windows.

Vamos utilizar o namespace Microsoft.Win3, então acrescente ele ao programa:


using Microsoft.Win32;

De dois clique no botão Gravar Caminho e o insira o código abaixo:


try
{
   // cria uma referêcnia para a chave de registro Software
   RegistryKey rk = Registry.LocalMachine.OpenSubKey("Software",  true);
   // cria um Subchave como o nome GravaRegistro
   rk = rk.CreateSubKey("GravaRegistro");
   // grava o caminho na SubChave GravaRegistro
   rk.SetValue("CAMINHO_TXT", tbx_caminho.Text);
   // fecha a Chave de Restistro registro
   rk.Close();
   MessageBox.Show("Caminho gravado com Sucesso!");

}
catch (Exception erro)
{
   MessageBox.Show("Erro no gravação do Registro: " + erro.Message);
}

Pronto, agora já temos nosso caminho gravado do Registro do Windows.
Para verificar o caminho gravado, basta acessar o Registro do Windows com o comando regedit, e verificar que na chave de registro HKEY_LOCAL_MACHINE\Software terá um basta com o nome GravaRegistro e dentro dela um arquivo com o nome CAMINHO_TXT onde tera o caminho que você escolheu.

Agora precisamos realizar a leitura desse caminho gravado.
De dois clique no botão Caminho Gravado e insira o codigo abaixo:


try
{
   // cria uma referêcnia para a chave de registro Software
   RegistryKey rk = Registry.LocalMachine.OpenSubKey("Software", true);
   // realiza a leitura do registro
   tbx_caminhoGravado.Text = 
     rk.OpenSubKey("GravaRegistro", true).GetValue("CAMINHO_TXT").ToString();
}
catch (Exception erro)
{
   MessageBox.Show("Erro na leitura do Registro: " + erro.Message);
}

Finalizada então a codificação, execute o programa e realize a leitura do registro gravado.

Conclusão

Podemos ver que exitem outras formas que auxiliam nas gravações de informações, não só utilizando os arquivos .txt ou .ini. E que para utilizar o registro do Windows é muito simples, bastando algumas linhas de programação e você não irá precisar usar mais arquivos de texto para quardar informações como caminho do banco de dados.
Mas utilize com cuidado, pois se alterar o registro de ulgum outro programa, poderá tem sérios problemas.

Referências

http://www.microsoft.com/brasil/security/guidance/topics/devsec/secmod25.mspx
http://www.infowester.com/tutregistrowin.php
http://msdn2.microsoft.com/pt-br/library/system.windows.forms.openfiledialog(vs.80).aspx).

Preenchendo um DataGridView de forma desvinculada

2007-03-31T04:51:00.000-07:00

Por: Wilker Silva de Oliveira
e-mail: wilker.oliveira@gmail.com

No artigo Utilizando SGBD FireBird 2.0 com ADO.NET, demonstrei de forma rápida, como podemos popular um DataGridView através de consultas do banco de dados.
Nesse artigo, demonstrarei uma outra forma que temos para preencher esse componente desvinculado do banco de dados.

O DataGridView é uma poderosa forma de exibir dados no formato de tabela, tendo a possibilidade de adicionar, apagar dados entre outros recursos.
Para maiores informações sobre esse componente, acesse http://msdnwiki.microsoft.com/pt-br/mtpswiki/e0ywh3cz(VS.80).aspx.

Para demonstrar o preenchimento, criei um formulário conforme Figura 1 abaixo:

Para construir o formulário, utilizei os componentes DataGridView, GroupBox, TextBox, Button e MaskedTextBox, formatando sua máscara para o formato de Phone number - para poder fazer essa formatação, basta selecionar o componente MaskedTextBox e clicar na opção Mask, na janela de Propriedades (Properties Window).

Para adicionar as colunas, selecione o componente DataGridView, e clique na seta que aparece logo em cima, conforme Figura 2 abaixo:

Clique em Add Column....

Basta agora informar o nome para a coluna, qual o tipo e o nome de cabeçalho da coluna conforme Figura 3. Para o tipo da coluna, deixe o padrão: DataGridViewTextBoxColumn.

Faça o mesmo procedimento para os outros campos.
Após o preenchimento das colunas, o formulário ficará conforme Figura 4:

Pronto, podemos então começar a colocar os eventos para cada botão.

Adicionando os dados

De dois clique no botão Adicionar e informe o código conforme abaixo:

   /// 
  /// Adiciona os dados no DataGridView
  /// 

 private void bt_adicionar_Click(object sender, EventArgs e)
 {       
      // array de string com os dados informados
      string[] dados = { tx_nome.Text, tx_fone.Text, tx_celular.Text };

      // preenche o datagridview com os dados informados
      // cada possição do array de string corresponde a uma
      // coluna do nosso datagridview
      this.dgv_dados.Rows.Add( dados );

      // limpa os dados após o preenchimento
      limpa_dados();
 }

Verifique que foi chamado um método limpa_dados(), o mesmo serve para limpar os dados após seu preenchimento no DataGridView:

   /// 
  /// Limpa os dados após o preenchimento
  /// 

  private void limpa_dados()
  {
        tx_nome.ResetText();// limpa o nome
        tx_fone.ResetText();// limpa o telefone
        tx_celular.ResetText();// limpa o celular
  }

Pronto, conseguimos então preencher um DataGridView sem necessidade de uma conexão com o banco de dados.

Como mais uma opção do nosso formulário, iremos excluir uma linha selecionada do nosso DataGridView, para isso, no evento do botão Excluir, coloque o seguinte código:

   /// 
  /// Exclui do DataGridView a linha selecionada
  /// 

  private void bt_excluir_Click(object sender, EventArgs e)
  {
        // tenta pegar o index da linha selecionada
        try
        {
            // pega o index da linha selecioanada
            int index = dgv_dados.CurrentRow.Index;

            // conforme o index, ele remove a linha do
            // datagridview
            dgv_dados.Rows.RemoveAt(index);
        }
        // caso a linha não esteje selecionada, ocorrerá um erro
        catch
        {
            MessageBox.Show("Selecione uma linha!",
              "Atenção", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }

Conclusão

Popular um componente DataGridView, é muito simples, vinculado ou não ao banco de dados.
Esse componente fornece várias outras funcionalidades que não foram vistas aqui. Cabe ao leitor se aprofundar mais sobre essas funcionalidaes.

Referências

http://msdnwiki.microsoft.com/pt-br/mtpswiki/e0ywh3cz(VS.80).aspx.

Utilizando SGBD FireBird 2.0 com ADO.NET

2007-03-27T04:24:00.000-07:00

Por: Wilker Silva de Oliveira
e-mail: wilker.oliveira@gmail.com

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

       /// 
       /// 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 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:


/// 
/// 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ã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⊂=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