C#
- Cadastro de Clientes com Entity Framework em Camadas - III
C#
- Cadastro de Clientes com Entity Framework em Camadas - III
Se você esta chegando agora precisa saber que:
Vamos agora definir a interface e o código necessário para usar os recursos do Entity Framework em camadas e por a aplicação par funcionar.
Definindo a camada de Interface
Resta agora definir a interface no projeto Windows Forms chamado UI através do formulário form1.cs.
A figura abaixo mostra novamente o formulário contendo os controles para TextBox, DataGridView e os botões de comando onde no evento Click definiremos o código para realizar as operações CRUD;
 |
Devemos copiar o arquivo App.Config para o projeto UI para que possamos acessar os recursos do Entity Data Model.
Devemos também definir uma referência no projeto UI ao projeto DAL. Selecione a solução, e em propriedades do projeto escolha Project Dependencies, escolha o projeto UI e marque a opção DAL;
 |
Assim teremos acesso aos métodos criados na camada de acesso a dados.
Vamos agora definir cada uma das operações associadas com respectivo botão de comando usando os eventos dos controles.
Primeiro devemos definir os namespaces que iremos usar no formulário:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using DAL;
A seguir devemos
declarar as variáveis registro e clientes respectivamente do tipo
Cliente e ClientesDAL:
Cliente registro;
ClientesDAL clientes;
1 - Evento Load do formulário
/// <summary>
/// Evento Load do formulário
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Form1_Load(object sender, EventArgs e)
{
clientes = new ClientesDAL();
registro = new Cliente();
List<Cliente> resultado = clientes.GetAll();
dgvClientes.DataSource = resultado.ToList();
int codigo = Convert.ToInt32(dgvClientes.Rows[0].Cells[0].Value);
if (codigo > 0 )
{
Cliente cli = clientes.GetRegistroPorCodigo(codigo);
preencheControles(cli);
}
}
|
No evento Load criamos uma instância da nossa classe de acesso a dados e do nosso objeto cliente e primeiro preenchemos o controle DataGridView com todos os clientes usando o método GetAll();
A seguir obtemos o código do cliente do Grid e obtemos uma única entidade cliente usando o método GetRegistroPorCodigo() passando o código do cliente;
Para exibir os dados no formulário invocamos a rotina preencheControles(cli) passando a entidade cliente retornada;
2 - A rotina preencheControles:
/// <summary>
/// preencheControles do formulário com dados
/// </summary>
/// <param name="cliente"></param>
private void preencheControles(Cliente cliente)
{
txtID.Text = cliente.id.ToString();
txtNome.Text = cliente.nome;
txtEndereco.Text = cliente.endereco;
txtCep.Text = cliente.cep;
txtCidade.Text = cliente.cidade;
txtCelular.Text = cliente.celular;
txtTelefone.Text = cliente.telefone;
txtEmail.Text = cliente.email;
txtContato.Text = cliente.contato;
txtObs.Text = cliente.obs;
}
|
Esta rotina apenas recebe uma entidade e preenche os controles do formulário com as respectivas informações.
3 - Código do evento CellEnter do controle DataGridView:
/// <summary>
/// Evento CellEnter
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void dgvClientes_CellEnter(object sender, DataGridViewCellEventArgs e)
{
int codCliente = Convert.ToInt32(dgvClientes.Rows[e.RowIndex].Cells[0].Value);
Cliente resultado = clientes.GetRegistroPorCodigo(codCliente);
preencheControles(resultado);
}
|
O evento CellEnter ocorre quando a célula atual sofre alteração ou recebe o foco. Usamos esse evento para obter o código do cliente da linha selecionada do Grid.
Em seguida usamos o método GetRegistroPorCodigo() passando o código obtido no evento e preenchemos os controles do formulário com os dados da entidade obtida via rotina preencheControles.
4 - O código do evento Click do botão Incluir:
/// <summary>
/// Evento Click do botão Incluir
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnIncluir_Click(object sender, EventArgs e)
{
limparControles(this);
txtNome.Focus();
btnSalvar.Visible = true;
}
|
O código limpa os controles chamando a rotina limparControles() , põe o foco no TextBox do Nome do cliente e exibe o botão Salvar.
5 - Código do evento Click do botão Excluir:
/// <summary>
/// Excluir registro
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnExcluir_Click(object sender, EventArgs e)
{
DialogResult resposta = MessageBox.Show("Deseja excluir este registro?", "Excluir", MessageBoxButtons.YesNo);
switch (resposta)
{
case DialogResult.Yes:
clientes = new ClientesDAL();
registro = new Cliente();
registro.id = Convert.ToInt32(txtID.Text);
if (clientes.DeleteRegistro(registro))
{
MessageBox.Show("Registro excluido com sucesso");
}
else
{
MessageBox.Show("Erro ao excluir o registro");
}
break;
case DialogResult.No:
break;
}
}
|
Neste código após o cliente confirmar a exclusão criamos uma instância da nossa classe de acesso a dados e do nosso objeto cliente usamos o método DeleteRegistro() , e pós obtermos o id da entidade passamos a entidade que desejamos remover para o método.
6 - Código do evento Click do botão Atualizar :
/// <summary>
/// Botão atualizar
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnAtualizar_Click(object sender, EventArgs e)
{
clientes = new ClientesDAL();
registro = new Cliente();
atualizaRegistro(registro);
if (clientes.UpdateRegistro(registro))
{
MessageBox.Show("Registro atualizado com sucesso");
}
else
{
MessageBox.Show("Erro ao atualizar o registro");
}
}
|
Neste código após criarmos uma instância da nossa classe de acesso a dados e do nosso objeto cliente chamamos a rotina atualizaRegistro() para que nossa entidade Cliente seja atualizada com os dados do formulário.
A seguir usamos o método UpdateRegistro passando a entidade já com as informações para atualizar a entidade.
7- Código do evento Click do botão Salvar:
/// <summary>
/// Salva os registros
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnSalvar_Click(object sender, EventArgs e)
{
clientes = new ClientesDAL();
registro = new Cliente();
if (validaDados())
{
atualizaRegistro(registro);
int retorno = clientes.SaveRegistro(registro);
if (retorno > 0)
{
MessageBox.Show("Registro atualizado com sucesso");
}
else
{
MessageBox.Show("Erro ao atualizar o registro");
}
}
else
{
MessageBox.Show("Dados Inválidos...");
}
btnSalvar.Visible = false;
}
|
Neste código após criarmos uma instância da nossa classe de acesso a dados e do nosso objeto cliente chamamos a rotina Validados() que irá verificar se os dados informados no formulário são válidos.
Em seguida preenchemos a entidade Cliente com os dados do formulário usando a rotina atualizaRegistro e usamos o método SaveRegistro() para salvar a entidade.
8- Código da rotina atualizaRegistro():
/// <summary>
/// atualizaRegistro
/// </summary>
/// <param name="cliente"></param>
private void atualizaRegistro(Cliente cliente)
{
cliente.nome = txtNome.Text;
cliente.endereco = txtEndereco.Text;
cliente.cep = txtCep.Text;
cliente.cidade = txtCidade.Text;
cliente.celular = txtCelular.Text;
cliente.telefone = txtTelefone.Text;
cliente.email = txtEmail.Text;
cliente.contato = txtContato.Text;
cliente.obs = txtObs.Text;
}
|
Neste código atualizamos a entidade com as informações do formulário.
9 - Código da rotina validaDados e limparControles:
/// <summary>
/// validaDados
/// </summary>
/// <returns></returns>
private bool validaDados()
{
if (txtNome.Text == string.Empty || txtEndereco.Text == String.Empty || txtEmail.Text == string.Empty)
{
return false;
}
else
{
return true;
}
}
/// <summary>
/// limparControles
/// </summary>
/// <param name="control"></param>
private void limparControles(Control control)
{
foreach (Control textBox in control.Controls)
{
if (textBox is TextBox)
{
((TextBox)textBox).Text = string.Empty;
}
}
}
|
A rotina validaDados faz uma validação (bem simples por sinal) e retorna true ou false.
A rotina limpar Controles limpa os controles TextBox do formulário.
Executando o projeto iremos obter o seguinte resultado:
 |
Com isso temos nossa aplicação totalmente funcional preparada para realizar as operações CRUD usando o Entity Framework em uma camada de acesso a dados.
Como exercício deixo para você criar a camada de negócios.
O projeto completo com os fontes abertos está no Super DVD .NET.
Eu sei é apenas C#, mas eu gosto...
Referências: