Introdução ao C#
Para organização de nossos sistemas,
programas que desenvolvemos, temos um "grupo maior", chamado de
Solução que, dentro dele, ficam os programas desenvolvidos, formulários, etc.
Ao abrir um programa para dar manutenção
ou dar sequência em suas atividades, abra sempre a solução, pois ela é que está
gerenciando o sistema que está sendo desenvolvido.
Começando do zero...
Considerando que estamos utilizando o
Windows XP: inicie o Visual C#, clicando em iniciar / Todos os Programas /
Microsoft Visual C# 2008 Express Edition. Após termos o aplicativo aberto,
vamos criar uma nova solução, clicando em File / New Project...
Observe que o Visual C# está utilizando
o .NetFramework 3.5.
Selecione a templates utilizada. Em
nossas aplicações, será a Windows Forms Application.
Um item importante: o nome para a
Solução.
Após termos selecionado e preenchido os
item relacionados acima, clicamos em OK.
Um item importante é salvarmos a nossa
aplicação. Para isto, podemos utilizar o menu File / Save All... Na primeira
vez em que é salvo, será solicitado o nome do projeto (sugere o nome informado
na criação do projeto). Podemos informar a localização de nosso projeto e o
nome da Solução e será criado uma pasta para armazená-la.
Como já dissemos em ocasiões passadas,
o Visual C# 2008 é composto de várias janelas, como por exemplo, a janela de
Propriedade e Eventos, a janela de Ferramentas, a janela para explorar a
Solução, entre outras, que podem estar fixas, fixas com ocultar automaticamente
ou flutuantes.
Trabalhando com componentes.
Os componentes são classes, conjunto de
códigos e outros itens mais, já desenvolvidos e prontos para utilizarmos em
nossas aplicações. Os componentes ficam separados em grupos na barra de
ferramentas, ToolBox. Dentre eles, temos Common Controls, Containers, menus
& Toolbars.
Ao trabalhar com componentes, devemos
saber que ele possui características, nome, altura, largura, distancia do topo
do formulário, etc., Estas características são chamadas de propriedades. Ao
selecionar um componente, a relação completa aparece na Properties Window
(janela de propriedades), na qual podemos digitar algum valor ou selecionar uma
opção pré-definida.
Na mesma janela, na qual configuramos
as propriedades, podemos mudar para exibir as opções de eventos (o botão comum
desenho de um raio). Então, exibirá a lista de eventos.
Em muitos outros componentes, as
propriedades se repetem e a sua funcionalidade também. Por exemplo, a
propriedade text aparece em muitos componentes, pois é nela que informamos o
que irá aparecer na tela de nosso formulário. Outro item é o name. Esta
propriedade está em todos os componentes, sendo uma das mais importantes
propriedades. Através dela, que chamamos os componentes, atribuímos valores a
suas propriedades, entre outras funções.
O mesmo ocorre aos eventos. Podemos
usar, como exemplo, o evento click. Este evento aparecerá em todos os
componentes visuais.
Tabela de Tipo de variáveis.
É importante
saber a tabela de dados de variáveis para otimizar a criação das mesmas, desde
que não seja criada variável, que não comporta um determinado valor, ou que
comporte, mas fique utilizando um espaço muito grande desnecessariamente.
C# Type
|
.NET Framework type
|
Valores possíveis de se armazenar
|
|
System.Boolean
|
Verdadeiro ou Falso (Valores booleandos)
|
byte
|
System.Byte
|
0 a 255 (8 bits)
|
sbyte
|
System.SByte
|
-128
a
127 (8 bits)
|
char
|
System.Char
|
Um caractere (16 bits)
|
decimal
|
System.Decimal
|
±1.0 × 10-28 a ±7.9 × 1028 (128 bits)
|
double
|
System.Double
|
±5.0 × 10-324 a ±1.7 × 10308 (64
bits)
|
float
|
System.Single
|
±1.5 × 10-45 a ±3.4 × 1038 (32 bits)
|
int
|
System.Int32
|
-2,147,483,648 a 2,147,483,647 (32 bits)
|
uint
|
System.UInt32
|
0 a 4,294,967,295 (32 bits)
|
long
|
System.Int64
|
-9,223,372,036,854,775,808 a
9,223,372,036,854,775,807 (64 bits)
|
ulong
|
System.UInt64
|
0 a 18,446,744,073,709,551,615 (64 bits)
|
object
|
System.Object
|
Qualquer tipo.
|
short
|
System.Int16
|
-32,768
a
32,767 (16 bits)
|
ushort
|
System.UInt16
|
0 a 65,535 (16 bits)
|
string
|
System.String
|
Seqüência de caracteres (16 bits por
caractere)
|
Subprogramas
A finalidade de desenvolver um
subprograma, em outras linguagens, chamado de funções, é diminuir a quantidade
de linhas de programação. Vamos usar, como exemplo, a validação de CPF. Em um
determinado programa, temos o cadastro de clientes, fornecedores (podendo ser
pessoas físicas), funcionários, alunos, professores. Em todos estes exemplos,
teremos que validar o CPF que foi digitado, este com 11 caracteres sem a
máscara de entrada.
Vamos ver, abaixo, o código para
validar o CPF.
public bool Valida(string cpf)
{
int[] multiplicador1 = new int[9]
{ 10, 9, 8, 7, 6, 5, 4, 3, 2 };
int[] multiplicador2 = new int[10]
{ 11, 10, 9, 8, 7, 6, 5, 4, 3, 2 };
string tempCpf;
string digito;
int soma;
int resto;
cpf = cpf.Trim();
cpf = cpf.Replace(".", "").Replace("-", "");
if ((cpf
== "00000000000")
(cpf == "11111111111")
(cpf == "22222222222")
(cpf == "33333333333")
(cpf == "44444444444")
(cpf == "55555555555")
(cpf == "66666666666")
(cpf == "77777777777")
(cpf == "88888888888")
(cpf == "99999999999"))
{
return (false);
}
if (cpf.Length != 11)
return false;
tempCpf = cpf.Substring(0, 9);
soma = 0;
for (int i = 0; i < 9; i++)
soma += int.Parse(tempCpf[i].ToString())
* multiplicador1[i];
resto = soma % 11;
if (resto < 2)
resto = 0;
else
resto = 11 - resto;
digito = resto.ToString();
tempCpf = tempCpf + digito;
soma = 0;
for (int i = 0; i < 10; i++)
soma += int.Parse(tempCpf[i].ToString()) * multiplicador2[i];
resto = soma % 11;
if (resto < 2)
resto = 0;
else
resto = 11 - resto;
digito = digito + resto.ToString();
return cpf.EndsWith(digito);
}
Resumindo a finalidade de um
subprograma, é colocar um código em uma função e chamá-la toda vez que for
necessário, diminuindo, consideravelmente, as linhas de código e, por sua vez,
do executável do programa, uma vez pensando em portabilidade e desenvolvimento
de programas para equipamentos portáteis (palm, pocket, ...), temos que levar
isto em consideração.
Para chamarmos esta validação, vamos
colocar as linhas de código no evento Validated de um componente textBox.
private void textBox1_Validated(object sender, EventArgs e)
{ if (Valida(textBox1.Text))
{ MessageBox.Show("Certo");
}
else
{ MessageBox.Show("errado");
}}
Mensagens
O nosso próximo tópico são as mensagens que podemos fazer
com que o nosso sistema exiba. Isto é algo muito imporante, pois pense da
seguinte forma: como você, programador, que está desenvolvendo um sistema, irá
comunicar-se com o usuário do sistema, sem estar próximo ao usuário, sem usar
telefone, e-mail, ou qualquer outra forma de comunicação? É através das
mensagens exibidas pelo sistema. Como: "Arquivo salvo com sucesso!",
"Falha na comunicação! Verifique!", "Erro, o campo não pode
ficar vazio!", "A data deve estar no formato dia/mês/ano" e
muitas outras mensagens que podemos montar para comunicar-mos com o usuário. Vamos
ver, detalhadamente, os tipos de mensagens.
MessageBox.Show("Texto", "Título");
Na mensagem a qual define-se os botões que
aparecerão, temos:
MessageBox.Show("Texto","Título",MessageBoxButtons.AbortRetryIgnore);
AbortRetryIgnore OK
OKCancel
RetryCancel YesNo
YesNoCancel
Podemos
colocar uma imagem à esquerda da mensagem para enfatizar o tipo de mensagem.
Pode ser:
MessageBox.Show("Texto", "Título", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
Asterisk Error
Exclamation
Hand Information None
Question Stop Warning
Podemos, também, através de mensagens,
fazer perguntas ao usuário, da seguinte forma:
if (MessageBox.Show("Deseja sair
?", "Solicitação", MessageBoxButtons.YesNo) == DialogResult.Yes)
{ Close(); }
Yes Abort Cancel
Ignore No None
OK Retry
Comandos em Visual C#
Conversores
Temos que pensar o seguinte: quando
montamos uma mensagem, o que precisamos para exibir na tela é um texto (no formato de texto) que aparecerá no
título ou no corpo da mensagem. Caso precisamos mostrar algum item que não é
texto, por exempo uma data, hora, número. Temos que fazer a conversão destes
valores.
Nestas conversões, podemos basear em
nossa tabela de tipos de variáveis, Convert.To[tipo de variavel](o que quero
converter)
Vamos ver alguns exemplos:
Convert.ToString(DateTime.Now) Convert.ToString(i)
Convert.ToDecimal(textBox1.Text) Convert.ToDateTime(textBox1.Text)
Concatenação
Nosso próximo passo é o trabalho com a
Concatenação de textos. Concatenação nada mais é do que a soma de texto.
Vamos ver alguns exemplos:
VarNome = "Anna";
VarSobrenome = "Silva";
NomeCompleto = VarNome + " "
+ VarSobrenome;
Ficando assim "Anna Silva",
somamos "Anna" mais um espaço mais "Silva"
Um outro bom exemplo é a montagem de um
texto com vários tipos de dados:
"Tarefa realizada dia " + string.Format("{0:dd/MM/yyyy}",
DateTime.Now) + " as " + string.Format("{0:HH:mm:ss}",
DateTime.Now)
Ficando assim:
Tarefa realizada dia 23/03/2009 as 22:25:10
O Comando
string.Format("{0:dd/MM/yyyy}", DateTime.Now) está formatando uma
data no formato dia / mês / ano e convertendo para texto.
Estrutura de Decisão
A estrutura de decisão já foi usada
para implementar alguns exemplos vistos acima. A sua finalidade é executar uma
deterinada linha de comando ou linhas de comandos, dependendo do resultado de
um teste, um teste lógico.
Para compreendermos melhor este teste,
vamos pensar que estamos fazendo uma comparação, e o resultado desta
comparação é Sim ou Não, ou como a linguagem de
programação trabalha (true ou false). Podemos também seguir outra linha de
raciocínio: nós estamos fazendo uma afirmação, e em uma afirmação pode
ter apenas dois resultados, Verdadeiro ou Falso.
As comparações ou afirmações são testes
lógicos, pondendo ser:
Relacionais
|
==
Igualdade
|
>
Maior
|
<
Menor
|
!=
Diferente
|
>=
Maior igual
|
<=
Menor igual
|
Temos inúmeras formas de trabalharmos
com estruturas de desisão. Vamos ver, então:
(nos exemplos abaixo, vamos considerar
que já temos as variáveis criadas)
- Um teste com uma
linha de programação, no caso, verdadeira:
if (x == 0) // se x for igual a 0 (zero)
y = x;
- Um teste com duas ou
mais linhas de programação, no caso, verdadeiras:
if (x == 0)
{ y = x;
A = y + x; }
- Um teste com uma
linha de programação, no caso, verdadeira, e uma linha de programação, no
caso, falsa:
if (x == 0)
y = x;
else
y = a;
- Um teste com duas ou
mais linhas de programação, no caso, verdadeiras, e duas ou mais linhas de
programação, no caso, falsas:
if (x == 0)
{ y = x;
a = 5;}
else
{ y = a;
a = 2; }
- Dois testes com duas
ou mais linhas de programação, no caso, verdadeiras, e duas ou mais linhas
de programação, no caso, falsas:
if ((x == 0) && (y!=0))
// se x for igual a 0 E y for diferente de 0
{ y = x;
a = 5;}
else
{ y = a;
a = 2; }
- Dois testes com
duas ou mais linhas de programação, no caso, verdadeiras, e duas ou mais
linhas de programação, no caso, falsas:
if ((x == 0) (y!=0)) // se x for igual a
0 OU y
for diferente de 0
{ y = x;
a = 5;}
else
{ y = a;
a = 2; }
- Dois Ifs, com um teste cada e um
dentro do outro, com uma linha de programação em cada caso:
decimal x = 0;
string res = "";
if (x >= 7) // se x maior
ou igual a 7
res = "Aprovado";
else
if (x >= 5) // no caso
falso do 1° if tem outro if
res = "Recuperacao";
else
res = "Reprovado";
- Dois
Ifs, um com dois testes e, no caso falso, outro teste com uma linha de comando:
decimal nota = 0, freq = 0;
string res = "";
if ((nota >= 7)
&& (freq >= 75))
res = "Aprovado";
else
if (nota >= 5)
res = "Recuperacao";
else
res = "Reprovado";
- Um teste com negação com uma linha de programação, no caso,
verdadeiro:
if (!(x == 0)) // se x for não igual a 0
(zero)
y = x;
Estrutura de Decisão (case).
Quando temos uma quantidade muito grande
de testes, podemos utilizar, em vez do IF, o Switch ... case:
string Semana = "";
int DiaDaSemana = (int)DateTime.Now.DayOfWeek;
switch (DiaDaSemana)
{ case 0: { Semana = "Domingo"; break; }
case 1: { Semana = "Segunda-Feira"; break; }
case 2: { Semana = "Terça-Feira"; break; }
case 3: { Semana = "Quarta-Feira"; break; }
case 4: { Semana = "Quinta-Feira"; break; }
case 5: { Semana = "Sexta-Feira"; break; }
case 6: { Semana = "Sábado"; break; }
default: break; }
MessageBox.Show(Semana);
Nesta codificação, temos um teste no qual
temos a data corrente, pego do sistema operacional e, através do comando
DayOfWeek, obtemos os valores que variam de 0 (Domingo) a 6 (Sábado).
Blocos de Comando
Todos os comandos em C# tem que
terminar com um ponto-e-vírgula ( ; ) e esses comandos tem que estar
delimitados por um bloco que tem início e fim, representados no C# pelos
caracteres abre-chaves ( { ), que define o início do bloco e fecha-chaves ( }
), que define o fim do bloco.
O namespace precisa ser delimitado com
um início e fim, no caso, com { e }, assim como o classe e o método Main.
Outras estruturas precisam ser delimitadas, e que serão vistas ao longo desta
unidade.
Formatação de Dados
A formatação de dados é uma ferramenta
muito importante para demonstrar um determinado dado em um layout amigável para
o usuário, ou de uma forma que se necessita. Vamos observar alguns exemplos de
formatação de datas
Formatação da data abaixo, apresenta o
dia como 25
listBox1.Items.Add("dd "+ string.Format("{0:dd}", DateTime.Now));
Formatação da data
abaixo, apresenta o dia da semana como qua
listBox1.Items.Add("ddd " + string.Format("{0:ddd}", DateTime.Now));
Formatação da data
abaixo, apresenta o dia da semana como quarta-feira
listBox1.Items.Add("dddd " + string.Format("{0:dddd}", DateTime.Now));
Formatação da data
abaixo, apresenta o mes como 03
listBox1.Items.Add("MM " + string.Format("{0:MM}", DateTime.Now));
Formatação da data
abaixo, apresenta o mes como mar
listBox1.Items.Add("MMM " + string.Format("{0:MMM}", DateTime.Now));
Formatação da data
abaixo, apresenta o mes como março
listBox1.Items.Add("MMMM " + string.Format("{0:MMMM}", DateTime.Now));
Formatação da data
abaixo, apresenta o ano como 09
listBox1.Items.Add("yy
" + string.Format("{0:yy}", DateTime.Now));
Formatação da data
abaixo, apresenta o ano como 2009
listBox1.Items.Add("yyyy
" + string.Format("{0:yyyy}", DateTime.Now));
Formatação da data
abaixo, apresenta o ano como 25/03/2009
listBox1.Items.Add("dd/MM/yyyy
" + string.Format("{0:dd/MM/yyyy}", DateTime.Now));
Formatação da data
abaixo, apresenta o data como quarta-feira, 25 de março de 2009
listBox1.Items.Add("
" + string.Format("{0:dddd, dd 'de'
MMMM 'de' yyyy}", DateTime.Now));
Formatação da hora
abaixo, apresenta o hora como 20:00:00
listBox1.Items.Add("HH:mm:ss
"+string.Format("{0:HH:mm:ss}", DateTime.Now));
Formatação da hora
abaixo, apresenta o hora como 20 (formato de 24 horas)
listBox1.Items.Add("HH " + string.Format("{0:HH}", DateTime.Now));
Formatação da hora
abaixo, apresenta o hora como 08 (formato de 12 horas)
listBox1.Items.Add("hh " + string.Format("{0:hh}", DateTime.Now));
Para a formatação de
números, com uma determinada quantidade de zeros antes do número, com
finalidade de preenchimento, podemos utilizar o .ToString(“00”) e informar a quantidade de
zeros referente a quantidade de dígitos que desejamos ao todos
txbAula.Text = Convert.ToInt32(txbAula.Text).ToString("0000");
Para formatar um número,
utilizando duas casas decimais e indiferente da quantidade de dígitos
(formatado pelo #).
txbAula.Text = Convert.ToDecimal(txbAula.Text).ToString("###,##0.00");
Comandos em C#
Upper: em relação a caracteres maiúsculos e
minúsculos, temos algo chamado "case sensitive". Temos que pensar que
"E" é diferente de "e", porque disto? Internamente, o
caractere "E" é um código e o caractere "e" é outro código.
Quando precisamos fazer uma comparação, colocamos a comparação entre as letras,
mas o computador faz a comparação utilizando estes códigos.
Uma dica muito importante, quando
estamos fazendo comparações como no exemplo, temos um campo para o usuário
informar "A" para ativo ou "I" para inativo e dentro do seu
programa tem uma comparação como if (varStatus == "A") e se o usuário
informou "a". O resultado desta comparação será falso, pois
"a" é diferente de "A".
Temos duas formas para forçar com que
fique tudo em maiúsculo. Uma delas é utilizar o componente textBox. Colocar a propriedade CharacterCasing como Upper, desta forma, a entrada de
dados no textbox será tudo maiúsculo, independentemente do usuário digitar maiúsculo
ou minúsculo. Outra forma é utilizar programação. Vamos ver o código abaixo.
if (varStatus.ToUpper()
== "A")
Na propriedade CharacterCasing, podemos
utilizar as opções (normal, upper, lower). Nas linhas de código, as opções são
(ToLower(),ToUpper())
Vamos ver, agora, outros comandos para
serem utilizados com tipo de dados texto.
Trim: o comando trim é utilizado para tirar
os espaços antes e depois do texto.
textBox1.Text = textBox1.Text.Trim();
Podemos utilizar as variações para
remover os espaços anteriores com TrimStart(), ou remover os espaços
posteriores do texto usando o comando TrimEnd(). Este comando não remove
espaços que estão entre os caracteres. Por exemplo, se foi digitado "A B",
os espaços entre A e B não serão removidos, mas, se for digitado " AB
", será removido deixando "AB".
Replace: o comando replace é usado para
substituir valores de uma string. Vamos ver o exemplo.
textBox1.Text =
textBox1.Text.Replace("A","@");
Neste exemplo, estamos substituindo o
character "A" pelo caracter "@".
Substring: é o recurso de copiarmos uma parte de
uma string, utilizando o comando substring. Temos que prestar atenção em um
caso: a numeração começa por zero, sendo que a primeira letra é o 0, a segunda é o 1, e assim
por diante. No exemplo abaixo, estamos copiando a
partir da
primeira posição (0) e estamos copiando 5 caracteres
textBox1.Text = textBox1.Text.Substring(0,5);
Remove: na mesma ideia do comando substring,
temos o comando remove, que tem a finalidade de remover certa quantidade de
caracteres de uma string. No exemplo abaixo, estamos removendo 2 caracteres a
partir da primeira posição (0).
textBox1.Text = textBox1.Text.Remove(0,2);
Length: é o comando que conta quantos caracteres
tem uma string,
if (txbCPF.Text.Length == 11)
Neste exemplo, estamos testando se o
que foi digitado no textbox, chamado txbCPF, tem 11 caracteres, pois é a
quantidade de dígitos do CPF.
Insert: usado para adicionar um texto em um
determinado ponto da string. No exemplo abaixo, estamos adicionando o texto
" - PR" no final do texto.
int t;
t = textBox1.Text.Length;
textBox1.Text = textBox1.Text.Insert(t, " - PR");
No exemplo, o nosso texto é uma cidade
do Paraná, mas temos cidade com o nome de Londrina, Santo Antonio da Platina,
Guarapuava, Cambé. Vimos que não podemos colocar o texto " - PR" em
um ponto fixo, porque o nome das cidades não tem a mesma quantidade de caracteres.
Para resolver este problema, utilizamos o comando length, para saber quantos
caracteres temos e se este valor foi armazenado em uma variável inteira chamada
t, e se ela foi usada para informar, no comando insert, o ponto inicial de
inserção do texto " - PR".
Podemos simplificar o comando, usando a
sintaxe a baixo
textBox1.Text = textBox1.Text.Insert(textBox1.Text.Length, " -
PR");
Comandos de repetição
e tratamento de erros
Rotinas de Repetição (laço)
Existem casos em que precisamos executar
um mesmo comando inúmeras vezes, alguns já pré-definidos, outros que não
sabemos quantas vezes. Em vez de colocar um comando para executá-lo 10 vezes,
por exemplo, podemos usar um comando de repetição, também conhecido como
comando de laço ou loop, para executar um loop de 10 voltas.
Existem vários comandos que executam
estas tarefas. Vamos, agora, ver alguns tipos e analisá-los, para identificar a
aplicação que mais se enquadra com cada particularidade de comandos de laço.
for (int i = 0; i <= 10; i++)
{ listBox1.Items.Add(Convert.ToInt16(i)); }
For: Neste exemplo, usamos o comando for
para executar uma rotina, que será, nesse caso, repetida 11 vezes. Vamos ver
por quê?
Neste comando de laço, a primeira linha
é dividida em 3 partes, que estão dentro dos parênteses. Na primeira parte do
comando for foi criada uma variável do tipo inteiro, pois o comando precisa de
uma variável para controle interno das voltas. Então, foi usado no exemplo a
variável com o nome de "i", iniciada com valor 0 (zero). Este é o
valor inicial do loop. Na segunda parte, temos até quando será executado o
loop. Podemos comprar esta parte ao comando IF, porque é feita uma comparação e,
enquanto esta condição for verdadeira, será executado o comando. Nesta
comparação, poderemos utilizar todos os comandos relacionais já mencionados nas
explicações do comando if.
Importante: utilização das comparações
< e <= e também do valor inicial.
Na terceira parte, temos o
incrementador, algo muito importante também no comando de laço, pois a nossa
variável de controle é incrementada e, por isso, em algum momento, a comparação
não será mais atendida, sendo a condição de saída do loop. Se não tivéssemos
este incremento, a nossa variável iniciaria com zero e nunca chegaria a ser
maior que 10 que, em nosso exemplo, é a condição de saída do laço.
Teste de mesa
for (int i = 0; i <= 10; i++)
|
Valor
Inicial =>
|
0
|
Valor
Exibido na listBox
|
0
|
|
1
|
|
1
|
|
:
|
|
:
|
|
9
|
|
9
|
Valor
Final =>
|
10
|
|
10
|
for (int i = 0; i < 10; i++)
|
Valor
Inicial =>
|
0
|
Valor
Exibido na listBox
|
0
|
|
1
|
|
1
|
|
:
|
|
:
|
|
8
|
|
8
|
Valor
Final =>
|
9
|
|
9
|
Observem a diferença em usar o <
(menor) e <= (menor ou igual (pense isso como apenas um sinal)). Quando
utilizamos <, o número que comparamos não entra na sequência. Já quando
usamos o <=, o número que comparamos entra na exibição.
for (int i = 10; i >= 0; i--)
{ listBox1.Items.Add(Convert.ToInt16(i)); }
Podemos, também, fazer um loop
decrescente. No exemplo acima, iniciando em 10 e sendo executado até a nossa
variável de controle chegar a 0, e na parte a qual é feito o incremento, temos
que fazer o decremento (i--). No caso de necessitarmos de em intervalo maior,
teremos que realizar cálculos. (i = i - 2)
for (int i = 0; i <=
Convert.ToInt32(textBox1.Text); i++)
{ listBox1.Items.Add(Convert.ToInt16(i)); }
O comando for precisa saber o valor
inicial e o valor final, antes de começar a executar o comando de laço. Mas
este valor inicial e, no exemplo do valor final, podemos definir no momento de
execução com o valor que foi informado em uma textBox.
for (int i = 0; i <= 20; i = i+2)
{ listBox1.Items. Add("Número par: "+Convert.ToInt16(i)); }
Neste exemplo, iniciamos a variável com
zero e vamos executar até 20, e o nosso incremento é de 2 em 2. Com isso, vamos
mostrar apenas os número pares.
Muito simples. Agora, pense como fazer
para mostrar apenas os números ímpares de 1 a 30?
While: vamos, agora, passar para uma outra
forma de laço: o comando while, que, no final das contas, faz a mesma coisa,
mas tem a suas particularidades. Vamos ver, então?
int contador = 0;
while (contador <= 10)
{ listBox1.Items.Add(Convert.ToInt16(contador));
contador++; }
Se formos executar o teste de mesa com
este comando de laço, veremos que ele fará a mesma coisa que exemplificamos com
o comando for. Vamos analisar as semelhanças:
No for, temos uma variável que foi
inicializada com zero. Aqui, temos também, apenas com outro nome. Como
contador, a condição de saída, a variável <= 10, também se pode usar as
mesmas regras utilizadas anteriormente. E, para finalizar o incremento ao
contador, é feito dentro do bloco que será executado.
Aqui, não mudou em nada na utilização
do for com o while. Para esta finalidade, poderíamos escolher qualquer um, que
funcionaria perfeitamente.
Mas o while foi desenvolvido para
termos uma flexibilidade maior com rotinas de repetição. Vamos trabalhá-lo mais
na próxima disciplina de LPT III, quando precisaremos percorrer uma tabela até
que chegue ao seu final. Neste caso, não teremos o valor que será o valor
final, então informaremos até final do arquivo.
Do: Temos mais um comando de laço, o
comando do:
int contador = 0;
do
{ listBox1.Items.Add(Convert.ToInt16(contador));
contador++; }
while (contador <= 10);
Este comando é bem pouco utilizado,
principalmente pela forma que ele trabalha.
Enquanto os comandos for e while
trabalham fazendo o teste e, dependendo do resultado, executa o loop, já no do,
ele faz o seguinte: executa e faz o teste. Como podemos visualizar no exemplo
acima, é inicializado um contador e, aí, começa o loop, que, neste caso, está
mostrando o valor do contador dentro do componente listbox. Incrementa o
contador e só depois faz o teste se é para continuar.
Vamos com a seguinte linha de
raciocínio: veja o exemplo abaixo.
int contador=20;
do{
listBox1.Items.Add(Convert.ToInt16(contador));
contador++; }
while (contador <= 10);
A variável foi inicializada com valor
20 e é para ter sido executada enquanto o contador for menor ou igual a 10, só
que tivemos um problema: o número 20, nosso valor inicial, já foi exibido e,
após o teste, constatou que não é para ter prosseguido, porque 20 não é menor
ou igual a 10 e saiu fora do loop.
Nos casos do "while" e do
"do", em que o controle está dentro do bloco de repetição, temos que
cuidar, pois há diferença entre exibir um resultado e calcular de calcular e exibir o resultado.
Vamos ver um teste de mesa para ver, na prática, como fica?
int contador = 0;
while (contador
<= 4)
{
listBox1.Items.Add(Convert.ToInt16(contador));
contador++;
}
|
contador
0
1
2
3
4
5
|
Tela
0
1
2
3
4
|
Neste teste de mesa, o contador é
iniciado com zero e logo entra no loop, mostra o valor, soma 1 e volta para o
teste. Na última volta, ele está valendo 5 e não passou no teste do while,
fazendo com que saia do loop.
int contador = 0;
while (contador <=
4)
{
contador++;
listBox1.Items.Add(Convert.ToInt16(contador));
}
|
contador
0
1
2
3
4
5
|
Tela
1
2
3
4
5
|
Neste outro caso, em que é somado e
mostrado o valor, a variável é iniciada com zero e entra no loop. Logo depois,
é somado 1 à variável contador e logo após exibido o valor que é 1. Na última
volta, o contador vale 4, é somando mais 1, passando para 5 e exibido. Não
passando mais pelo teste, sai do loop.
Controle de exceções.
A grande finalidade de trabalharmos com
controle de exceções é de mostrarmos uma mensagem amigável ao usuário, ao invés
de ser exibidas as mensagens padrão do visual c#. Vamos ver, então?
int X = 0;
string vfinal = "";
try
{ X = Convert.ToInt16(textBox1.Text);
vfinal = "conversao de dados
correta"; }
catch (Exception)
{ vfinal = "erro na
conversao de dados"; }
finally
{ MessageBox.Show(vfinal); }
Neste caso, estamos fazendo uma
conversão de um valor texto de uma textbox para um valor inteiro de uma
variável. Para testarmos, criamos uma variável string que exibirá a mensagem
"conversao de dados correta", no caso da conversão ser realizada com
sucesso. No caso de erro na conversão, será interrompida a execução e executado
o catch, no caso de uma exceção genérica, e será carregada à variável o texto
"erro na conversao de dados". Ao final do bloco do try, tem o
finally, que será executado no final, após ter ocorrido tudo certo ou quando
houve um erro.
Observe as mensagens e coloque-se no
lugar do usuário. Se aparecer a mensagem de erro padrão, em inglês, após 30
segundos, o telefone do desenvolvedor está tocando, pois o usuário não sabe o
que fazer.
Além do mais, no caso de clicar no
botão Quit, a aplicação será finalizada.
int i = 2, z = 0;
try
{ i = i / z; }
catch (DivideByZeroException)
{ MessageBox.Show("Erro nao
pode dividir por zero"); }
No exemplo acima, forçamos um erro em
que um número é dividido por zero, e que não pode ser executado na matemática.
Neste caso, temos um catch especifico para esta situação. Podemos
ter inúmeros tipos de tratamento de exceções. Para vermos a lista completa,
podemos fazer o seguinte: digitar catch e, neste ponto, pressionarmos a tecla
Ctrl+Barra de espaço. Aparecerá uma lista do auto-completar na qual podemos
percorrê-la com as setas para cima e para baixo.