Visual Studio .NET

Propaganda
Visual Studio .NET - C#
Parte 1 – Fundamentos e ASP.Net
Cláudio Luís Vieira Oliveira
[email protected]
1
Visual Studio .NET – C#
•Conteúdo
IDE do Visual Studio .NET
Tipo de Dados
Introdução à Orientação a Objetos
Sintaxe do C#
Construção de Aplicações para a WEB
Programação em Camadas
Acesso ao Banco de Dados
2
1
Visual Studio .NET – C#
IDE do Visual Studio .NET
Um IDE, do inglês Integrated Development Environment
ou Ambiente Integrado de Desenvolvimento, é um
programa de computador que reúne características e
ferramentas de apoio ao desenvolvimento de programas.
Oferece suporte ao RAD (de Rapid Application
Development,
ou
"Desenvolvimento
Rápido
de
Aplicativos"), visando uma maior produtividade no
desenvolvimento de aplicações.
3
Visual Studio .NET – C#
Projetos e soluções
Um Projeto (Project) pode ser entendido como um grupo
de classes e formulários organizados. Por outro lado, uma
Solução (Solution) é um grupo de projetos. Um sistema
pode ter uma ou mais soluções que, por sua vez,
possuem um ou mais projetos.
4
2
Visual Studio .NET – C#
Criação de um projeto
Escolher no menu principal a opção File, New e depois
Project:
Selecionar
o tipo de
aplicação
Especificar
nome e
localização
5
Visual Studio .NET – C#
Criação de um projeto
O primeiro exemplo irá consistir em uma “Console
Application” e terá o nome de Exemplo01:
6
3
Visual Studio .NET – C#
Construção da aplicação
Acrescentar as seguintes linhas ao método Main:
using System;
using System.Collections.Generic;
using System.Text;
namespace Exemplo01
{
class Program
{
static void Main(string[] args)
{ Console.WriteLine("Olá Pessoal!");
Console.ReadKey();
}
}
}
7
Visual Studio .NET – C#
Compilação e execução da aplicação
Após concluir o programa, gravar as alterações
realizadas. Em seguida, a solução deverá ser compilada,
para isso, utilizar a opção do menu Build e depois Build
Solution, também pode-se utilizar a tecla de atalho F6.
Observar na parte inferior da IDE se ocorreram erros ou
avisos.
Quando a compilação não apresentar erros a mesma
poderá ser executada através do menu Debug utilizando
os itens Start Debugging (F5) ou Start Without Debugging
(Ctrl + F5).
8
4
Visual Studio .NET – C#
Tipos de dados
Os principais tipos de dados utilizados em C# são: string,
int, float e double. Sendo que a classe Convert pode ser
utilizada para realizar a conversão entre eles.
int a = 20, c;
string b = "10";
c = a + Convert.ToInt32(b);
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("A soma de {0} com {1} é igual a {2}",
a, b, c);
Console.ReadKey();
9
Visual Studio .NET – C#
Entrada de dados
A classe Console possibilita a entrada de dados através
do método ReadLine(). Porém, é importante observar que
a entrada de dados é sempre realizada através de cadeias
de caracteres (string) e depois, deve ser convertida para o
tipo de dados desejado.
int a, c;
string b;
Console.Write("Digite A: ");
a = Convert.ToInt32(Console.ReadLine());
Console.Write("Digite B: "); b = Console.ReadLine();
c = a + Convert.ToInt32(b);
Console.WriteLine("A soma de {0} com {1} é igual a {2}",
a, b, c);
Console.ReadKey();
10
5
Visual Studio .NET – C#
Introdução à Orientação a Objetos – estabelece
um forte relacionamento entre os diversos componentes
de um determinado problema computacional através da
adoção de dois conceitos chave: classe e objeto.
Classe: determina o comportamento dos objetos, que são
definidos pelos métodos, e estados possíveis, descritos
pelos atributos que compõem e caracterizam esses
objetos;
Objetos: pode ser entendido como uma abstração de algo
que existe dentro do domínio de um problema ou na sua
implementação, sendo que todo objeto é a instância de
11
uma classe.
Visual Studio .NET – C#
Introdução à Orientação a Objetos
Atributo: define um conjunto padrão de características
específicas para uma determinada classe. Os valores
(estados) que estes atributos recebem, quando a classe é
instanciada, permitem caracterizar um objeto.
Método: solicitação a um objeto invocando um de seus
métodos, método este que ativa um determinado
comportamento descrito pela classe que deu origem ao
objeto em questão.
12
6
Visual Studio .NET – C#
Utilizando uma Classe
Neste exemplo será utilizada a classe Cliente, a qual foi
gerada automaticamente pela ferramenta StarUML.
Inicialmente será criado um novo projeto de aplicação
console chamado “ExemploCliente”:
13
Visual Studio .NET – C#
Utilizando uma Classe
Agora a classe cliente deverá ser gerada através da
StarUML dentro da pasta do projeto:
14
7
Visual Studio .NET – C#
Utilizando uma Classe
O arquivo com a classe
gerada deve ser adicionado
ao projeto através da
Solution Explorer:
15
Visual Studio .NET – C#
Utilizando uma Classe
Após adicionar a classe Cliente ao projeto é necessário
completar o código-fonte da mesma, por exemplo, o
método Criar deverá conter as seguintes instruções:
public bool Criar(int _Código, string _Nome,
string _Endereço, string _Telefone)
{ Código = _Código;
Nome = _Nome;
Endereço = _Endereço;
Telefone = _Telefone;
return (true);
}
16
8
Visual Studio .NET – C#
Utilizando uma Classe
O método Consultar deverá retornar os valores dos
atributos do objeto:
public string Consultar()
{ return ("Código: " + Código + "\nNome: " + Nome +
"\nEndereço: " + Endereço + "\nTelefone: " +
Telefone);
}
17
Visual Studio .NET – C#
Utilizando uma Classe
Concluindo o exemplo, na classe Main deverá ser criada
uma instância da classe Cliente dando origem, neste
exemplo, ao objeto c:
static void Main(string[] args)
{ Cliente c = new Cliente();
c.Criar(10, "José", "Rua das Flores, 10", "4321-2343");
Console.WriteLine(c.Consultar());
Console.ReadKey();
}
18
9
Visual Studio .NET – C#
Métodos get e set
...
public class Cliente
{ private int codigo;
private string nome;
private string endereco;
private string telefone;
public int Codigo
{
get { return codigo; }
set { codigo = value; }
}
...
19
Visual Studio .NET – C#
Exercícios: Introdução à Orientação a Objetos
1) Permitir a entrada de dados (digitação) na
aplicação “ExemploCliente”.
2) Alterar a aplicação “ExemploCliente” de modo a
implementar e testar o método Modificar existente na
classe Cliente.
3) Criar uma classe chamada Lâmpada que represente os
atributos e métodos de uma lâmpada.
4) Implementar uma aplicação que, utilizando a classe
Lâmpada, realize o controle de dois objetos desse tipo,
20
permitindo ao usuário acendê-las ou apagá-las.
10
Visual Studio .NET – C#
Introdução à Orientação a Objetos
Adotando o mesmo exemplo utilizado no módulo sobre
SQL Server podemos considerar que PRODUTOS dentro
de um sistema de VENDAS, pode ser considerado como
um OBJETOS. Desta forma, é possível descrever uma
CLASSE e os respectivos atributos:
Produto
Codigo
Descricao
Preco
class Produto
{ private int codigo;
private string descricao;
private double preco;
}
Encapsulamento
21
Visual Studio .NET – C#
Introdução à Orientação a Objetos
Encapsulamento:
consiste
na
separação
de
características internas e externas de um determinado
objeto. Este recurso é comumente utilizado para evitar o
acesso direto aos atributos desse objeto, permitindo desta
forma que apenas os métodos consigam alterar esses
atributos.
Objeto
22
11
Visual Studio .NET – C#
Implementando a classe
No Solution Explorer clique com o botão direito do mouse
sobre o projeto Exemplo01, escolher a opção Add e
depois New Item. Selecionar C# Class e definir o nome da
classe como Produto, mantendo a extensão cs.
23
Visual Studio .NET – C#
Implementando a classe
Em seguida serão criados alguns métodos para a classe:
class Produto
{ private int codigo;
private string descricao;
private double preco;
Atributos
public Produto(int _codigo,
string _descricao, double _preco)
{ codigo = _codigo;
descricao = _descricao;
preco = _preco;
}
public Produto()
{
}
Construtores e
Polimorfismo
24
12
Visual Studio .NET – C#
Introdução à Orientação a Objetos
Construtor: consiste em um tipo especial de método que
determina como um objeto é criado.
Polimorfismo: permite que um determinado método
declarado em uma classe funcione de maneira diferente
de acordo com o contexto no qual o objeto está inserido.
25
Visual Studio .NET – C#
Implementando a classe
...
public void DefinirCodigo(int _codigo)
{ codigo = _codigo;
}
public int ObterCodigo()
{ return (codigo);
}
// Implementar os métodos para os outros atributos
...
}
26
13
Visual Studio .NET – C#
Criando os objetos – instanciando a classe
No método Main a classe produto será instanciada dando
origem ao objeto, neste exemplo, simbolizado pela
variável “p”.
static void Main(string[] args)
{ Produto p = new Produto(10, "TV 29 pol.", 910.00);
Console.WriteLine("o produto " + p.ObterDescricao() +
" custa R$ " + p.ObterPreco());
Console.ReadKey();
}
27
Visual Studio .NET – C#
Criando os objetos – instanciando a classe
Neste outro exemplo não existem os estados dos atributos
do objeto no momento em que o mesmo é instanciado,
desta forma será utilizado o outro método construtor:
static void Main(string[] args)
{ Produto p = new Produto();
Console.Write("Código: ");
p.DefinirCodigo(Convert.ToInt32(Console.ReadLine()));
Console.Write("Descrição: ");
p.DefinirDescricao(Console.ReadLine());
Console.Write("Preço: ");
p.DefinirPreco(Convert.ToDouble(Console.ReadLine()));
Console.WriteLine("\nO produto " + p.ObterDescricao() +
" custa R$ " + p.ObterPreco());
Console.ReadKey();
28
}
14
Visual Studio .NET – C#
Introdução à Orientação a Objetos
Uma das características fundamentais da orientação a
objetos é a capacidade de reaproveitamento de código, o
que pode ser implementado através do conceito de
herança.
Herança: é o recurso pelo qual uma determinada classe,
denominada sub-classe, pode receber atributos e métodos
presentes em outra classe, neste caso chamada de superclasse.
29
Visual Studio .NET – C#
Introdução à Orientação a Objetos
O exemplo a seguir mostra uma possibilidade de
aplicação do conceito de herança tomando como base a
classe Produto que está sendo utilizada.
Considerar como cenário uma loja que mantém um banco
de dados para todos os produtos vendidos. Estes
produtos possuem alguns atributos em comum como, por
exemplo, código, descrição e preço. Porém, alguns
produtos possuem algumas informações específicas: CD: duração e número de faixas; - DVD: duração, região,
idioma e legenda; - Eletrônicos: tensão de operação e
garantia; Livros: autor, número de páginas e idioma.
30
15
Visual Studio .NET – C#
Definição da classe Eletronico
A classe Eletronico será herdará os atributos e métodos
da classe Produto, desta forma apenas serão declarados
os atributos específicos da classe.
class Eletronico: Produto
{ private int tensao;
private string garantia;
Herança
public Eletronico()
{
}
31
Visual Studio .NET – C#
Definição da classe Eletronico
O método construtor da classe Eletronico precisará
acessar os atributos da classe Produto, desta forma na
classe Produto, os mesmos deverão ser alterados de
private para protected.
public Eletronico(int _codigo, string _descricao, double
_preco, int _tensao, string _garantia)
{ codigo = _codigo;
descricao = _descricao;
preco = _preco;
tensao = _tensao;
garantia = _garantia;
}
32
16
Visual Studio .NET – C#
Definição da classe Eletronico
public void DefinirTensao(int _tensao)
{
tensao = _tensao;
}
public int ObterTensao()
{
return (tensao);
}
// Implementar os métodos para os atributo garantia
...
}
33
Visual Studio .NET – C#
Utilizando a classe
static void Main(string[] args)
{ Eletronico e = new Eletronico();
Console.Write("Código: ");
e.DefinirCodigo(Convert.ToInt32(Console.ReadLine()));
Console.Write("Descrição: ");
e.DefinirDescricao(Console.ReadLine());
Console.Write("Preço: ");
e.DefinirPreco(Convert.ToDouble(Console.ReadLine()));
Console.Write("Tensão: ");
e.DefinirTensao(Convert.ToInt32(Console.ReadLine()));
Console.Write("Garantia: ");
e.DefinirGarantia(Console.ReadLine());
Console.WriteLine("\nO produto " + e.ObterDescricao() +
" custa R$ " + e.ObterPreco() + " e possui garantia de "
+ e.ObterGarantia());
34
Console.ReadKey();
}
17
Visual Studio .NET – C#
Exercício: Introdução à Orientação a Objetos
5) Implementar as demais classes descritas no
cenário proposto: CD, DVD e Livro.
35
Visual Studio .NET – C#
Exercício: Introdução à Orientação a Objetos
6) Uma empresa de aluguel de veículos mantém um
banco de dados para todos os veículos de sua frota. Para
todos os veículos, são armazenados o número do chassi,
o número da placa, o fabricante, o modelo, o ano de
fabricação e a cor. Algumas informações são incluídas
para determinados tipos de veículos: - caminhões:
capacidade de carga, número de eixos; - carros esportes:
potência, capacidade de aceleração; ônibus: quantidade
de passageiros, número de eixos; - off road: altura em
relação ao solo, tipo de tração. Realizar a definição e
implementação das classes, com
respectivos atributos e métodos,
36
com base no exposto acima.
18
Visual Studio .NET – C#
Engenharia Reversa
Utilizando a StarUML é possível, a partir da análise do
código-fonte de um determinado projeto, realizar a
construção do diagrama de classes.
Criar um novo projeto
na StarUML e, em
seguida, adicionar o
profile do C#.
Escolher a opção
Reverse Engineering
no menu Tools e C#:
37
Visual Studio .NET – C#
Engenharia Reversa
Escolher a pasta na qual o projeto se encontra e depois
adicionar as classes desejadas, por exemplo:
38
19
Visual Studio .NET – C#
Engenharia Reversa
Em seguida selecionar Design Model:
39
Visual Studio .NET – C#
Engenharia Reversa
Marcar as opções desejadas e pressionar o botão Run(R):
40
20
Visual Studio .NET – C#
Engenharia Reversa
Observar, ao final do processo, o resultado mostrado:
41
Visual Studio .NET – C#
Engenharia Reversa
O diagrama de classes indica, além dos atributos e
métodos, o relacionamento entre as classes, neste
exemplo, a generalização (herança):
42
21
Visual Studio .NET – C#
Sintaxe do C# – Instrução if
if (p.ObterPreco() < 1000.00)
imposto = p.ObterPreco() * 0.05;
else if (p.ObterPreco() < 3000.00)
imposto = p.ObterPreco() * 0.10;
else
imposto = p.ObterPreco() * 0.15;
43
Visual Studio .NET – C#
Sintaxe do C# – Formatação da saída
Console.WriteLine("\nO produto " + p.ObterDescricao() +
" custa R$ " + p.ObterPreco().ToString("##0.00") +
" e o valor do imposto é R$ " +
imposto.ToString("##0.00"));
44
22
Visual Studio .NET – C#
Sintaxe do C# – Instrução switch
Console.Write("Digite um número entre 1 e 3: ");
int i = Convert.ToInt32(Console.ReadLine());
switch (i)
{ case 1: Console.WriteLine("Um"); break;
case 2: Console.WriteLine("Dois"); break;
case 3: Console.WriteLine("Três"); break;
default:
Console.WriteLine("Número fora da faixa solicitada");
break;
}
Console.ReadKey();
45
Visual Studio .NET – C#
Sintaxe do C# – Instrução for
for (int i = 0; i < 10; i++)
{ Console.WriteLine("O valor de i é " + i);
}
Console.ReadKey();
46
23
Visual Studio .NET – C#
Sintaxe do C# – Instrução while
int i = 0;
while (i < 10)
{ Console.WriteLine("O valor de i é " + i++);
}
Console.ReadKey();
Instrução do ... while
int i = 0;
do
{ Console.WriteLine("O valor de i é " + i++);
}
while (i < 10);
Console.ReadKey();
47
Visual Studio .NET – C#
Sintaxe do C# – Vetores e matrizes
int[] v = new int[10];
Random a = new Random();
Console.Write("Vetor: ");
for (int i = 0; i < 10; i++)
{ v[i] = a.Next(1, 50);
Console.Write("{0}, ", v[i]);
}
Console.WriteLine("\nO valor do elemento na quarta posição
é {0}", v[3]);
Console.ReadKey();
48
24
Visual Studio .NET – C#
Sintaxe do C# – Vetores e matrizes
char[,] m = new char[3,3];
int n;
Random a = new Random();
for (int i = 0; i < 3; i++)
{ for (int j = 0; j < 3; j++)
{ n = a.Next(0, 3);
if (n == 0)
m[i,j] = 'B';
else if (n == 1)
m[i,j] = 'O';
else
m[i,j] = 'X';
}
Console.WriteLine("{0} {1}
m[i,2]);
}
Console.ReadKey();
{2}", m[i,0], m[i,1],
49
Visual Studio .NET – C#
Sintaxe do C# – Vetores e matrizes
Produto[] p = new Produto[3];
for (int i = 0; i < 3; i++)
{ p[i] = new Produto();
Console.Write("Código: ");
p[i].DefinirCodigo(Convert.ToInt32(Console.ReadLine()));
Console.Write("Descrição: ");
p[i].DefinirDescricao(Console.ReadLine());
Console.Write("Preço: ");
p[i].DefinirPreco(Convert.ToDouble(Console.ReadLine()));
}
50
25
Visual Studio .NET – C#
Sintaxe do C# – Instrução foreach
Console.WriteLine("\n{0, -15}{1, 10}", "Descrição",
"Preço");
Console.WriteLine("--------------- ----------");
foreach (Produto item in p)
Console.WriteLine("{0, -15}{1, 10}",
item.ObterDescricao(),
item.ObterPreco().ToString("##0.00"));
Console.ReadKey();
51
Visual Studio .NET – C#
Sintaxe do C# – Coleções
O componente ArrayList pode ser entendido como um
vetor comum, porém com a capacidade de ir crescendo
conforme a demanda, ou seja, não é necessária a
alocação prévia do seu tamanho máximo.
ArrayList p = new ArrayList();
for (int i = 0; i < 3; i++)
{ Produto item = new Produto();
Console.Write("Código: ");
item.DefinirCodigo(Convert.ToInt32(Console.ReadLine()));
Console.Write("Descrição: ");
item.DefinirDescricao(Console.ReadLine());
Console.Write("Preço: ");
item.DefinirPreco(Convert.ToDouble(Console.ReadLine()));
p.Add(item);
52
}
26
Visual Studio .NET – C#
Sintaxe do C# – Coleções
O componente HashTable permite associar chaves a
valores, permitindo armazenagem e recuperação
eficientes dos valores.
Hashtable produto = new Hashtable();
Produto item;
item = new Produto(1001, "Mesa com 4 cadeiras", 450.00);
produto.Add(item.ObterCodigo(), item);
item = new Produto(1002, "Sofá 4 lugares", 700.00);
produto.Add(item.ObterCodigo(), item);
item = new Produto(1003, "Estante para sala de estar",
300.00);
produto.Add(item.ObterCodigo(), item);
53
Visual Studio .NET – C#
Sintaxe do C# – Coleções
Acesso ao conteúdo armazenado na HashTable é
realizado através de dois atributos: Key e Value.
Console.WriteLine("\n{0, 4} {1, -30} {2, 10}", "Cód.",
"Descrição", "Preço");
Console.WriteLine("---- ------------------------------ ---------");
IDictionaryEnumerator itemProduto =
produto.GetEnumerator();
while (itemProduto.MoveNext())
{ item = (Produto) itemProduto.Value;
Console.WriteLine("{0, 4} {1, -30} {2, 10}",
itemProduto.Key, item.ObterDescricao(),
item.ObterPreco().ToString("##0.00"));
}
Console.ReadKey();
54
27
Visual Studio .NET – C#
Sintaxe do C# – Coleções
Uma das grandes vantagens da adoção de HashTable é a
possibilidade da realização de buscas através da chave
ou até mesmo pelo valor.
int chavePesquisa = 1002;
if (produto.ContainsKey(chavePesquisa))
{
item = (Produto)produto[chavePesquisa];
Console.WriteLine("\nO produto " + item.ObterDescricao()
+ " custa R$ " + item.ObterPreco());
}
else
{
Console.WriteLine("\nO produto não foi localizado!");
}
55
Visual Studio .NET – C#
Sintaxe do C# – Tratamento de exceção
Uma aplicação de qualidade deve evitar o seu
encerramento de forma abrupta. Desta forma, é uma boa
prática de programação realizar o tratamento dos erros.
int a, b = 0;
Console.WriteLine("Início da aplicação");
try
{
a = 10 / b;
Console.WriteLine("O valor de A é: {0}", a);
}
catch (Exception e)
{
Console.WriteLine("ERRO: " + e);
}
Console.WriteLine("Restante da aplicação"); 56
28
Visual Studio .NET – C#
Exercícios
7) Criar um programa que receba três números inteiros e
exiba o maior deles.
8) Especificar uma aplicação que faça a leitura do nome e
ano de nascimento de uma pessoa e exiba a idade da
mesma.
9) Dada uma seqüência de 10 números inteiros, realizar a
exibição na ordem inversa à da leitura.
10) Dado um vetor com 5 números inteiros, exibir a média.
11) Um dado de jogo foi lançado 20 vezes. A partir dos
resultados dos lançamentos, devidamente armazenados
em um vetor, mostrar o número de ocorrências
de cada face.
57
Visual Studio .NET – C#
Exercícios
12) Criar uma coleção para representar 5 objetos do tipo
veículo e que possuem como atributos: chassis, placa,
modelo, cor e ano de fabricação.
13) Considerando o funcionamento de uma lâmpada,
projetar uma classe que represente os estados
possíveis e respectivos métodos.
14) Tomando como referência uma aplicação em modo
console, implementar uma classe chamada Teclado e
que contenha os métodos necessários para realizar a
leitura de valores do tipo de dados string, inteiro e float.
58
29
Visual Studio .NET – C#
Construção de aplicações para a WEB
Criar um novo projeto através das opções File, New e
WebSite.
59
Visual Studio .NET – C#
Construção de aplicações para a WEB
Em seguida deve-se utilizar os componentes da Toolbox
para realizar o lay-out da página, por exemplo:
Caixa de
Texto
Label
Botão
60
30
Visual Studio .NET – C#
Toolbox
A Toolbox contém os elementos que podem
ser inseridos às janelas e páginas criadas
através do Visual Studio. Para o exemplo
que está sendo desenvolvido serão
utilizados: Label (Etiqueta), TextBox (Caixa
de Texto) e Button (Botão).
61
Visual Studio .NET – C#
Properties Window
A janela de propriedades deve ser
utilizada para determinar algumas das
características dos elementos criados.
Por exemplo, considerando a caixa de
texto que receberá o nome, deverão ser
ajustadas as seguintes propriedades:
- Id = Nome
- MaxLength = 40
- Width = 250px
62
31
Visual Studio .NET – C#
Programação dos eventos
Após o “desenho” da página, torna-se necessário
adicionar o código-fonte que irá realizar o cálculo da idade
a partir do ano de nascimento que foi inserido. É
importante observar que a idade deverá ser calculada no
momento em que o usuário clicar sobre o botão Calcular,
sendo este, o evento que deverá ser programado.
Acontecimentos que podem
ocorrer a um elemento em
determinado momento.
63
Visual Studio .NET – C#
Programação dos eventos
Dar um duplo clique sobre o botão Calcular, a janela de
código-fonte será aberta, colocar os comandos
necessários para realizar o cálculo da idade, por exemplo:
protected void Calcular_Click(object sender, EventArgs e)
{
int anoAtual = DateTime.Now.Year;
Idade.Text = Nome.Text + " a sua idade é " + (anoAtual –
Convert.ToInt32(AnoNascimento.Text));
}
64
32
Visual Studio .NET – C#
Programação dos eventos
Os eventos disponíveis para determinado controle
também podem ser acessados através da janela de
propriedades:
Propriedades
Eventos
65
Visual Studio .NET – C#
Execução da aplicação
Escolher no menu a opção
Build e depois Build Solution
(F6), observar se não
ocorrerem
erros
de
compilação. Em seguida,
clicar em Debug e depois
Start Debugging (F5).
66
33
Visual Studio .NET – C#
Exercícios
15) Criar um botão chamado Limpar que ao ser
clicado apague o conteúdo existente nas caixas
de texto e na etiqueta que exibe o resultado.
16) Elaborar uma calculadora
simples seguindo o lay-out
mostrado ao lado.
67
Visual Studio .NET – C#
Exercícios
17)
Implementar
uma
calculadora
no
estilo
“Windows”,
contendo
as
quatro operações básicas:
adição, subtração, multiplicação e divisão.
68
34
Visual Studio .NET – C#
Botões de Rádio
O programa desenvolvido no
exercício 16 pode ser alterado para
utilizar um grupo de botões de rádio.
Neste caso deverá ser usado o
controle RadioButtonList disponível
na caixa de ferramentas.
Ajustar as seguintes propriedades:
- Id = Operacao
- RepeatColumns = 4
69
Visual Studio .NET – C#
Botões de Rádio
Em seguida deve-se clicar na propriedade
especificar as opções para o usuário, por exemplo:
Items
70
35
Visual Studio .NET – C#
Botões de Rádio
A propriedade SelectedValue deverá ser usada para
determinar qual a opção que foi escolhida pelo usuário:
...
switch (Operacao.SelectedValue)
{
case "Somar": r = n1 + n2; break;
case "Subtrair": r = n1 - n2; break;
...
71
Visual Studio .NET – C#
Caixas de Seleção
Outra possibilidade de uso de
controles
para
a
aplicação
Calculadora Simples consiste na
adoção do controle Caixa de
Seleção (DropDownList).
Posteriormente deve-se ajustar as
propriedades de maneira similar à
realizada para os Botões de
Rádio.
72
36
Visual Studio .NET – C#
Validadores
O Visual Studio .NET possui elementos que podem
realizar a validação dos campos. No exemplo a seguir
será utilizado um validador que torna obrigatório o
preenchimento do campo Nome.
Na
Toolbox
escolher
o
componente
RequiredFieldValidator e colocá-lo ao lado da caixa de
texto Nome. Ajustar as seguintes propriedades:
- Id = NomeObrigatorio
- ControlToValidade = Nome
- ErrorMessage = Campo obrigatório
73
Visual Studio .NET – C#
Validadores
Ao executar a
aplicação se o
nome não for
preenchido será
mostrada
uma
mensagem e a
idade
não
é
calculada.
74
37
Visual Studio .NET – C#
Validadores
O próximo passo consiste em criar um validador para o
ano de nascimento, neste caso será utilizado o
componente RangeValidator para aceitar os anos entre
1807 e 2007. Após a criação do componente as seguintes
propriedades deverão ser ajustadas:
- Id = FaixaAno
- ControlToValidade = AnoNascimento
- ErrorMessage = Deve estar entre 1807 e 2007
- MaximumValue = 2007
- MinimumValue = 1807
75
Visual Studio .NET – C#
Validadores
Ao executar a aplicação será realizada a verificação se a
data de nascimento está dentro da faixa especificada.
76
38
Visual Studio .NET – C#
Validadores
Um validador pode ser utilizado para receber dados
dinâmicos, ou seja, aqueles que são obtidos durante a
execução do programa.
protected void Page_Load(object sender, EventArgs e)
{
int faixaFim = DateTime.Now.Year;
int faixaInicio = faixaFim - 200;
FaixaAno.MaximumValue = faixaFim.ToString();
FaixaAno.MinimumValue = faixaInicio.ToString();
FaixaAno.ErrorMessage = "Deve estar entre " +
faixaInicio.ToString() + " e " + faixaFim.ToString();
}
77
Visual Studio .NET – C#
Envio de dados entre páginas
Os dados de um formulário são enviados para que o
processamento seja realizado em uma outra página.
Neste caso, usa-se a propriedade PostBackUrl do botão
para indicar a página de destino.
Para criar uma nova página clicar com o botão da direita
sobre o projeto, escolher Add New Item. Selecionar Web
Form e especificar o nome da página. No exemplo, esta
página será chamada de Resposta.aspx.
78
39
Visual Studio .NET – C#
Envio de dados entre páginas
Na página de resposta deverá ser colocado um
componente (Etiqueta) que receberá o resultado do
cálculo da idade. Esta etiqueta deverá ter a propriedade Id
com o valor Mensagem.
79
Visual Studio .NET – C#
Obtenção dos dados enviados
O próximo passo consiste em realizar o cálculo da idade
dentro do evento Page_Load:
protected void Page_Load(object sender, EventArgs e)
{
int anoAtual = DateTime.Now.Year;
Mensagem.Text = "Olá, " + Request.Form["Nome"] +
" a sua idade é " + (anoAtual –
Convert.ToInt32(Request.Form["AnoNascimento"]));
}
A classe Request contém os
dados que são enviados através
do “POST” do formulário.
80
40
Visual Studio .NET – C#
Redirecionamento
O botão Voltar permitirá ao usuário retornar à página
principal. Porém, a utilização de Response.Redirect não
realiza o envio dos dados do formulário.
protected void Voltar_Click(object sender, EventArgs e)
{
Response
.Redirect("Default.aspx");
}
81
Visual Studio .NET – C#
Página Padrão
Nos projetos de Web Sites que
contém mais do que uma página,
torna-se necessário realizar a
definição da página padrão, ou
seja, a primeira página que deverá
ser carregada quando o site é
acessado.
A definição da página padrão é
realizada através da Solution
Explorer, clicando-se com o botão
direito do mouse sobre a página
desejada e escolhendo a opção
“Set As Start Page”.
82
41
Visual Studio .NET – C#
Exercícios
Utilizando como referência a classe Produto, desenvolvida
anteriormente, e as necessidades adicionais de se
especificar a quantidade do produto e um desconto, criar
um Web Site que apresente as
Seguintes funcionalidades:
18) Uma página que possibilite
a digitação dos dados de um
determinado produto, conforme
mostrado na figura ao lado.
83
Visual Studio .NET – C#
Exercícios
19) A caixa para a seleção do desconto deverá apresentar
as seguintes possibilidades de escolha: (Sem desconto),
1%, 2% e 5%.
20) O botão calcular deverá enviar os dados para uma
página chamada Fechamento.aspx.
21) A página Fechamento.aspx deverá criar um objeto do
tipo Produto e atribuir os valores do código, descrição e
preço digitados pelo usuário ao objeto criado.
Dica: Adicionar ao projeto a classe Produto que já foi
desenvolvida anteriormente.
84
42
Visual Studio .NET – C#
Utilização de Classes
Além de Web Forms também é possível inserir classes
dentro do projeto de um Web Site. Na Solution Explorer
deve-se clicar com o botão da direita sobre o Web Site e
escolher a opção “Add New Item...” ou “Add Existing Item”.
É importante observar que as classes devem ficar
organizadas dentro da pasta App_Code:
85
Visual Studio .NET – C#
Utilização de Classes
Quando uma classe é criada, normalmente, ela está
inserida dentro de um namespace, por exemplo:
...
namespace Loja
{
public class Produto
{
protected int codigo;
protected ...
86
43
Visual Studio .NET – C#
Utilização de Classes
As páginas ASP.Net não adotam o conceito de
namespace, desta forma, para usar uma classe dentro de
um Web Form torna-se necessário “importar” o
namespace dentro da página:
...
using System.Web.UI.HtmlControls;
using Loja;
public partial class Fechamento : System.Web.UI.Page
{
protected void Page_Load(object s, EventArgs e)
{
Produto p = new Produto();
87
...
Visual Studio .NET – C#
Exercícios
22) Calcular o preço total utilizando, para isso, a seguinte
fórmula:
PrecoTotal = (Preco * Quantidade) – Desconto
23) Determinar a alíquota do
especificado pela tabela abaixo:
PrecoTotal
<= 500,00
> 500,00 e <= 1.000,00
> 1.000,00 e <= 10.000,00
> 10.000,00
imposto
Alíquota
0,5%
2,5%
8,0%
12,5%
conforme
88
44
Visual Studio .NET – C#
Exercícios
24) Calcular o imposto a ser pago
adotando a seguinte fórmula:
Imposto = PrecoTotal * Alíquota
25)
Exibir
na
página
Fechamento.aspx as seguintes
informações: Código, Descrição,
Preço, Quantidade, Valor do
Desconto, Valor Total, Valor e
Alíquota do Imposto.
89
Visual Studio .NET – C#
Programação em camadas
A idéia de se programar em camadas está fundamentada
sobre o conceito de separação de tarefas e
responsabilidades: diferentes serviços disponibilizados
pelo programa, classificados de acordo com a sua função,
são desenvolvidos de forma separada.
Camada de
Interface com
o usuário
Camada
de
negócios
Camada
de acesso
aos dados
Banco
de Dados
90
45
Visual Studio .NET – C#
Por que adotar a programação em camadas?
A produtividade aumenta muito quando se utiliza o modelo
em camadas, já que é possível a re-utilização de blocos
de código, adicionando funcionalidades que já foram
desenvolvidas, implementadas e testadas em outras
aplicações. O impacto causado pela aplicação de tal
modelo não se reduz ao simples aumento de
produtividade, causando também um grande impacto
sobre a qualidade do mesmo, favorecendo em vários
quesitos, como facilidade de instalação, manutenção e até
aspectos relacionados com a segurança.
91
Visual Studio .NET – C#
Acesso ao banco de dados
O Visual Studio .NET apresenta inúmeras possibilidades
para a conexão de uma aplicação à um sistema de banco
de dados, o exemplo que será desenvolvido a seguir irá
demonstrar algumas dessas capacidades e está baseado
sobre um hipotético sistema de e-commerce contendo as
tabelas para produtos, clientes e vendas.
92
46
Visual Studio .NET – C#
Modelo entidade relacionamento do sistema
CPF
Cliente
Nome
CPF
Telefone
Cod_Prod
Adquirir
Qtde
Código
Data
Para armazenar as
tabelas criar no
SQL Server um
database chamado
teste e também um
usuário
com
o
mesmo nome.
Descrição
Produto
Preço
93
Visual Studio .NET – C#
Estrutura das tabelas
CREATE TABLE Produto (
Codigo INT NOT NULL,
Descricao NVARCHAR(40) NOT
NULL,
Preco REAL,
CONSTRAINT Produto_PK
PRIMARY KEY(Codigo))
CREATE TABLE Adquirir (
CPF NVARCHAR(14) NOT NULL,
CodProd INT NOT NULL,
Qtde INT NOT NULL,
Data DATETIME NOT NULL,
CONSTRAINT Adquirir_PK
PRIMARY KEY (CPF, CodProd),
CONSTRAINT CPF_Cliente_FK
CREATE TABLE Cliente (
FOREIGN KEY (CPF)
CPF NVARCHAR(14) NOT NULL,
REFERENCES Cliente (CPF),
Nome NVARCHAR(40) NOT NULL, CONSTRAINT Codigo_Produto_FK
Telefone NVARCHAR(20),
FOREIGN KEY (CodProd)
CONSTRAINT Cliente_PK
REFERENCES Produto (Codigo))
PRIMARY KEY (CPF))
94
47
Visual Studio .NET – C#
Criação no SQL Server
Utilizar o Microsoft SQL Server
Management Studio Express
para criar o database, o usuários
e as três tabelas que são
necessárias ao desenvolvimento
do exemplo.
95
Visual Studio .NET – C#
Desenvolvimento do front-end
Criar um projeto de um Web Site no Visual Studio .NET, a
página principal (Default.aspx) deverá conter apenas os
links para as demais páginas que serão desenvolvidas
utilizar, para isso, o componente Hyperlink disponível na
Toolbox.
96
48
Visual Studio .NET – C#
Página de produtos
Adicionar ao projeto uma nova
página
e
chamá-la
de
RelacaoProduto.aspx, colocar
os componentes GridView e
SQLDataSource
além
dos
botões Novo e Voltar.
97
Visual Studio .NET – C#
Ajuste do DataSource
Configurar
as
seguintes
propriedades do controle:
- Id = DsoProduto
- ConnectionString = (Observar a
figura ao lado)
-SelectQuery =
SELECT Codigo, Descricao, Preco
FROM PRODUTO
ORDER BY Codigo
98
49
Visual Studio .NET – C#
Configuração do GridView
Ajustar as seguintes propriedades do controle:
- Id = GridProduto
- DataSourceId =
DsoProduto
- Columns =
(Figura ao lado)
99
Visual Studio .NET – C#
Criação do formulário para manutenção
Inserir um novo Web Form ao projeto, chamá-lo de
ManutencaoProduto.aspx e colocar os componentes
conforme sugerido abaixo:
100
50
Visual Studio .NET – C#
Navegação entre as páginas
Adicionar uma nova coluna do tipo CommandField, Select
ao GridView.
101
Visual Studio .NET – C#
Navegação entre as páginas
Permitir que o formulário de manutenção seja carregado
quando o usuário selecionar uma linha do GridView ...
protected void GridProduto_SelectedIndexChanged (object
sender, EventArgs e)
{ GridViewRow linha = GridProduto.SelectedRow;
Response.Redirect("ManutencaoProduto.aspx?Codigo=" +
linha.Cells[1].Text);
}
... e também quando pressionar o botão Novo.
protected void NovoProduto_Click(object sender, EventArgs e)
{ Response.Redirect("ManutencaoProduto.aspx?Codigo=-1");
}
102
51
Visual Studio .NET – C#
Camada de acesso ao banco de dados
Adotando os conceitos de programação em camadas serão
criadas duas classes, uma chamada Produto e outra
AcessoDadosProduto. A classe Produto irá conter os
atributos e métodos do respectivo objeto.
public class Produto
{ private int codigo;
private string descricao;
private float preco;
public int Codigo
{ get { return codigo; }
set { codigo = value; }
}
}
103
Visual Studio .NET – C#
Camada de acesso ao banco de
dados
SqlConnection: Classe responsável pela
conexão ao servidor de banco de dados;
SqlCommand: Possui a finalidade de
enviar um comando ao servidor de banco
de
dados
através
da
conexão
estabelecida
com
a
classe
SqlConnection;
SqlDataReader: Obtém os resultados
(dados) de um comando SQL, o qual foi
previamente enviado através da classe
SqlCommand.
SqlDataReader
SqlCommand
SqlConnection
SGBD
104
52
Visual Studio .NET – C#
Camada de acesso ao banco de dados
SqlConnection
SqlCommand
SqlDataReader
SqlConnection()
SqlCommand()
Read()
Open()
ExecuteReader()
GetInt32()
Close()
ExecuteNonQuery()
GetString()
GetFloat()
HasRows
Close()
105
Visual Studio .NET – C#
Camada de acesso ao banco de dados
A classe AcessoDadosProduto irá conter os métodos para
recuperação e manipulação dos dados.
public class AcessoDadosProduto
{ private static string stringConexao = "Data Source=MMIW26\\SQLEXPRESS;Initial Catalog=Teste;User ID=teste;
Password=teste";
public static Produto obterProduto(int codigo)
{ Produto produto = new Produto();
SqlConnection conexao = new SqlConnection(stringConexao);
SqlCommand sql = new SqlCommand("SELECT Codigo, Descricao,
Preco FROM Produto WHERE Codigo = " + codigo.ToString(),
conexao);
106
53
Visual Studio .NET – C#
Camada de acesso ao banco de dados
SqlDataReader rs;
conexao.Open();
rs = sql.ExecuteReader();
rs.Read();
if (rs.HasRows)
{
produto.Codigo = rs.GetInt32(0);
produto.Descricao = rs.GetString(1);
produto.Preco = rs.GetFloat(2);
}
rs.Close();
conexao.Close();
return (produto);
}
107
Visual Studio .NET – C#
Camada de acesso ao banco de dados
public static void incluirProduto(Produto produto)
{
SqlConnection conexao = new SqlConnection(stringConexao);
string comando = "INSERT INTO Produto(Codigo, Descricao,
Preco) VALUES (" + produto.Codigo.ToString() + ", ' " +
produto.Descricao + "', " +
produto.Preco.ToString().Replace(",", ".") + ")";
conexao.Open();
SqlCommand sql = new SqlCommand(comando, conexao);
sql.ExecuteNonQuery();
conexao.Close();
}
108
54
Visual Studio .NET – C#
Camada de acesso ao banco de dados
public static void alterarProduto(Produto produto)
{
SqlConnection conexao = new SqlConnection(stringConexao);
string comando = "UPDATE Produto SET Descricao='" +
produto.Descricao + "', Preco=" +
produto.Preco.ToString().Replace(",", ".") + " WHERE
Codigo=" + produto.Codigo.ToString();
conexao.Open();
SqlCommand sql = new SqlCommand(comando, conexao);
sql.ExecuteNonQuery();
conexao.Close(); }
109
Visual Studio .NET – C#
Camada de acesso ao banco de dados
public static void excluirProduto(int codigo)
{ SqlConnection conexao = new SqlConnection(stringConexao);
string comando = "DELETE FROM Produto WHERE Codigo=" +
codigo.ToString();
conexao.Open();
SqlCommand sql = new SqlCommand(comando, conexao);
sql.ExecuteNonQuery();
conexao.Close();
}
}
110
55
Visual Studio .NET – C#
Inserção e alteração de produtos
Deverão ser preenchidos os campos do formulário e, em
seguida, o botão Gravar deverá ser pressionado. Para isso
será criado um componente do tipo HiddenField chamado
Operação o qual irá conter os valores “i” para inclusão ou “a”
para alteração.
111
Visual Studio .NET – C#
Inserção e alteração de produtos
Em seguida será desenvolvido o código-fonte para quando o
botão Gravar for pressionado:
protected void Gravar_Click(object sender, EventArgs e)
{ Produto produto = new Produto();
produto.Codigo = Convert.ToInt32(Codigo.Text);
produto.Descricao = Descricao.Text;
produto.Preco = (float) Convert.ToDouble(Preco.Text);
if (Operacao.Value == "i")
AcessoDadosProduto.incluirProduto(produto);
else
AcessoDadosProduto.alterarProduto(produto);
Response.Redirect("RelacaoProduto.aspx");
}
112
56
Visual Studio .NET – C#
Obter os dados de um produto
As rotinas para alteração e exclusão requerem que o produto
seja previamente carregado e isso será realizado no evento
Page_Load do formulário.
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
Operacao.Value = "i"; // Inclusão
Codigo.Enabled = true;
Excluir.Enabled = false;
int codigo = Convert.ToInt32(Request.QueryString
["Codigo"]);
113
Visual Studio .NET – C#
Obter os dados de um produto
if (codigo != -1)
{ Produto produto =
AcessoDadosProduto.obterProduto(codigo);
Codigo.Text = produto.Codigo.ToString();
Codigo.Enabled = false;
Descricao.Text = produto.Descricao;
Preco.Text = produto.Preco.ToString("f2");
Operacao.Value = "a"; // Alteração
Excluir.Enabled = true;
}
}
}
114
57
Visual Studio .NET – C#
Exclusão dos dados de um produto
O usuário irá clicar no link Editar do produto que será
apagado, depois será carregado o formulário com os
respectivos dados. O último passo consiste em pressionar o
botão Excluir:
protected void Excluir_Click(object sender, EventArgs e)
{
AcessoDadosProduto.excluirProduto(Convert.ToInt32(
Codigo.Text));
Response.Redirect("RelacaoProduto.aspx");
}
115
Visual Studio .NET – C#
Exercícios: Implementação dos outros cadastros
26) Conforme o modelo que foi criado para
produtos, implementar as opções para realizar o
cadastro de clientes e aquisições.
27) Trocar o texto Editar por um ícone.
116
58
Visual Studio .NET – C#
Formatação das colunas do GridView
É possível aplicar formatação ao conteúdo dos itens
apresentados no GridView, para isso é necessário preencher
as seguintes propriedades da coluna que se deseja formatar:
- HTMLEncode = False
- DataFormatString = {0:f2}
Onde:
1) A máscara deverá ser colocada entre chaves;
2) O número 0 (zero) representa o elemento da coluna;
3) Enquanto f2 é a máscara de formatação que será
aplicada.
117
59
Download