Toda linguagem disponibiliza uma série de instruções para controlar a maneira controlar o fluxo de execução do programa. São instruções para executar um ou outro conjunto de comando dependendo de uma condição ser verdadeira ou falsa, são instruções para executar um conjunto de comandos um número determinado de vezes e instruções para executar um conjunto de comandos até que uma condição se torne verdadeira ou falsa.

No C#, as instruções de fluxo de controle são divididas em três categorias:

• Instruções de seleção.
• Instruções de repetição.
• Instruções de salto (jump).

A maioria das instruções tem o seu funcionamento baseado em um teste lógico, o qual retorna True ou False.

Instruções de seleção:

As instruções de seleção executam um entre vários comandos disponíveis. O comando a ser executado é selecionado com base no valor de uma expressão.

A instrução if

Este comando seleciona uma comando ou grupos de comando para execução, com base no valor retornado por uma expressão boleana. Uma expressão boleana somente pode retornar dois valores: True ou False.

A forma mais simples deste comando é indicada a seguir:

if expressão

{

            comando1;

            comando2;

            ...

            comandon;

}

Comando1, Comando2 até Comandon somente serão executados se a expressão for verdadeira.Observe que podemos executar mais do que um comando, caso a expressão seja verdadeira. Para isto basta colocar os diversos comandos entre chaves. Considere o seguinte exemplo:

if (x>y)

{

     Console.WriteLine(“X é maior do que y”)

    x = x+1

    y = y-1

}

Os comandos entre as chaves somente serão executados quando x for maior do que y, caso contrário a execução “pula” para o primeiro comando após o fechamento das chaves.

Uma outra forma da instrução if é a que inclui a cláusula else. Com a cláusula else podemos definir um conjunto de comandos que devem ser executados se a expressão de teste retornar False. A sintaxe para esta instrução é a seguinte:

if (x<y)

{

comando1_verdadeiro;

comando2_verdadeiro;

            ...

            comandon_verdadeiro;

}

else

            {

comando1_falso;

comando2_falso;

            ...

            comandon_falso;

            }

Vamos a um exemplo simples, onde o usuário entra com dois valores. O programa devolve diferentes mensagens para o caso do primeiro ser maior do que o segundo ou para o caso do segundo ser maior ou igual ao primeiro.

Considere o exemplo da Listagem 3.7.

Listagem 3.7 – Um exemplo utilizando a instrução if  – ex7cap3.cs

using System;

class ex7cap3

{

            // Exemplo7  - Capítulo 3.

            //  Utilizando a instrução If.

            // Por:  Júlio Battisti

            // MCP,  MCP+I, MCSE, MCSE+I, MCSE, MCDBA

            public  static void Main()

            {

                        //  Declaração das variáveis.

                        int  valor1;

                        int  valor2;

                        //  Entrada dos valores de x e y

                        Console.Write("Digite  o primeiro valor inteiro ->");

                        String  Aux1=Console.ReadLine();

                        Console.Write("Digite  o segundo valor inteiro ->");

                        String  Aux2=Console.ReadLine();

                        //  Converto os valores para inteiro.

                        valor1  = Convert.ToInt32(Aux1);

                        valor2  = Convert.ToInt32(Aux2);

                        //  Teste e exibição dos resultados.

                        if  (valor1>valor2)

                           {

Console.WriteLine("*****************************************");           

Console.WriteLine("PRIMEIRO VALOR É MAIOR DO QUE O  SEGUNDO !");

Console.WriteLine("*****************************************");           

Console.WriteLine("O PRIMEIRO VALOR DIGITADO FOI:  {0}",valor1);

            Console.WriteLine("O  SEGUNDO  VALOR DIGITADO FOI:  {0}",valor2);

            Console.WriteLine("*****************************************");           

                           }

                        else

                          {

                                   Console.WriteLine("*****************************************");           

            Console.WriteLine("PRIMEIRO  VALOR É MENOR OU IGUAL AO SEGUNDO !");

            Console.WriteLine("*****************************************");           

            Console.WriteLine("O  PRIMEIRO VALOR DIGITADO FOI: {0}",valor1);

            Console.WriteLine("O  SEGUNDO  VALOR DIGITADO FOI:  {0}",valor2);

            Console.WriteLine("*****************************************");           

                         }

            }

}

Digite o exemplo da listagem 3.7 e salve o mesmo em um arquivo chamado ex7cap3.cs, na pasta C:\ExCsharp\cap3. Compile e execute o exemplo da listagem 3.7. Para o primeiro valor digite 10 e para o segundo digite 5. Você obterá os resultados indicados na Figura 3.7.

Figura 3.7 Executando o programa ex7cap3.exe.

Repita a execução do programa. Agora digite 10 para o primeiro valor e 15 para o segundo. Você obterá os resultados indicados na Figura 3.8.

Figura 3.8 Executando o programa ex7cap3.exe com novos valores.

Também podemos utilizar mais do que um else na mesma instrução if. Neste caso após a cláusula else iniciamos um novo if. A melhor maneira de entendermos esta estrutura é através de um exemplo. Vamos supor que você tenha que executar diferentes comandos dependendo do valor de uma variável x ser igual a 0, 1, 2, ou 3. Para isso poderíamos utilizar o seguinte bloco de código:

if (x == 0)

{

    comandos para x =  0

}

else if (x == 1)

{

                comandos para x = 1

            }

else if (x==2)

{

                comandos para x = 2

            }

else

{

                comandos para x = 3

            }

Observe que a última hipótese (x == 3) não precisamos testar, pois se a execução chegou até o último else é porque x não é igual a 0, nem igual a 1 e nem igual a 2. Quando um dos testes for verdadeiro, os comandos associados são executados e a execução “pula” para o primeiro comando após o bloco if.

Importante = Observe que o operador para comparação de igualdade não é um sinal simples de igual (=), ao invés disso é um sinal duplo de igualdade (==). O operador simples (=) é utilizado para atribuição de valores para variáveis. Para comparação utiliza-se o operador ==.

Na Tabela 3.3 temos uma descrição dos principais operadores de comparação.

Tabela 3.3 Os principais operadores de comparação.

Porém para situações em que temos que testar várias possibilidades, a utilização de sucessivas instruções if-else pode não ser a solução mais adequado. Para isso temos a instrução switch.

A instrução switch

A instrução switch tem uma expressão de controle bem no início do laço. Com base no valor da expressão de controle, diferentes comandos serão executados.

Sintaxe para a instrução switch:

switch (expressão_de_controle)

            {

                        case  valor_1:

                                   comando1;

                                   comando2;

                                   ...

                                   comandon;

                                   comando  para sair;

                        case  valor_2:

                                   comando1;

                                   comando2;

                                   ...

                                   comandon;

                                   comando  para sair;

                        ...

                        case  valor_n:

                                   comando1;

                                   comando2;

                                   ...

                                   comandon;

                                   comando  para sair;

                        default:

                                   comando1;

                                   comando2;

                                   ...

                                   comandon;

                                   comando  para sair;

     }

Para a expressão de controle podemos utilizar os seguintes tipos: sbyte, byte, short, ushort, long, ulong, char, string ou um tipo de enumeração.

A expressão_de_controle é avalidada. Se um dos valores (valor_1, valor_2, etc) for coincidente com o valor da expressão_de_controle, os comandos respectivos serão executados. Se não tivermos nenhuma coincidência, os comandos do rótulo default: serão executados. Se não houver um rótulo default, e não houver coincidência com nenhum valor, a execução segue para o primeiro comando após o final do bloco switch.

“comando para sair” é um comando que faz com que a execução saia do bloco switch, de tal maneira que os demais valores não precisem ser avaliados, uma vez que uma coincidência já foi encontrada ou os comandos relacionados ao rótulo default: foram executados. O comando mais comumente utilizado é o break.

Vamos a um exemplo simples, onde o usuário deve digitar um valor entre 1 e 7. O programa informa o dia da semana correspondente, de acordo com o seguinte critério:

 Domingo             =  1

 Segunda-feira       =  2

 Terça-feira         =  3

 Quarta-feira        =  4

 Quinta-feira        =  5

 Sexta-feira         =  6

 Sábado              =  7

Considere o exemplo da Listagem 3.8.

Listagem 3.8 – Um exemplo utilizando a instrução switch  – ex8cap3.cs

using System;

class ex8cap3

{

            // Exemplo  8 - Capítulo 3.

            //  Utilizando a instrução switch.

            // Por:  Júlio Battisti

            // MCP,  MCP+I, MCSE, MCSE+I, MCSE, MCDBA

            public  static void Main()

            {

               // Declaração da variável do tipo inteiro.

               int dia;

               // Entrada do valor pelo usuário.

               Console.Write("Digite um número inteiro  entre 1 e 7 ->");

               String Aux1=Console.ReadLine();

                //  Converto o valor para inteiro.

               dia  =  Convert.ToInt32(Aux1);

               // Utilizo switch para testar o valor da  variável dia.

               switch (dia)

                 {

                  case 1:

                        Console.WriteLine("*****************************************");           

                        Console.WriteLine("VOCÊ  ESCOLHEU O DOMINGO !!");

                        Console.WriteLine("*****************************************");           

                        break;

                   case 2:

            Console.WriteLine("*****************************************");           

                        Console.WriteLine("VOCÊ  ESCOLHEU A SEGUNDA-FEIRA !!");

                        Console.WriteLine("*****************************************");           

                        break;

                    case 3:

                        Console.WriteLine("*****************************************");           

                        Console.WriteLine("VOCÊ  ESCOLHEU A TERÇA-FEIRA !!");

                        Console.WriteLine("*****************************************");           

                        break;

                    case 4:

                        Console.WriteLine("*****************************************");           

                        Console.WriteLine("VOCÊ  ESCOLHEU A QUARTA-FEIRA !!");

                        Console.WriteLine("*****************************************");           

                        break;

                  case 5:

                        Console.WriteLine("*****************************************");           

                        Console.WriteLine("VOCÊ  ESCOLHEU A QUINTA-FEIRA !!");

                        Console.WriteLine("*****************************************");           

                        break;

                  case 6:

                        Console.WriteLine("*****************************************");           

                        Console.WriteLine("VOCÊ  ESCOLHEU SEXTA-FEIRA !!");

                        Console.WriteLine("*****************************************");           

                        break;

                  case 7:

                        Console.WriteLine("*****************************************");           

                        Console.WriteLine("VOCÊ  ESCOLHEU O SÁBADO !!");

                        Console.WriteLine("*****************************************");           

                        break;

                  default:

                        Console.WriteLine("*****************************************");           

                        Console.WriteLine("VOCÊ  NÃO DIGITOU UM VALOR ENTRE 1 E 7 !!");

                        Console.WriteLine("*****************************************");           

                        break;

            }  //Esta chave fecha o laço switch.

       } //Esta chave  fecha o método Main()

} Esta chave fecha a classe ex8cap3.

Digite o exemplo da listagem 3.8 e salve o mesmo em um arquivo chamado ex8cap3.cs, na pasta C:\ExCsharp\cap3. Compile e execute o exemplo da listagem 3.8. Digite o valor 5. Você obterá os resultados indicados na Figura 3.9.

Figura 3.9 Executando o programa ex8cap3.exe.

Repita a execução do programa. Agora digite 10. Você obterá os resultados indicados na Figura 3.10.

Figura 3.10 Executando o programa ex8cap3.exe com um valor igual a 10.

Instruções de repetição:

As instruções de repetição, como o próprio nome sugere, permitem que um conjunto de comandos sejam executados um número definido de vezes ou até que uma determinada condição seja verdadeira. Vamos estudar as seguintes instruções:

• for
• while
• do/while
• foreach

A instrução for

Este instrução é utilizada para repetir um ou mais conjuntos, um número determinado de vezes. A instrução for do C# é praticamente igual ao comando for do C/C++. É composta de três partes, conforme indicado na sintaxe a seguir:

    for  (inicialização; expressão boleana; incremento)

            {

                        comando1

                        comando2

                        ...

                        comandon

            }

O número de vezes que os comandos da instrução for serão executados é determinado por uma variável de controle. Na primeira parte do laço for, definimos um valor para esta variável. Na segunda parte fazemos um teste para ver se a variável já atingiu um valor limite. A terceira e última parte informa o incremento da variável a cada passagem do laço.

Enquanto a expressão boleana for verdadeira, os comandos do laço continuam a ser executados. Quando a expressão torna-se falsa, a execução “pula” para o primeiro comando após a chave de fechamento do laço for.

Vamos a um exemplo simples, onde são exibidos os números entre 1 e 10 e o valor do número elevado ao quadrado e ao cubo.

Considere o exemplo da Listagem 3.9

using System;

class ex9cap3

{

            // Exemplo9  - Capítulo 3.

            // A  instrução for.

            // Por:  Júlio Battisti

            // MCP,  MCP+I, MCSE, MCSE+I, MCSE, MCDBA

            public  static void Main()

            {

                        //  Declaração da variável.

                        int  i;

                        //  Laço for que é executado dez vezes.

                    Console.WriteLine("Número"+"\t"+"Quadrado"+"\t"+"Cubo"); 

                        for  (i=1;i<=10;i++)

                           {

                                   Console.Write(i+"\t");

                                   Console.Write("{0}"+"\t"+"\t",i*i);

                                   Console.WriteLine("{0}",i*i*i);

                           }

            }

}

Digite o exemplo da listagem 3.9 e salve o mesmo em um arquivo chamado ex9cap3.cs, na pasta C:\ExCsharp\cap3. Compile e execute o exemplo da listagem 3.9. Você obterá os resultados indicados na Figura 3.11.

Figura 3.11 Executando o programa ex9cap3.exe.

Observe que para o laço for utilizamos uma variável inteira i. Inicializamos a mesma com o valor 1. O teste 1<=10 faz com que o laço seja executado dez vezes. A última parte: i++ e novidade. O operador ++ incremente a variável i de um em um. O resultado é o mesmo que se tivéssemos utilizado: i=i+1. No próximo capítulo faremos um estudo detalhado dos operadores do C#.

Para calcular o quadrado multiplicamos o número por ele mesmo: i*i.

Para calcular o cubo multiplicamos o número por ele mesmo, três vezes: i*i*i.

Na Tabela 3.4 temos uma descrição dos principais operadores aritméticos.

Tabela 3.4 Os principais operadores aritméticos.

Observe que também utilizamos o código de controle \t – tabulação. Utilizamos a tabulação para alinhar os resultados.

Também podemos utilizar instruções for “aninhadas”, isto é, instruções for uma dentro da outra. O uso típico para instruções for aninhadas é para percorrer os valores de uma matriz, onde a instrução for mais externa vai variando o número das linhas e a instrução for mais interna vai variando o número das colunas. Observe o exemplo a seguir:

for (i=1;i<=6;I++)

   {

            for  (j=1;j<=5;j++)

                        {

            Comando1

            Comando2

            ...

            Comandon

}

}

Neste caso primeiro i=1. O programa entra no laço interno e para i=1 o laço interno é executado 6 vezes, ou seja: i=1, j=1 e i=1, j=2 e i=1, j=3 e i=1, j=4 e i=1, j=5 . Agora i é incrementado e torna-se igual a 2. Para i=2 o j varia de 1 à 5 e a história se repete. Até que i tenha variado até 6 e j até 5.

Vamos comprovar estas variações através de um exemplo prático. Neste exemplo utilizaremos dois laços. No laço externo i varia de 1 até 6. No laço interno i varia de 1 até 5. Dentro do laço colocamos comandos que vão exibindo os valores de “i” e “j” respectivamente.

Considere o exemplo da Listagem 3.10

using System;

class ex10cap3

{

            // Exemplo  10 - Capítulo 3.

            //  Instruções for aninhadas.

            // Por:  Júlio Battisti

            // MCP,  MCP+I, MCSE, MCSE+I, MCSE, MCDBA

            public  static void Main()

            {

                        //  Declaração das variáveis.

                        int  i;

                        int  j;

                        //  Laço que é executado com i de 1 até 6

                        //  e com j variando de 1 até 5.

                        Console.WriteLine("i  j"+"\t"+"i  j"+"\t"+"i  j"+"\t"+"i  j"+"\t"+"i  j");                      

                        for  (i=1;i<=6;i++)

                           {

                                   for  (j=1;j<=5;j++)

                                   {

                                     Console.Write(i);

                                     Console.Write("  {0}",j);

                                     Console.Write("\t");

                                   }

                                     Console.WriteLine();

                           }

            }

}

Digite o exemplo da listagem 3.10 e salve o mesmo em um arquivo chamado ex10cap3.cs, na pasta C:\ExCsharp\cap3. Compile e execute o exemplo da listagem 3.10. Você obterá os resultados indicados na Figura 3.12.

Figura 3.12 Executando o programa ex10cap3.exe.

Após encerrada a execução do laço for, a execução segue normalmente para o comando seguinte ao encerramento do laço for. Também podemos utilizar a instrução break, dentro da laço for, para encerra-lo e desviar a execução para o primeiro comando após o encerramento do laço. Normalmente a instrução break é colocada dentro de uma instrução if, de tal maneira que a mesma somente será executada se uma determinada condição for alcançada.

A instrução while.

A instrução while executa um ou mais comandos enquanto uma determinada condição for verdadeira. A condição é testada no início do laço. Se a condição for verdadeira o(s) comando(s) do laço são executados. Ao chegar no final do laço a execução volta para o teste no início do laço while. Se a condição continuar verdadeira o(s) comando(s) são executados novamente e o processo se repete, até que a condição no início do laço se torne falsa. Quando a condição se torna falsa a execução “pula” para o primeiro comando após o final do laço while. A seguir temos a sintaxe para o comando while:

while (condição)

   {

            comando1

            comando2

            ...

            comandon

   }

Importante: Os comandos de dentro do laço devem ser capaz de tornar a condição falsa em um determinado momento, pois caso contrário o laço continuará a ser executado infinitamente. Neste caso teremos criado um laço infinito, no qual o programa ficará executando, normalmente, até congelar.

Uma característica importante da instrução while é que se, no início do laço, a condição já for falsa, os comandos do interior do laço não serão executados nem uma única vez.

Vamos a um exemplo de utilização da instrução While. No exemplo da Listagem 3.11 utilizamos a função While para determinar a soma dos n primeiros números inteiros. O valor de n é informado pelo usuário.

Considere o exemplo da Listagem 3.11

using System;

class ex11cap3

{

            // Exemplo  11 - Capítulo 3.

            //  Instrução while.

            // Por:  Júlio Battisti

            // MCP,  MCP+I, MCSE, MCSE+I, MCSE, MCDBA

            public  static void Main()

            {

                        //  Declaração das variáveis.

                        int  n;

                        int  i;

                        int  soma;

                        //  Entrada do valor de n pelo usuário.

                        Console.Write("Digite  um valor inteiro entre 1 e 100 ->");

                        String  Aux1 = Console.ReadLine();

                        n  = Convert.ToInt32(Aux1);

                        //  Utilizamos o laço While para determinar a soma dos n

                        //  primeiros números inteiros.

                        soma  = 0;

                        i=1;

                        while  (i<=n)

                          {

                                   soma=soma+i;

                                   i=i+1;  //IMPORTANTÍSSIMO

                          }

                        //Exibição  dos resultados.

                        Console.WriteLine("***********************************************");

            Console.WriteLine("Soma  dos números inteiros de 1 a {0}",n);

            Console.WriteLine("***********************************************");

            Console.WriteLine("SOMA  --> {0}",soma);

            Console.WriteLine("***********************************************");

            }

}

Note a observação: //IMPORTANTÍSSIMO. Se não colocássemos essa linha – i=i+1, a variável i não seria incrementada a cada passo do laço e, portanto, o teste (i<=n) nunca se tornaria falso, o que faria com que o laço ficasse executando infinitamente.

Digite o exemplo da listagem 3.11 e salve o mesmo em um arquivo chamado ex11cap3.cs, na pasta C:\ExCsharp\cap3. Compile e execute o exemplo da listagem 3.11. Digite o valor 50. Você obterá os resultados indicados na Figura 3.13.

Figura 3.13 Executando o programa ex11cap3.exe com um valor 50.

Repita a execução do programa. Agora digite 85. Você obterá os resultados indicados na Figura 3.14.

Figura 3.14 Executando o programa ex11cap3.exe com um valor igual a 80.

A instrução do/while.

Com a instrução do/while deslocamos o teste para o final do laço. Com isso estamos garantindo que os comandos no interior do laço serão executados pelo menos uma vez, já que a condição somente será avaliada no final do laço, após os comandos terem sido executados.

A sintaxe para a instrução do/while é a seguinte:

do

   {

            comando1

            comando2

            ...

            comandon

   }

while (teste)

Importante= Os comandos de dentro do laço devem ser capaz de tornar a condição falsa em um determinado momento, pois caso contrário o laço continuará a ser executado infinitamente. Neste caso teremos criado um laço infinito, no qual o programa ficará executando, normalmente, até congelar.

Uma característica importante da instrução while é que os comandos do laço são executados, pelo menos uma vez.

Vamos a um exemplo de utilização da instrução While. No exemplo da Listagem 3.12 utilizamos a função do/while para fazer com que o valor digitado pelo usuário esteja dentro de uma determinada faixa. No nosso caso, queremos que o usuário digite um valor menor do que 10. Se for digitado um valor maior ou igual a 10, o programa apresenta novamente uma mensagem para que seja digitado um valor menor do que 10.

Considere o exemplo da Listagem 3.12

using System;

class ex12cap3

{

            // Exemplo  12 - Capítulo 3.

            //  Instrução do/while.

            // Por:  Júlio Battisti

            // MCP,  MCP+I, MCSE, MCSE+I, MCSE, MCDBA

            public  static void Main()

            {

                        //  Declaração da variável.

                        int  i;

                        //  Enquanto o usuário não digitar um valor menor

                        //  do que 10 o programa não vai adiante.

                        do

                          {

                                   Console.Write("Digite  um valor menor do que 10 ->");

                                   String  Aux1 = Console.ReadLine();

                                   i  = Convert.ToInt32(Aux1);

                          }

                        while  (i>=10);

Console.WriteLine("***********************************************");

Console.WriteLine("AGORA SIM VOCÊ DIGITOU UM VALOR  MENOR DO QUE 10");

Console.WriteLine("***********************************************");

Console.WriteLine("VALOR DIGITADO --> {0}",i);

Console.WriteLine("***********************************************");

            }

}

Digite o exemplo da listagem 3.12 e salve o mesmo em um arquivo chamado ex12cap3.cs, na pasta C:\ExCsharp\cap3. Compile e execute o exemplo da listagem 3.12. Digite o valor 25 e pressione ENTER. Observe que o programa solicita novamente que seja digitado um valor menor do que 10. Digite 50. Mesma coisa. Agora digite 8. Você obterá os resultados indicados na Figura 3.15.

Figura 3.15 Executando o programa ex12cap3.exe.

A instrução foreach

Esta instrução já é uma velha conhecida da turma do Visual Basic. A instrução foreach é utilizada para percorrer todos os elementos de uma determinada coleção. Também podemos utilizar esta instrução para percorrer todos os elementos de um array de elementos, uma vez que um array não deixa de ser uma coleção de elementos do mesmo tipo.

A seguir um exemplo onde utilizamos a instrução foreach para exibir os elementos de um array de strings.

Considere o exemplo da Listagem 3.13:

using System;

class ex13cap3

{

            // Exemplo  13 - Capítulo 3.

            //  Instrução foreach.

            // Por:  Júlio Battisti

            // MCP,  MCP+I, MCSE, MCSE+I, MCSE, MCDBA

            public  static void Main()

            {

                        //  Declaração e preenchimento do array.

                        string[]  nomes =  {"josé","maria","pedro","antônio","carlo"};

                        //  Utilizo foreach para percorrer todos os elementos do array

                        foreach  (string nome in nomes)

                          Console.WriteLine("Nome:  {0}",nome);

            }

}

Digite o exemplo da listagem 3.13 e salve o mesmo em um arquivo chamado ex13cap3.cs, na pasta C:\ExCsharp\cap3. Compile e execute o exemplo da listagem 3.13. Você obterá os resultados indicados na Figura 3.16.

Figura 3.16 Executando o programa ex13cap3.exe.

Observe os seguintes comandos:

foreach (string nome in nomes)

          Console.WriteLine("Nome: {0}",nome);

O primeiro comando percorre os elementos do array nomes. O segundo comando exibe o valor de cada elemento.

Vamos a mais um exemplo de utilização de foreach para percorrer os elementos de uma coleção. Dentro do namespace System, temos a classe System.Environment. Dentro desta classe temos um método chamado GetLogicalDrives. Este método retorna um array de strings contendo o nome dos drives lógicos do computador. Depois utilizaremos foreach para percorrer os elementos do array de strings retornado por GetLogicalDrives.

Considere o exemplo da Listagem 3.14:

using System;

class ex14cap3

{

            // Exemplo  14 - Capítulo 3.

            //  Instrução foreach.

            // Método  Environment.GetLogicalDrives()

            // Por:  Júlio Battisti

            // MCP,  MCP+I, MCSE, MCSE+I, MCSE, MCDBA

            public  static void Main()

            {

                        //  Declaração e preenchimento do array.

                        string[]  drives = Environment.GetLogicalDrives();

                        //  Utilizo foreach para percorrer todos os elementos do array.

                        foreach  (string drive in drives)

                                    Console.WriteLine("Nome:  {0}",drive);

            }

}

Digite o exemplo da listagem 3.14 e salve o mesmo em um arquivo chamado ex14cap3.cs, na pasta C:\ExCsharp\cap3. Compile e execute o exemplo da listagem 3.14. Você obterá os resultados indicados na Figura 3.17.

Figura 3.17 Executando o programa ex14cap3.exe.

Nota= Os resultados obtidos podem ser diferentes dos exibidos na Figura 3.17, uma vez que o mesmo depende dos drives configurados no computador que você estiver utilizando.

De diferente neste exemplo, em relação ao anterior, apenas o fato de termos utilizado uma classe do .NET Framework Class Library – Environment.GetLogicalDrives( ), a qual retorna o nome (letra da unidade) de todos os drives lógicos do computador.

Instruções de salto (jump):

As instruções de salto transfarem, incondicionalmente, a execução do programa para fora de um laço ou para um ponto específico do programa. Por exemplo, podemos utilizar uma instrução break para sair de um laço while, mesmo que a condição do laço ainda não tenha se tornado falsa.

Temos as seguintes instruções de salto:

• break
• continue
• goto  (Nãããããão, goto não! Tem sim. Mas não se assuste.)
• return
• throw

A instrução break

Sintaxe:

break;

A instrução break é utilizada para sair de um laço switch, while, do/while, for ou foreach.  A execução passa para o primeiro comando após o final do laço onde o break foi executado. Se colocarmos o break fora de um dos laços citados, obteremos um erro de compilação.

A instrução continue

Dentro de um laço quando é encontrada uma instrução continue os demais comandos do laço são ignorados e o laço é executado novamente, dependendo do valor do teste. A diferença entre a instrução break e a instrução continue é que o break sai definitivamente do laço, passando a execução para o comando imediatamente após o laço; enquanto o continue apenas suspende os comandos restantes e continua a execução do laço, até que o mesmo seja encerrado.

SS= A instrução goto

A utilização da instrução goto é conhecida de longa data. Podemos utilizar a instrução goto para saltar diretamente para um rótulo definido no código do programa. Um rótulo é definido da seguinte maneira:

nome_do_rótulo:

Porém esta prática é altamente desaconselhada. Quem não lembra dos famosos programas “macarrão” da época do Basic. Um programa macarrão é o que utiliza muitas instruções goto, onde a execução fica pulando de uma parte para outra do programa. O C# desencoraja o uso do goto, aplicando algumas restrições para a utilização do mesmo. Por exemplo, não podemos utilizar goto para deslocar a execução para dentro de um bloco de comandos, como por exemplo um for ou while.

A instrução return

Esta instrução, normalmente, é utilizada dentro de uma função. A instrução return retorna o controle do programa para o comando seguinte ao que fez a chamada à função e pode também retornar um valor calculado pela função.

A instrução throw

Esta instrução é utilizada no tratamento de exceções e será vista no próximo capítulo.