C#  - CRUD básico no SQLite com VS 2015 - II

Neste artigo vou mostrar como realizar um CRUD básico usando o banco de dados SQLite em uma aplicação Windows forms com o VS Community 2015 e a linguagem C#.

Na primeira parte do artigo criamos o banco de dados e a tabela alunos no SQLite e criamos também o projeto definindo a interface com o usuário no Visual Studio 2015 Community.

Vamos agora implementar as funcionalidades CRUD usando ADO .NET.

Irei usar a abordagem de usar comandos SQL em consultas parametrizadas.

Incluindo dados

Para incluir dados o usuário vai clicar no botão Incluir do formulário Form1.cs e no evento Click deste botão vamos abrir o formulário Form2.cs para que o usuário informe os dados do novo aluno.

Veja como ficou o código do evento Click do botão Incluir no formulário Form1:

        private void btnIncluir_Click(object sender, EventArgs e)
        {
            try
            {
                Aluno _aluno = null;
                Form2 frm2 = new Form2(_aluno);
                frm2.ShowDialog();
                CarregaDados();
            }
            catch (Exception ex)
            {
                MessageBox.Show("Erro : " + ex.Message);
            }
       }

No código criamos uma instância do formulário Form2 e estamos passando um objeto aluno que esta definido como null.

Para tratar esse comportamento temos que alterar o construtor no Form2 incluindo o código mostrado a seguir:

  public partial class Form2 : Form
    {
        Aluno _aluno;
        string operacao = "";
        string connectionString = @"Data Source=C:\dados\SQLite\Cadastro.s3db";
        public Form2(Aluno aluno)
        {
            InitializeComponent();
            _aluno = aluno;
        }
        ...
        ...
  }

Este código define um objeto _aluno e atribui o valor recebido via construtor a esse objeto. Define também a string de conexão usada para acessar o banco de dados.

Logo após o construtor ser executado, temos o evento Load do formulário que vai verificar se o objeto aluno é null ou não para decidir qual a operação vai ser realizada : incluir ou alterar.

       private void Form2_Load(object sender, EventArgs e)
        {
            if (_aluno == null)
            {
                txtNome.Focus();
                operacao = "incluir";
            }
            else
            {
                operacao = "alterar";
                txtNome.Text = _aluno.nome;
                txtEmail.Text = _aluno.email;
                txtIdade.Text = _aluno.idade.ToString();
            }
        }

Observe que quando o objeto aluno não for null significa que vamos alterar os dados, e, para isso precisamos exibir os dados obtidos do DataGridView via objeto aluno nas caixas de texto.

A chamada para alterar os dados é feita quando o usuário clica no botão Alterar do formulário Form1, e, tem o seguinte código :

       private void btnAlterar_Click(object sender, EventArgs e)
        {
            try
            {
                Form2 frm2 = new Form2(GetDadosDoGrid());
                frm2.ShowDialog();
                CarregaDados();
            }
            catch (Exception ex)
            {
                MessageBox.Show("Erro : " + ex.Message);
            }
        }

Note que na instância de Form2() estamos invocando o método GetDadosDoGrid() que deve retornar um objeto aluno contendo os dados selecionados do DataGridView.

Veja o código deste método:

        private Aluno GetDadosDoGrid()
        {
            try
            {
                int linha;
                linha = dgvAlunos.CurrentRow.Index;
                Aluno aluno = new Aluno();
                aluno.Id = Convert.ToInt32(dgvAlunos[0, linha].Value);
                aluno.nome = dgvAlunos[1, linha].Value.ToString();
                aluno.email = dgvAlunos[2, linha].Value.ToString();
                aluno.idade = Convert.ToInt32(dgvAlunos[3, linha].Value);
                return aluno;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

Este código retorna um objeto aluno preenchido com os dados da seleção do grid.

O método CarregaDados() atualiza o conteúdo do controle DataGridView() e será chamado após qualquer alteração nos dados usando o método LeDados() que mostrei na primeira parte do artigo.

 private void CarregaDados()
 {
     dgvAlunos.DataSource = LeDados<SQLiteConnection, SQLiteDataAdapter>("Select * from Alunos");
 }

 

Então no formulário Form2 temos que definir os métodos para incluir e alterar dados.

Incluindo e Alterando dados no Form2

No formulário Form2.cs vamos definir os métodos IncluirDados() e AtualizaDados() que recebem um objeto aluno.

Aqui usamos uma instância da nossa classe de domínio e ao invés de passar valores primitivos como parâmetros passamos um objeto aluno.

Abaixo temo o código desses métodos :

public int IncluirDados(Aluno aluno)
{
    int resultado = -1;
    using (SQLiteConnection conn = new SQLiteConnection(connectionString))
    {
        conn.Open();
        using (SQLiteCommand cmd = new SQLiteCommand(conn))
        {
            cmd.CommandText = "INSERT INTO alunos(nome,email,idade) VALUES (@nome,@email,@idade)";
            cmd.Prepare();
            cmd.Parameters.AddWithValue("@nome", aluno.nome);
            cmd.Parameters.AddWithValue("@email", aluno.email);
            cmd.Parameters.AddWithValue("@idade", aluno.idade);
            try
            {
                resultado = cmd.ExecuteNonQuery();
            }
            catch (SQLiteException ex)
            {
                  throw ex;
             }
            finally
            {
                  conn.Close();
            }
        }
    }
   return resultado;
 }
 
  public int AtualizaDados(Aluno aluno)
  {
           int resultado = -1;
          using (SQLiteConnection conn = new SQLiteConnection(connectionString))
          {
              conn.Open();
              using (SQLiteCommand cmd = new SQLiteCommand(conn))
              {
                  cmd.CommandText = "UPDATE alunos SET nome=@nome, email=@email, idade=@idade WHERE Id = @id";
                  cmd.Prepare();
                  cmd.Parameters.AddWithValue("@Id", aluno.Id);
                  cmd.Parameters.AddWithValue("@nome", aluno.nome);
                  cmd.Parameters.AddWithValue("@email", aluno.email);
                  cmd.Parameters.AddWithValue("@idade", aluno.idade);
                  try
                  {
                      resultado = cmd.ExecuteNonQuery();
                  }
                  catch (SQLiteException ex)
                  {
                      throw ex;
                  }
                  finally
                  {
                      conn.Close();
                }
             }
         }
        return resultado;
  }

Esses métodos são chamados quando o usuário clica no botão Salvar do formulário Form2 cujo código vemos a seguir:

        private void btnSalvar_Click(object sender, EventArgs e)
        {
            if (ValidaDados())
            {
                Aluno aluno = new Aluno();
                aluno.Id = _aluno.Id;
                aluno.nome = txtNome.Text;
                aluno.email = txtEmail.Text;
                aluno.idade = Convert.ToInt32(txtIdade.Text);
                try
                {
                    if (operacao == "incluir")
                    {
                        if (IncluirDados(aluno) > 0)
                        {
                            MessageBox.Show("Dados incluídos com sucesso.");
                        }
                        else
                        {
                            MessageBox.Show("Os dados não foram incluídos.");
                        }
                    }
                    else
                    {
                        if (AtualizaDados(aluno) > 0)
                        {
                            MessageBox.Show("Dados atualizados com sucesso.");
                        }
                        else
                        {
                            MessageBox.Show("Os dados não foram atualizados.");
                        }
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show("Erro : " + ex.Message);
                }
            }
            else
            {
                MessageBox.Show("Dados inválidos.");
            }
    }

Primeiro verificamos se os dados informados nas caixas de texto são válidos (eu fiz uma validação bem simples, mas você pode incrementar isso):

     private Boolean ValidaDados()
     {
            bool retorno = true;
            if (txtNome.Text == string.Empty)
                retorno = false;
            if (txtEmail.Text == string.Empty)
                retorno = false;
            if (txtIdade.Text == string.Empty)
                retorno = false;
            return retorno;
     }

Se os dados forem válidos então o código verifica qual operação vai realizar chamando o respectivo método.

Excluindo dados

A exclusão de dados é feita no formulário Form1 após o usuário selecionar um registro do Grid e clicar no botão Excluir.

Abaixo temos o código do evento Click deste botão:

        private void btnExcluir_Click(object sender, EventArgs e)
        {
            try
            {
                DialogResult response = MessageBox.Show("Deseja deletar este registro ?", "Deletar linha",
                      MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2);
                if (response == DialogResult.Yes)
                {
                    DeletaDados(GetDadosDoGrid());
                    CarregaDados();
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show("Erro : " + ex.Message);
            }
        }

Após o usuário confirmar que deseja deletar o registro chamamos o método DeletaDados() passando o objeto aluno. Abaixo temo o código deste método:

        public int DeletaDados(Aluno aluno)
        {
            int resultado = -1;
            using (SQLiteConnection conn = new SQLiteConnection(connectionString))
            {
                conn.Open();
                using (SQLiteCommand cmd = new SQLiteCommand(conn))
                {
                    cmd.CommandText = "DELETE FROM alunos WHERE Id = @Id";
                    cmd.Prepare();
                    cmd.Parameters.AddWithValue("@Id", aluno.Id);
                    try
                    {
                        resultado = cmd.ExecuteNonQuery();
                    }
                    catch (SQLiteException ex)
                    {
                        throw ex;
                    }
                    finally
                    {
                        conn.Close();
                    }
                }
            }
            return resultado;
        }

Precisamos usar apenas o Id do aluno para realizar a exclusão dos dados.

Localizar dados

Para localizar dados o usuário informe o nome na caixa de texto e conforme vai digitando é realizada uma consulta dinâmica que filtra os registros de acordo com o critério informado.

Para realizar essa tarefa vamos usar o evento TextChanged da caixa de texto e chamar o método ProcurarDados() que retorna um DataTable e atualiza o DataGridView:

      private void txtCriterio_TextChanged(object sender, EventArgs e)
       {
            dgvAlunos.DataSource = ProcurarDados();
       }

No método ProcurarDados() estamos usando uma consulta SQL com a cláusula LIKE  passando como critério o que for digitado no TextBox:

   SELECT id, nome, email, idade from alunos WHERE nome LIKE '" + txtCriterio.Text + "%'";

As vezes os dados que você está desejando filtrar não têm uma ocorrência exata, ou você pretende realizar uma busca mais irrestrita. Para isso devemos usar a cláusula LIKE.

Supondo que desejamos filtrar todos os alunos que tenham o nome começado pelas letras Jos, Através da cláusula LIKE podemos inserir as letras desejadas e a SQL fará uma busca parcial pela string informada: Algo como:

SELECT nome FROM tblalunos WHERE nome LIKE "Jos%"

Isto retornará os possíveis nomes: José , Josué, Josimar, Josias, etc...

Código do método ProcurarDados() :

       private DataTable ProcurarDados()
        {
            string sql = "SELECT id, nome, email, idade from alunos WHERE nome LIKE '" + txtCriterio.Text + "%'";
            using (SQLiteConnection conn = new SQLiteConnection(connectionString))
            {
                conn.Open();
                using (SQLiteDataAdapter da = new SQLiteDataAdapter(sql, conn))
                {
                    try
                    {
                        DataTable dt = new DataTable();
                        da.Fill(dt);
                        return dt;
                    }
                    catch (SQLiteException ex)
                    {
                        throw ex;
                    }
                    finally
                    {
                        conn.Close();
                    }
                }
            }
        }

Esta abordagem pode e deve ser melhorada usando uma arquitetura em camadas e em breve vou mostrar em outro artigo como podemos fazer essa implementação.

Pegue o projeto completo aqui : CRUD_SQLite.zip (sem as referências)

Jesus lhes respondeu, e disse: A minha doutrina não é minha, mas daquele que me enviou.
Se alguém quiser fazer a vontade dele, pela mesma doutrina conhecerá se ela é de Deus, ou se eu falo de mim mesmo.
João 7:16-17

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

Quer aprender a criar aplicações Web Dinâmicas usando a ASP .NET MVC 5 ?

 

  Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

 

Referências:

José Carlos Macoratti