Referência: 1.1
A figura 1.1 mostra as classes e objetos criados dentro do sistema. Prestando atenção no diagrama existem classes que possui uma seta indo para outra classe. Explicarei mais a frente porque esse desenho e funcionamento do diagrama. O mesmo foi criado com o Visual Studio.NET 2005 depois de todas as classes criadas. Pode ser criado antes ou depois, não existe problema algum.
Os nomes das classes criados são de um motivo particular, adotei esse nome apenas para facilitar o entendimento.
DTO: todo nome de classe que no final estiver DTO são apenas atributos get’s e set’s do formulário da página, ou seja, os atributos serão enviados da camada de apresentação para a DTO.
DAO: todo nome de classe que no final estiver DAO, possuirá todo método responsável para inserir no banco de dados ou trazer dados. Por exemplo, usuarioDAO.cs, terá tudo sobre usuário para inserir, deletar ou atualizar no banco de dados.
Na figura 1.1, é mostrado duas setas de classes distintas. Isso quer dizer que, uma classe herda a outra classe. Quando uma classe é herdada de outra, a mesma recebe todos os atributos e podem ser acessadas normalmente, ou seja, como se estivesse em mesma classe.
Começando, mostrarei primeiramente a tabela do banco de dados e a STORE PROCEDURE que criei e estarei utilizando mais a frente. Veja a figura 1.2 de referência.
Referência: 1.2
O banco de dados é bem simples e com poucos campos para ser cadastrados. O nome do banco de dados não importa, podes colocar qualquer nome, porém o nome da tabela é TB_USU_TESTE.
A figura de referência 1.3 mostra a store procedure criada para inserir dados no banco de dados.
Referência: 1.3
Pronto, depois do banco de dados e STORE PROCEDURE criada, irei direto para a criação da classe BancoDados.cs onde possui todo o código para abrir e fechar o banco de dados.
Clicando com o botão direito, adicione um novo componente com o nome citado anteriormente e coloque o código abaixo. Não posso esquecer de importar a classe SqlClient para poder conectar no banco de dados.
using System;
using System.Data;
using System.Data.SqlClient;
/// <summary>
/// Classe de banco de dados
/// </summary>
public class BancoDados
{
protected SqlConnection sConn = new SqlConnection("Initial Catalog=BANCO DE DADOS; user id=USUARIO ;password=SENHA; Data Source=SERVIDOR DE BANCO DE DADOS");
/// <summary>
/// Metodo que conecta no banoc de dados
/// </summary>
#region conecta com o banco de dados
public void Conecta()
{
try
{
if (sConn.State==0)
{
sConn.Open();
}
}
catch(Exception e)
{
throw new Exception("Fora:"+ e.Message);
}
}
#endregion
/// <summary>
/// Metodo que desconecta no banco de dados
/// </summary>
#region desconecta com o banco de dados
public void Desconecta()
{
try
{
//if (sConn.State!=0)
//{
sConn.Close();
//}
}
catch(Exception e)
{
throw new Exception("Fora:"+ e.Message);
}
}
#endregion
}
Pronto, a classe de banco de dados criada, o próximo passo é criar uma classe que contém os campos do formulário que irá ser inserida no banco. Clicando com o botão direito, adicione um novo item ou classe chamada usuarioDTO.cs.
A figura 1.4 mostra a classe citada.
Referência: 1.4
Esta classe possui apenas as variáveis com get e set de cada uma.
Veja abaixo todos os atributos criados.
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
/// <summary>
/// Classe com atributos do form
/// </summary>
public class usuarioDTO
{
String nome;
String email;
String endereco;
String cep;
public String Email
{
get { return email; }
set { email = value; }
}
public String Endereco
{
get { return endereco; }
set { endereco = value; }
}
public String Cep
{
get { return cep; }
set { cep = value; }
}
public String Nome
{
get { return nome; }
set { nome = value; }
}
}
Pronto, depois da classe de atributos criada, irei criar o formulário, ou seja, a camada de apresentação para inserir os campos no banco de dados. Adicionei um novo item chamado Default.aspx, com alguns campos. Veja a figura 1.5.
Referência: 1.5
Segue abaixo todo código da pagina.
<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
<title>Untitled Page</title>
</head>
<body>
<form id="form1" runat="server">
<div>
Nome: <asp:TextBox ID="txtNome" runat="server"></asp:TextBox>
<br />
E-mail:
<asp:TextBox ID="txtEmail" runat="server"></asp:TextBox><br />
Endereço:
<asp:TextBox ID="txtEndereco" runat="server" Height="49px" TextMode="MultiLine" Width="189px"></asp:TextBox><br />
CEP:
<asp:TextBox ID="txtCEP" runat="server"></asp:TextBox><br />
<br />
<asp:Button ID="cmbGravar" runat="server" Text="Gravar" OnClick="cmbGravar_Click" /></div>
</form>
</body>
</html>
Veja a relação:
Nome: txtNome
E-mail: txtEmail
Endereço: txtEndereco
Cep: txtCEP
Botão Gravar: cmdGravar
A figura 1.6 mostra como ficará a página que acabou de ser criada.
Referência: 1.6
Não ligue para o layout por enquanto, estou focando esse artigo para a OO (Orientação a Objetos) e o funcionamento. Espero que até aqui esteja ainda tudo claro para você leitor.
Clicando com o botão direito no mouse em cima do projeto, adicionei um nome componente, chamado usuarioDAO.cs. Essa classe é responsável para inserir os valores dentro do banco de dados, ou seja, a camada de negócio do sistema.
A figura 1.7 mostra a classe citada anteriormente criada.
Referência: 1.7
Veja o código da classe usuarioDAO.cs.
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Data.SqlClient;
/// <summary>
/// classe que insere usuario no banco de dados, chama de DAO
/// </summary>
public class usuarioDAO : BancoDados
{
/// <summary>
/// insere usuario no banco de dados
/// </summary>
/// <param name="usuario"></param>
public Boolean insereUsuarioDAO(usuarioDTO usuario)
{
try
{
getConection();
insereUsuarioNoBanco(usuario);
return true;
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
/// <summary>
/// metodo para inserir usuario no banco de dados
/// </summary>
/// <param name="usuario"></param>
private Boolean insereUsuarioNoBanco(usuarioDTO usuario)
{
try
{
SqlCommand sqlc = new SqlCommand("SP001_INSERE_USUARIO_TESTE", sConn);
sqlc.CommandType = CommandType.StoredProcedure;
atribuirValores(usuario, sqlc);
sqlc.ExecuteNonQuery();
return true;
}
catch (SqlException e)
{
throw new Exception(e.Message);
}
finally
{
getConectionOut();
}
}
/// <summary>
/// atribuir valores vindo do objeto
/// </summary>
/// <param name="usuario"></param>
/// <param name="sqlc"></param>
private static void atribuirValores(usuarioDTO usuario, SqlCommand sqlc)
{
sqlc.Parameters.AddWithValue("@NO_USU", usuario.Nome);
sqlc.Parameters.AddWithValue("@EMAIL_USU", usuario.Email);
sqlc.Parameters.AddWithValue("@END_USU", usuario.Endereco);
sqlc.Parameters.AddWithValue("@CEP_USU", usuario.Cep);
}
/// <summary>
/// metodo que conecta no banco de dados;
/// </summary>
public void getConection()
{
Conecta();
}
/// <summary>
/// metodo que desconecta do banco de dados
/// </summary>
public void getConectionOut()
{
Desconecta();
}
}
Explicando o código acima:
Primeiramente irei analisar a assinatura da classe.
public class usuarioDAO : BancoDados
Se você estiver pensando, “que coisa estranha esse dois pontos”. Não é estranho, é normal, essa classe está herdando atributos da classe BancoDados. Estou usando uma parte da orientação a objetos chamada herança, ou seja, tudo que estiver em outra classe poderá ser usada na classe usuarioDAO.
O método principal dessa classe é o seguinte:
/// <summary>
/// insere usuario no banco de dados
/// </summary>
/// <param name="usuario"></param>
public Boolean insereUsuarioDAO(usuarioDTO usuario)
{
try
{
getConection();
insereUsuarioNoBanco(usuario);
return true;
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
É bem pequeno esse método, porém dentro do bloco try, é utilizado vários métodos dessa mesma classe. Analisando a assinatura do método, vejo que é um método público, retorna um tipo de objeto Boolean, ou seja, true ou false e recebe um objeto chamado usuarioDTO como parâmetro. Se não estás entendendo, calma que está chegando a hora certa para entender. Dentro da classe e do bloco try é chamado um método getConection().
/// <summary>
/// metodo que conecta no banco de dados;
/// </summary>
public void getConection()
{
Conecta();
}
Esse método cima é apenas para conectar ao banco de dados. Veja que o mesmo está chamando um outro método de dentro da classe BancoDados.cs. Não esqueça que o mesmo está sendo herdado de outra classe.
O próximo método chamado é o insereUsuarioNoBanco(usuario); passando o parâmetro usuário como parâmetro.
/// <summary>
/// metodo para inserir usuario no banco de dados
/// </summary>
/// <param name="usuario"></param>
private Boolean insereUsuarioNoBanco(usuarioDTO usuario)
{
try
{
SqlCommand sqlc = new SqlCommand("SP001_INSERE_USUARIO_TESTE", sConn);
sqlc.CommandType = CommandType.StoredProcedure;
atribuirValores(usuario, sqlc);
sqlc.ExecuteNonQuery();
return true;
}
catch (SqlException e)
{
throw new Exception(e.Message);
}
finally
{
getConectionOut();
}
}
Para quem é experiente com .NET, pode perceber que separei todos os métodos de uma classe em partes pequenas para serem melhores gerenciados e para melhor manutenção. Separando dessa forma, poderei mudar qualquer método sem que um dependa do outro, ou seja, fica a independência de código ou de métodos.
Esse método insereUsuarioNoBanco(usuarioDTO usuário) mostra que está sendo usado uma STORE PROCEDURE como sql. O tipo de comando é StoreProcedure. A próxima linha, veja que é um método também criado chamado atribuirValores(usuario, sqlc). Esse método é apenas para adicionar os valores passados dentro do comando para ser executado.
Veja o método atribuirValores.
/// <summary>
/// atribuir valores vindo do objeto
/// </summary>
/// <param name="usuario"></param>
/// <param name="sqlc"></param>
private static void atribuirValores(usuarioDTO usuario, SqlCommand sqlc)
{
sqlc.Parameters.AddWithValue("@NO_USU", usuario.Nome);
sqlc.Parameters.AddWithValue("@EMAIL_USU", usuario.Email);
sqlc.Parameters.AddWithValue("@END_USU", usuario.Endereco);
sqlc.Parameters.AddWithValue("@CEP_USU", usuario.Cep);
}
Esse método receber o objeto usuarioDTO e o SqlCommand apenas para adicionar como PARAMETERS de um sql. Continuando, a próxima linha do método insereUsuarioNoBanco apenas executa o sqlc, fazendo assim uma inserção no banco de dados dos valores passados.
Dentro do bloco finally, estou usando um outro método criado para fechar a conexão com o banco de dados.
/// <summary>
/// metodo que desconecta do banco de dados
/// </summary>
public void getConectionOut()
{
Desconecta();
}
Até agora não vimos como esse parâmetro vai ser passado né, irei mostrar agora.
Esses valores irão ser passados da camada de apresentação.
Abra o arquivo default.aspx e clique duas vezes no botão GRAVAR.
O código abaixo mostrará como ficará o código.
protected void cmbGravar_Click(object sender, EventArgs e)
{
usuarioDAO dao = new usuarioDAO();
usuarioDTO dto = new usuarioDTO();
setValores(dto);
if (dao.insereUsuarioDAO(dto))
{
Response.Redirect("resultadoFinal.aspx");
}
else
{
Response.Redirect("resultadoFinalErro.asp");
}
}
Explicando o código acima:
As duas primeiras linhas; estou apenas instanciando as duas classes e colocando uma variável para cada uma. Uma chamada dao e outra dto. Logo depois criei um método chamado setValores(dto) passando a dto como parâmetro. Veja o código abaixo:
/// <summary>
/// metodo para atribuir valores
/// </summary>
/// <param name="dto">objeto dto</param>
private void setValores(usuarioDTO dto)
{
dto.Nome = txtNome.Text;
dto.Endereco = txtEndereco.Text;
dto.Email = txtEmail.Text;
dto.Cep = txtCEP.Text;
}
Esse método apenas seta os valores dos textBox para dentro da dto.
Continuando com o código segue as linhas abaixo.
if (dao.insereUsuarioDAO(dto))
{
Response.Redirect("resultadoFinal.aspx");
}
else
{
Response.Redirect("resultadoFinalErro.asp");
}
Colocando a variável criada seguindo do (ponto), escolho o insereUsuarioDAO passando a dto preenchida. Dessa forma, todos os valores serão passados para a classe.
Clicando F5 para iniciar o sistema veja como os dados serão inseridos no banco de dados. Veja a figura 1.8.
Referência: 1.8
Preencha os campos e clique gravar. Logo depois podes olhar diretamente no banco de dados se os mesmos foram inseridos. Se quiser, podes colocar um break para ir seguindo em cada método.
Não mostrarei esses passos para o artigo não ficar maior ainda.
Depois de preencher os dados e clicar no botão, dando tudo certo, o sistema redirecionará para a página de sucesso. Criei duas páginas só para mostrar que foi inserido com sucesso ou se deu erro, irá para outra página. O nome das duas páginas é: resultadoFinal.aspx e resultadoFinalErro.aspx.
Veja a figura 1.9.
Referência: 1.9
Esse artigo não termina aqui. O passo dois; mostrarei como depois de cadastrar os dados passar e-mail para o usuário cadastrado e para o administrador do sistema, isso tudo automaticamente. No final desse artigo parte 2, estarei disponibilizando o código fonte do sistema criado.
Espero que tenha gostado, qualquer duvida só mandar e-mail para:
mauricio@ascompras.com.br
mauricio@aspneti.com.br
Mauricio Junior