Este artigo é a terceira parte do projeto Loja em C#.Net, e agora iremos implementar a camada de acesso a dados.
- Primeira parte, a criação da base de dados em SQL Server;
- Segunda parte, a criação do projeto e a camada modelo.
Criando o Projeto DAL no Visual Studio
Abra o Visual Studio, e abra seu projeto Model, clique com o botão direito em Solution Model, depois em Add, clique em New Project, conforme a figura a seguir:
Na janela New
Project, no lado esquerdo, expanda Templates, depois Visual C#, e clique
em Windows. No lado direito escolha Class Library, dê o nome de DAL, dê OK. Obs: Não crie o projeto no mesmo caminho que o Projeto Model. Veja a figura a
seguir:
O Solution Explorer ficará conforme a figura a seguir:
Agora renomeie a solução para Loja, conforme a figura a seguir:
O projeto DAL precisa reutilizar tudo que criamos no projeto Model, e isso é possível adicionando uma referência, expanda References, clique com o botão direito e escolha Add Reference, conforme a figura a seguir:
A janela Reference Manager será aberta, do lado esquerdo, expanda Solution e clique em Projects. Do lado direito aparecerá os projetos, marque a caixa de seleção referente ao projeto Model, e clique em OK. Veja a figura a seguir:
Se não houve problema algum, o projeto Model aparecerá em References conforme a figura a seguir:
Agora está tudo pronto para implementarmos as classes de acesso a dados. Clique com o botão direito em Class1.cs e clique em Rename, dê o nome de Dados. Abra a classe Dados.cs, altere o namespace para Loja.DAL, e em seguira implemente o método String de Conexao:
public static string StringDeConexao
{
get
{
return "server=(localdb)\\Projects;database=Loja;Trusted_Connection=True";
}
}
Obs: A string de conexão precisa ser a mesma mostrada no painel SQL Server Object Explorer, se não a string estiver errada haverá erro no decorrer do tutorial.
A figura a seguir mostra a classe Dados.cs e suas alterações, veja:
Vá ao Solution Explorer, clique com o botão direito em DAL, vá em Add, e clique em Class, dê o nome de ClientesDAL, clique em Add.
Altere o namespace para Loja.DAL, adicione a palavra reservada public a classe, e para visualizar o projeto Model dentro da classe ClientesDAL, adicione a cláusula using Loja.Model, conforme a figura a seguir:
A classe ClientesDAL.cs está pronta para ser implementada e começaremos pelo método Incluir usado para inserir um registro no banco de dados, copie o código a seguir:
public void incluir(ClienteInformation cliente)
{
//conexao
SqlConnection cn = new SqlConnection();
try
{
cn.ConnectionString = Dados.StringDeConexao;
//command
SqlCommand cmd = new SqlCommand();
cmd.Connection = cn;
cmd.CommandType = CommandType.StoredProcedure;
//nome da stored procedure
cmd.CommandText = "insere_cliente";
//parâmetro código da stored procedure
SqlParameter pcodigo = new SqlParameter("@codigo", SqlDbType.Int);
pcodigo.Direction = ParameterDirection.Output;
cmd.Parameters.Add(pcodigo);
//parâmetro nome da stored procedure
SqlParameter pnome = new SqlParameter("@nome", SqlDbType.NVarChar, 100);
pnome.Value = cliente.Nome;
cmd.Parameters.Add(pnome);
//parâmetro email da stored procedure
SqlParameter pemail = new SqlParameter("@email", SqlDbType.NVarChar, 100);
pemail.Value = cliente.Email;
cmd.Parameters.Add(pemail);
//parâmetro telefone da stored procedure
SqlParameter ptelefone = new SqlParameter("@telefone", SqlDbType.NVarChar, 80);
ptelefone.Value = cliente.Telefone;
cmd.Parameters.Add(ptelefone);
//Abre a conexão
cn.Open();
//Executa o comando
cmd.ExecuteNonQuery();
cliente.Codigo = (Int32)cmd.Parameters["@codigo"].Value;
}
catch (SqlException ex)
{
//Se houver algum erro com a conexão, exibirá a mensagem de exceção SQL
throw new Exception("Servidor SQL Erro:" + ex.Number);
}
catch (Exception ex)
{
//Se houver algum erro, exibirá a mensagem de exceção
throw new Exception(ex.Message);
}
finally
{
//Fecha a conexão
cn.Close();
}
}
Agora vamos ao método Alterar usado para alterar um registro no banco de dados, copie o código a seguir:
public void alterar(ClienteInformation cliente)
{
//conexao
SqlConnection cn = new SqlConnection();
try
{
cn.ConnectionString = Dados.StringDeConexao;
//command
SqlCommand cmd = new SqlCommand();
cmd.Connection = cn;
cmd.CommandType = CommandType.StoredProcedure;
//nome da stored procedure
cmd.CommandText = "altera_cliente";
//parâmetro código da stored procedure
SqlParameter pcodigo = new SqlParameter("@codigo", SqlDbType.Int);
pcodigo.Value = cliente.Codigo;
cmd.Parameters.Add(pcodigo);
//parâmetro nome da stored procedure
SqlParameter pnome = new SqlParameter("@nome", SqlDbType.NVarChar, 100);
pnome.Value = cliente.Nome;
cmd.Parameters.Add(pnome);
//parâmetro email da stored procedure
SqlParameter pemail = new SqlParameter("@email", SqlDbType.NVarChar, 100);
pemail.Value = cliente.Email;
cmd.Parameters.Add(pemail);
//parâmetro telefone da stored procedure
SqlParameter ptelefone = new SqlParameter("@telefone", SqlDbType.NVarChar, 80);
ptelefone.Value = cliente.Telefone;
cmd.Parameters.Add(ptelefone);
cn.Open();
cmd.ExecuteNonQuery();
}
catch (SqlException ex)
{
throw new Exception("Servidor SQL Erro:" + ex.Number);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
cn.Close();
}
}
Próximo método é o Excluir que irá remover o registro no banco de dados:
public void excluir(int codigo)
{
//conexao
SqlConnection cn = new SqlConnection();
try
{
cn.ConnectionString = Dados.StringDeConexao;
//command
SqlCommand cmd = new SqlCommand();
cmd.Connection = cn;
cmd.CommandType = CommandType.StoredProcedure;
//nome da stored procedure
cmd.CommandText = "exclui_cliente";
//parâmetro código da stored procedure
SqlParameter pcodigo = new SqlParameter("@codigo", SqlDbType.Int);
pcodigo.Value = codigo;
cmd.Parameters.Add(pcodigo);
cn.Open();
int resultado = cmd.ExecuteNonQuery();
if (resultado != 1)
{
throw new Exception("Não foi possível excluir o cliente " + codigo);
}
}
catch (SqlException ex)
{
throw new Exception("Servidor SQL Erro:" + ex.Number);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
cn.Close();
}
}
E finalmente o método Listagem que exibirá os registros do banco de dados, copie o código:
public DataTable Listagem(string filtro)
{
SqlConnection cn = new SqlConnection();
SqlDataAdapter da = new SqlDataAdapter();
DataTable dt = new DataTable();
try
{
cn.ConnectionString = Dados.StringDeConexao;
//adapter
da.SelectCommand = new SqlCommand();
da.SelectCommand.CommandText = "seleciona_cliente";
da.SelectCommand.Connection = cn;
da.SelectCommand.CommandType = CommandType.StoredProcedure;
//parâmetros da stored procedure
SqlParameter pfiltro;
pfiltro = da.SelectCommand.Parameters.Add("@filtro", SqlDbType.Text);
pfiltro.Value = filtro;
da.Fill(dt);
return dt;
}
catch (SqlException ex)
{
throw new Exception("Servidor SQL Erro:" + ex.Number);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
cn.Close();
}
}
A classe ClientesDAL.cs está pronta, se houver algum erro reveja os passos.
Agora iremos criar a próxima classe, clique com o botão direito no projeto DAL, vá a Add, e clique em Class.., dê o nome de ProdutosDAL e clique em Add.
Adicione a cláusula using Loja.Model, altere o namespace para Loja.DAL e adicione a palavra reservada public, igual foi feito na classe ClientesDAL.cs.
A classe ProdutosDAL está pronta para ser implementada, e começamos com o método ProdutosEmFalta, copie o código a seguir:
public ArrayList ProdutosEmFalta()
{
SqlConnection cn = new SqlConnection(Dados.StringDeConexao);
SqlCommand cmd = new SqlCommand("Select * from Produtos Where Estoque < 10", cn);
cn.Open();
SqlDataReader dr = cmd.ExecuteReader();
ArrayList lista = new ArrayList();
while (dr.Read())
{
ProdutoInformation produto = new ProdutoInformation();
produto.Codigo = Convert.ToInt32(dr["codigo"]);
produto.Nome = dr["nome"].ToString();
produto.Estoque = Convert.ToInt32(dr["estoque"]);
produto.Preco = Convert.ToDecimal(dr["preco"]);
lista.Add(produto);
}
dr.Close();
cn.Close();
return lista;
}
Próximo método é o incluir:
public void incluir(ProdutoInformation produto)
{
//conexao
SqlConnection cn = new SqlConnection();
try
{
cn.ConnectionString = Dados.StringDeConexao;
//command
SqlCommand cmd = new SqlCommand();
cmd.Connection = cn;
cmd.CommandText = "insert into Produtos(nome, preco, estoque) values (@nome, @preco, @estoque); select @@IDENTITY;";
cmd.Parameters.AddWithValue("@nome", produto.Nome);
cmd.Parameters.AddWithValue("@preco", produto.Preco);
cmd.Parameters.AddWithValue("@estoque", produto.Estoque);
cn.Open();
produto.Codigo = Convert.ToInt32(cmd.ExecuteScalar());
}
catch (SqlException ex)
{
throw new Exception("Servidor SQL Erro:" + ex.Number);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
cn.Close();
}
}
Próximo método é o alterar:
public void alterar(ProdutoInformation produto)
{
//conexao
SqlConnection cn = new SqlConnection();
try
{
cn.ConnectionString = Dados.StringDeConexao;
//command
SqlCommand cmd = new SqlCommand();
cmd.Connection = cn;
cmd.CommandType = CommandType.Text;
cmd.CommandText = "update Produtos set nome = @nome, preco = @nome, estoque = @estoque where codigo = @codigo;";
cmd.Parameters.AddWithValue("@codigo", produto.Codigo);
cmd.Parameters.AddWithValue("@nome", produto.Nome);
cmd.Parameters.AddWithValue("@preco", produto.Preco);
cmd.Parameters.AddWithValue("@estoque", produto.Estoque);
cn.Open();
cmd.ExecuteNonQuery();
}
catch (SqlException ex)
{
throw new Exception("Servidor SQL Erro:" + ex.Number);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
cn.Close();
}
}
Próximo método é o excluir:
public void excluir(int codigo)
{
//conexao
SqlConnection cn = new SqlConnection();
try
{
cn.ConnectionString = Dados.StringDeConexao;
//command
SqlCommand cmd = new SqlCommand();
cmd.Connection = cn;
cmd.CommandText = "delete from Produtos where codigo = " + codigo;
cn.Open();
int resultado = cmd.ExecuteNonQuery();
if (resultado != 1)
{
throw new Exception("Não foi possível excluir o produto " + codigo);
}
}
catch (SqlException ex)
{
throw new Exception("Servidor SQL Erro:" + ex.Number);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
cn.Close();
}
}
E por último o método Listagem:
public DataTable listagem(string filtro)
{
DataTable tabela = new DataTable();
string strSql;
if (filtro == "")
{
strSql = "select * from produtos";
}
else
{
strSql = "select * from produtos where nome like '%" + filtro + "%'";
}
SqlDataAdapter da = new SqlDataAdapter(strSql, Dados.StringDeConexao);
da.Fill(tabela);
return tabela;
}
A classe ProdutosDAL.cs está pronta, se houver algum erro reveja os passos.
Agora
iremos criar a próxima classe, clique com o botão direito no projeto
DAL, vá a Add, e clique em Class.., dê o nome de VendasDAL e clique em
Add.
Adicione a cláusula using
Loja.Model, altere o namespace para Loja.DAL e adicione a palavra
reservada public, igual foi feito na classe ClientesDAL.cs e ProdutosDAL.cs.
A classe VendasDAL está pronta para ser implementada, e começamos com o método ListaDeProdutos, copie o código a seguir:
public DataTable ListaDeProdutos
{
get
{
SqlConnection cn = new SqlConnection();
cn.ConnectionString = Dados.StringDeConexao;
cn.Open();
SqlDataAdapter da = new SqlDataAdapter("select * from produtos", cn);
DataTable dt = new DataTable();
da.Fill(dt);
cn.Close();
return dt;
}
}
//Propriedade que retorna uma lista de clientes
public DataTable ListaDeClientes
{
get
{
SqlConnection cn = new SqlConnection();
cn.ConnectionString = Dados.StringDeConexao;
cn.Open();
SqlDataAdapter da = new SqlDataAdapter("select * from clientes", cn);
DataTable dt = new DataTable();
da.Fill(dt);
cn.Close();
return dt;
}
}
Próximo método é o incluir:
public void incluir(VendaInformation venda)
{
//conexao
SqlConnection cn = new SqlConnection();
SqlTransaction t = null;
try
{
cn.ConnectionString = Dados.StringDeConexao;
//command
SqlCommand cmd1 = new SqlCommand();
cmd1.Connection = cn;
cmd1.CommandText = @"insert into vendas(CodigoCliente, CodigoProduto, Data, Quantidade, Faturado)
VALUES(@CodigoCliente, @CodigoProduto, @Data, @Quantidade, @Faturado);
select @@IDENTITY;";
SqlCommand cmd2 = new SqlCommand();
cmd2.Connection = cn;
cmd2.CommandText = @"update Produtos SET estoque = estoque - @quantidade where codigo=@codigoProduto";
cn.Open();
//Default
t = cn.BeginTransaction(IsolationLevel.Serializable);
cmd1.Transaction = t;
cmd2.Transaction = t;
cmd1.Parameters.AddWithValue("@codigocliente", venda.CodigoCliente);
cmd1.Parameters.AddWithValue("@codigoproduto", venda.CodigoProduto);
cmd1.Parameters.AddWithValue("@data", venda.Data);
cmd1.Parameters.AddWithValue("@quantidade", venda.Quantidade);
cmd1.Parameters.AddWithValue("@faturado", venda.Faturado);
cmd2.Parameters.AddWithValue("@quantidade", venda.Quantidade);
cmd2.Parameters.AddWithValue("@codigoproduto", venda.CodigoProduto);
venda.Codigo = Convert.ToInt32(cmd1.ExecuteScalar());
cmd2.ExecuteNonQuery();
t.Commit();
}
catch (Exception ex)
{
t.Rollback();
throw new Exception("Erro no servidor:" + ex.Message);
}
finally
{
cn.Close();
}
}
}
Agora a classe VendasDAL está pronta, vá ao Solution Explorer, clique com o botão direito em DAL, e clique em Build. O visual Studio irá compilar a solução.
Próximo passo é criar o projeto BLL com as regras de negócio do projeto, até mais.