Além das condições simples e compostas, podemos também ter estruturas aninhadas, que basicamente seria if e else dentro de outros if e else, eles também foram resumidos para else if (que executa outra condição após o if (ou else if anterior) não equivaler ao teste lógico deste).
Veja um exemplo logo abaixo:
using System;
namespace EstruturaDecisaoCondicionalAninhada {
class Program {
static void Main(string[] args) {
int dia;
string nome;
Console.Write("Digite o dia da semana, de 1 a 7: ");
dia = int.Parse(Console.ReadLine());
if(dia == 1) {
nome = "Domingo";
}
else if(dia == 2) {
nome = "Segunda-feira";
}
else if(dia == 3) {
nome = "Terça-feira";
}
else if(dia == 4) {
nome = "Quarta-feira";
}
else if(dia == 5) {
nome = "Quinta-feira";
}
else if(dia == 6) {
nome = "Sexta-feira";
}
else if(dia == 7) {
nome = "Sábado";
}
else {
nome = "Dia Inválido";
}
Console.Write("O dia escolhido foi {0}.", nome);
Console.Read();
}
}
}
PS: Esse modo acima é apenas modo educacional, para esse tipo de código, é melhor usar o switch case.
O comando goto (vai para) que direciona o ponteiro de execução do nosso programa, quando ele encontra o goto, ele vai até o label indicado em qualquer ponto do programa (criado apenas com o nome e dois pontos), e o goto apenas usará o nome do label que indicará.
Veja um exemplo do uso do goto:
int n1, n2, res;
char opc; // Variável usada no label.
inicio: // Label, indicado com dois pontos.
Console.Clear();
Console.Write("Digite a primeira nota: ");
n1 = Int32.Parse(Console.ReadLine());
Console.Write("Digite a segunda nota: ");
n2 = Int32.Parse(Console.ReadLine());
res = (n1 + n2) / 2;
if(res >= 6) {
Console.WriteLine("Aprovado!\n");
}
else if(res >= 4 && res < 6) {
Console.WriteLine("Recuperação\n");
}
else {
Console.WriteLine("Reprovado\n");
}
Console.Write("\nDeseja Digitar Outras Notas? [S/N]: ");
opc = Char.Parse(Console.ReadLine());
if(Char.ToUpper(opc) == 'S') {
Console.Clear();
goto inicio; // Indicação do Label.
}
PS: Note que o método Char.ToUpper() retorna a letra em maiúscula, temos também o ToLower() que retorna a minúscula.
Assim como as declarações simples, compostas e aninhadas, podemos usar o switch case, que é o condicional de chaveamento, que facilita a leitura e pode deixar o código mais eficiente.
O código anterior pode ser reescrito dessa forma:
using System;
namespace DeclaracaoCondicionaSwitch {
class Program {
static void Main(string[] args) {
int dia;
string nome;
Console.Write("Digite o dia da semana, de 1 a 7: ");
dia = int.Parse(Console.ReadLine());
switch(dia) {
case 1:
nome = "Domingo";
break;
case 2:
nome = "Segunda-feira";
break;
case 3:
nome = "Terça-feira";
break;
case 4:
nome = "Quarta-feira";
break;
case 5:
nome = "Quinta-feira";
break;
case 6:
nome = "Sexta-feira";
break;
case 7:
nome = "Sábado";
break;
default:
nome = "Dia Inválido";
break;
}
Console.Write("O dia escolhido foi {0}.", nome);
Console.Read();
}
}
}
Podemos também fazer algo assim:
switch(dia) {
case 1:
case 7:
nome = "Final de Semana";
break;
case 2:
case 3:
case 4:
case 5:
case 6:
nome = "Durante a semana";
break;
default:
nome = "Dia Inválido";
break;
}
PS: O switch tem suas limitações, por exemplo, só podemos trabalhar com dados int, char e string, não podemos trabalhar por exemplo, com números reais.
Estruturas de repetição são blocos de código que são repetidos em sequência definidamente ou indefinidamente, dependendo do caso.
Usamos a declaração while para rodar um bloco de códigos repetidamente enquanto uma condição de teste especificada retornar verdadeiro.
Veja um exemplo de uso abaixo:
using System;
namespace EstruturaDeRepeticaoWhile {
class Program {
static void Main(string[] args) {
int i = 1;
while(i <= 50) {
Console.WriteLine(i);
i++;
}
Console.Read();
}
}
}
Outro exemplo, mais complexo:
using System;
namespace EstruturaDeRepeticaoWhile {
class Program {
static void Main(string[] args) {
string nome;
Console.Write("Digite uma letra (a para encerrar): ");
nome = Console.ReadLine();
while(nome != "a") {
Console.Write("Digite uma letra (a para encerrar): ");
nome = Console.ReadLine();
Console.WriteLine(nome);
}
Console.Read();
}
}
}
PS: Podemos usar o método Trim() para excluir espaços desnecessários da string.
A estrutura for, também é de repetição, só que ela é usada quando sabemos mais ou menos de antemão quantas vezes terá repetições no nosso programa. No for, temos também melhor controle sobre o início e o fim do loop.
Veja um exemplo de código logo abaixo:
using System;
namespace EstruturaDeRepeticaoFor {
class Program {
static void Main(string[] args) {
int i;
for(i = 1; i <= 50; i++) {
Console.WriteLine(i);
}
Console.Read();
}
}
}
Uma utilização muito comum do for, é em vetores e matrizes.
A estrutura do while funciona de forma um pouco diferente, apesar de parecer bastante com o while, ele executa os dados primeiro antes de testar a condição, mesmo falsa, já que garante pelo menos uma vez a execução do código dentro do loop.
Veja um exemplo abaixo:
using System;
namespace EstruturaDeRepeticaoDoWhile {
class Program {
static void Main(string[] args) {
int i = 1;
do {
Console.WriteLine(i);
i++;
}
while(i <= 50);
Console.Read();
}
}
}
Outro exemplo, que pede os números pelo teclado:
using System;
namespace EstruturaDeRepeticaoDoWhile {
class Program {
static void Main(string[] args) {
int i;
do {
Console.Write("Digite um número (10 para encerrar): ");
i = int.Parse(Console.ReadLine());
Console.WriteLine("O número digitado foi {0}.", i);
}
while(i != 10);
Console.Read();
}
}
}