Curso de C#: Liçao 3: Controle de declarações - Seleção

A informação nesta lição irá ajudá-lo a sucursal em separado, lógico seqüências baseadas em decisões que fizer. Mais especificamente, os objectivos desta aula são as seguintes: Aprenda declarações.Aprender o switch.Saiba como break é utilizado em declarações switch.

Por | @oficinadanet Programação
Nas últimas duas lições, a cada programa que você viu continha uma quantidade limitada de etapas sequenciais e depois parou. Não houve decisões que você pode fazer com a entrada e a única restrição era para seguir em frente até ao fim. A informação nesta lição irá ajudá-lo a sucursal em separado, lógico seqüências baseadas em decisões que fizer. Mais especificamente, os objectivos desta aula são as seguintes:

* Aprenda declarações.
* Aprender o switch.
* Saiba como break é utilizado em declarações switch.
* Compreender a utilização adequada da declaração goto.


A declaração IF


Uma declaração que lhe permite tomar caminhos diferentes de lógica, dependendo de uma determinada condição. Quando a condição avalia a um boolean true, um bloco de código para que a verdadeira condição irá executar. Você tem a opção de um único caso declaração, várias declarações se outra pessoa, e uma outra declaração opcional. Listagem 3-1 mostra como cada um destes tipos de declarações se trabalhar.

Listagem 3-1. Formas da declaração IF: IfSelection.cs

    using System;

    class IfSelect
    {
        public static void Main()
        {
            string myInput;
            int myInt;

            Console.Write("Please enter a number: ");
            myInput = Console.ReadLine();
            myInt = Int32.Parse(myInput);

            // Single Decision and Action with brackets
            if (myInt > 0)
            {
                Console.WriteLine("Your number {0} is greater than zero.", myInt);
            }

            // Single Decision and Action without brackets
            if (myInt < 0)
                Console.WriteLine("Your number {0} is less than zero.", myInt);

            // Either/Or Decision
            if (myInt != 0)
            {
                Console.WriteLine("Your number {0} is not equal to zero.", myInt);
            }
            else
           {
                Console.WriteLine("Your number {0} is equal to zero.", myInt);
            }

            // Multiple Case Decision
            if (myInt < 0 || myInt == 0)
            {
                Console.WriteLine("Your number {0} is less than or equal to zero.", myInt);
            }
            else if (myInt > 0 && myInt <= 10)
            {
                Console.WriteLine("Your number {0} is in the range from 1 to 10.", myInt);
            }
            else if (myInt > 10 && myInt <= 20)
            {
                Console.WriteLine("Your number {0} is in the range from 11 to 20.", myInt);
            }
            else if (myInt > 20 && myInt <= 30)
            {
                Console.WriteLine("Your number {0} is in the range from 21 to 30.", myInt);
            }
            else
           {
                Console.WriteLine("Your number {0} is greater than 30.", myInt);
            }
        }
    }


As declarações na listagem 3-1 usar a mesma entrada variável, myInt como uma parte das suas avaliações. Essa é outra maneira de obter interativo de entrada do usuário. Aqui está o código pertinente:

        Console.Write("Please enter a number: ");
        myInput = Console.ReadLine();
        myInt = Int32.Parse(myInput);


Primeiro, imprima a linha "Digite um número:" para o console. A declaração Console.ReadLine () faz com que o programa de esperar pela entrada do usuário, que digita um número e, em seguida, pressiona Enter. Esse número é retornado na forma de uma string no myInput variável, que é um tipo string. Uma vez que temos de avaliar a entrada do usuário na forma de um int, myInput deve ser convertido. Isto é feito com o comando Int32.Parse (myInput). (Int32 e tipos similares serão cobertos em outra lição sobre avançados tipos) O resultado é colocado na myInt variável, que é um tipo int.

Agora que temos uma variável do tipo que queríamos, vamos avaliar se isso com declarações. A primeira afirmação é do formulário if (boolean expression) (declarações), como mostrado a seguir:

         // Single Decision and Action with brackets
        if (myInt > 0)
        {
            Console.WriteLine("Your number {0} is greater than zero.", myInt);
        }


Você deve começar com a palavra-chave se. Em seguida é a expressão booleana entre parênteses. Esta expressão booleana deve avaliar a um valor verdadeiro ou falso. Neste caso, estamos verificando a entrada do usuário para ver se ele é maior que (>) 0. Se esta expressão avalia para true, que executam as declarações dentro do curly correias. (Referimo-nos à estrutura com curly correias como um "bloco") Pode haver uma ou mais declarações dentro deste bloco. Se a expressão booleana avalia a falsa, que ignore as declarações dentro do bloco e continuar com o próximo programa execução declaração após o bloqueio.

Nota: Em outras linguagens, como C, C + +, podem ser avaliadas as condições em que um resultado de 0 é falso e qualquer outro número é verdadeiro. Em C #, a condição deve avaliar a um valor booleano de qualquer verdadeiro ou falso. Se você precisa para simular uma condição numérico com C #, você pode fazê-lo por escrito-o como (myInt! = 0), o que significa que a expressão avaliar para true se myInt não é 0.

A segunda afirmação é bem como se o primeiro, salvo se não tiver um bloco, como mostrado aqui:

        // Single Decision and Action without brackets
        if (myInt < 0)
            Console.WriteLine("Your number {0} is less than zero.", myInt);


Se a sua expressão booleana avalia a verdade, a primeira declaração após a expressão booleana será executado. Quando a expressão booleana avalia a falsa, a primeira declaração após a expressão booleana serão ignorados eo próximo programa declaração será executada. Esta forma de declaração, se é adequada quando você só tem uma única declaração para executar. Se você quiser executar dois ou mais declarações, quando a expressão booleana avalia para true, você deve anexar-los em um bloco.

A minha recomendação pessoal é torná-lo um hábito de sempre colocar suas declarações, se dentro de um bloco, independentemente de serem ou não tiver apenas uma declaração para executar. Isso ajudará a evitar erros caso você decidir mais tarde para adicionar uma declaração e se esqueça de adicionar o curly correias.

Na maior parte do tempo, você vai querer fazer um tanto ou tipo de decisão. Isto é chamado de um caso / outra declaração. O terceiro caso em declaração Listing 3-1 apresenta esta ideia, como mostrado a seguir:
         // Either/Or Decision
        if (myInt != 0)
        {
            Console.WriteLine("Your number {0} is not equal to zero.", myInt);
        }
        else
        {
            Console.WriteLine("Your number {0} is equal to zero.", myInt);
        }


Quando a expressão booleana avalia a verdade, a declaração (ões) no bloco imediatamente após a declaração, se forem executados. No entanto, quando a expressão booleana avalia a falsa, as declarações no bloco seguinte a outra palavra-chave estão sendo executados.

Quando você tiver várias expressões para avaliar, você pode usar o caso / resto se / outra forma de se a declaração. Mostramos este formulário na quarta se declaração de Listing 3-1, e repetida abaixo:

         // Multiple Case Decision
        if (myInt < 0 || myInt == 0)
        {
            Console.WriteLine("Your number {0} is less than or equal to zero.", myInt);
        }
        else if (myInt > 0 && myInt <= 10)
        {
            Console.WriteLine("Your number {0} is in the range from 1 to 10.", myInt);
        }
        else if (myInt > 10 && myInt <= 20)
        {
            Console.WriteLine("Your number {0} is in the range from 11 to 20.", myInt);
        }
        else if (myInt > 20 && myInt <= 30)
        {
            Console.WriteLine("Your number {0} is in the range from 21 to 30.", myInt);
        }
        else
        {
            Console.WriteLine("Your number {0} is greater than 30.", myInt);
        }


Este exemplo começa com a palavra-chave se, novamente executando o seguinte bloco se a expressão booleana avalia para true. Contudo, este período pode avaliar várias condições, com a subsequente se outra palavra-chave combinação. A outra declaração também se toma uma expressão booleana, assim como a declaração se. As regras são as mesmas, quando a expressão booleana para a outra declaração se avalia para true, o bloco imediatamente após a expressão booleana é executado. Quando nenhum dos outros ou se outra pessoa se boolean expressões avaliar a verdade, o bloco seguinte a outra palavra-chave será executado. Apenas uma seção de um caso / resto se / outra declaração será executada.

Uma diferença na última declaração dos demais é o boolean expressões. A expressão booleana, (myInt <0 | | myInt == 0), contém o condicional OR (| |) operador. Em ambos os regular OR (|) e o operador condicional OR (| |) operador, a boolean expressão irá avaliar para true se nenhuma das duas sub-expressões de ambos os lados do operador avaliar para true. A principal diferença entre as duas formas são OU regular que o operador vai avaliar os dois sub-expressões de cada vez. No entanto, a condicional OU irá avaliar a segunda sub-expressão apenas se a primeira sub-expressão avalia para false.

A expressão booleana, (myInt> 0 & & myInt <= 10), contém o condicional E operador. Tanto a regular E (&) e do operador condicional E (&) operador irá retornar true quando ambos da sub-expressões de ambos os lados do operador avaliar para true. A diferença entre os dois é que o operador regular E vai avaliar tanto expressões de cada vez. No entanto, o operador condicional E vai avaliar a segunda sub-expressão apenas quando a primeira sub-expressão avalia para true.

Os operadores condicionais (& & e | |), são comumente chamados curto-circuito operadores porque nem sempre avaliar a expressão inteira. Assim, elas também são usadas para produzir código mais eficiente, ignorando desnecessários lógica.

Declaração SWITCH


Outra forma de seleção é a declaração switch, que executa um conjunto de lógica, dependendo do valor de um determinado parâmetro. Os tipos dos valores instrução switch opera sobre pode ser booleans, enums, integrante tipos, e cordas. Aula 2: Operadores, Tipos, Variáveis e discutido o tipo bool, inteiro tipos. Listagem 3-2 mostra como usar o switch com ambos os tipos int e string.

Listagem 3-2. Declaração SWITCH: SwitchSelection.cs

    using System;

    class SwitchSelect
    {
        public static void Main()
        {
            string myInput;
            int myInt;

            begin:

            Console.Write("Please enter a number between 1 and 3: ");
            myInput = Console.ReadLine();
            myInt = Int32.Parse(myInput);

            // switch with integer type
            switch (myInt)
            {
                case 1:
                    Console.WriteLine("Your number is {0}.", myInt);
                    break;
                case 2:
                    Console.WriteLine("Your number is {0}.", myInt);
                    break;
                case 3:
                    Console.WriteLine("Your number is {0}.", myInt);
                    break;
                default:
                    Console.WriteLine("Your number {0} is not between 1 and 3.", myInt);
                    break;
            }

            decide:

            Console.Write("Type "continue" to go on or "quit" to stop: ");
            myInput = Console.ReadLine();

            // switch with string type
            switch (myInput)
            {
                case "continue":
                    goto begin;
                case "quit":
                    Console.WriteLine("Bye.");
                    break;
                default:
                    Console.WriteLine("Your input {0} is incorrect.", myInput);
                    goto decide;
            }
        }
    }


Listagem 3-2 mostra um switch de declarações. O switch começa a mudar com a palavra-chave seguido pelo interruptor expressão. No primeiro switch na listagem 3-2, o switch avalia expressão de um tipo int, como segue:
        
        // switch with integer type
        switch (myInt)
        {
            case 1:
                Console.WriteLine("Your number is {0}.", myInt);
                break;
            case 2:
                Console.WriteLine("Your number is {0}.", myInt);
                break;
            case 3:
                Console.WriteLine("Your number is {0}.", myInt);
                break;
            default:
                Console.WriteLine("Your number {0} is not between 1 and 3.", myInt);
                break;
        }


O interruptor bloco segue o interruptor expressão, em que um ou mais escolhas são avaliados para uma possível combinar com o interruptor expressão. Cada escolha é marcado com o caso palavras-chave, seguidas por um exemplo que é do mesmo tipo que o switch expressão e seguido por dois pontos (:). No exemplo que temos caso 1:, caso 2:, e caso 3:. Quando o resultado avaliados no switch expressão coincide com uma dessas escolhas, as declarações imediatamente após a correspondência escolha são executadas, até e incluindo uma ramificação declaração, que poderá ser tanto uma pausa, continue, goto, o retorno, ou atirar declaração.

Você também pode incluir uma escolha após todas as outras opções. Se nenhuma das outras escolhas correspondem, em seguida, escolha o padrão é tirada e suas declarações são executadas. Embora utilização do rótulo default é opcional, eu altamente recomendável que você sempre incluí-la. Isso ajudará a recuperar circunstâncias imprevistas e tornar os seus programas mais confiáveis.

Cada caso rótulo deve terminar com uma ramificação declaração, conforme descrito na tabela 3-1, que é normalmente a declaração break. A declaração break fará com que o programa para sair do switch e começar a execução com a seguinte declaração após o switch bloco. Há duas excepções a esta: adjacente caso declarações sem código de entre ou usando uma declaração goto. Aqui está um exemplo que mostra como combinar caso declarações:

        switch (myInt)
        {
            case 1:
            case 2:
            case 3:
                Console.WriteLine("Your number is {0}.", myInt);
                break;
            default:
                Console.WriteLine("Your number {0} is not between 1 and 3.", myInt);
                break;
        }

Ao colocar caso declarações em conjunto, sem no código-entre, você cria um único caso de múltiplos valores. A case without any code will automatically fall through to the next case. Um caso sem qualquer código será automaticamente através de queda para o próximo caso. The example above shows how the three cases for myInt equal to 1, 2, or 3, where case 1 and case 2 will fall through and execute code for case 3. O exemplo acima mostra como os três casos para myInt igual a 1, 2 ou 3, em que caso 1 e caso 2 cairá através de e execute código de caso 3.

Um caso declaração só pode ser uma correspondência exata e você não pode usar lógico condições. If you need to use logical conditions, you can use an if/else if/else statement. Se você precisa usar lógico condições, você pode usar um caso / resto se / outra declaração.

Outra maneira de controlar o fluxo de ar em forma lógica para controlar o fluxo da lógica de um switch é utilizando o goto declaração. You can either jump to another case statement, or jump out of the switch statement. Você pode pular para outro caso declaração, ou saltar fora do switch. The second switch statement in Listing 3-2 shows the use of the goto statement, as shown below: A segunda switch na listagem 3-2 mostra o uso da declaração goto, como mostrado a seguir:

         // switch with string type
        switch (myInput)
        {
            case "continue":
                goto begin;
            case "quit":
                Console.WriteLine("Bye.");
                break;
            default:
                Console.WriteLine("Your input {0} is incorrect.", myInput);
                goto decide;
        }


Nota: no actual exemplo, "continuar", é um caso de switch - e não a palavra-chave.

A declaração goto causas programa execução de ir para o marcador após o goto palavra-chave. During execution, if the user types in "continue", the switch statement matches this input (a string type) with the case "continue": label and executes the "goto begin:" instruction. Durante a execução, se o usuário digita em "continuar", o switch correspondências esta entrada (uma string tipo), com o caso "continuar": label e executa o "goto começar:" instrução. O programa irá, em seguida, deixar o switch e começar a executar o primeiro programa começará a seguinte declaração: rótulo. Este é efetivamente um laço, permitindo que você execute o mesmo código várias vezes.O ciclo vai terminar quando o usuário digita o texto "sair". Esta será avaliada com o caso "sair": escolha, que irá imprimir "Bye". Para o console, break fora do switch e no final do programa.

Quando nem o "continuar", nem "sair" strings são inscritos, o "padrão:" caso será digitado. Ele irá imprimir uma mensagem de erro para o console e, em seguida, execute o goto decidir: comando. Isso fará com que o programa execução para pular para a primeira declaração após a decidir: rótulo, que irá perguntar ao usuário se querem continuar ou desistir.

Claramente, o goto declaração é poderoso e pode, sob condições controladas, ser útil. Devo, no entanto, prudência você fortemente sobre a sua utilização.O goto declaração tem um grande potencial para uso indevido. Você poderia criar um programa muito difícil para depurar e manter. Imagine o esparguete código que poderia ser criado por acaso goto declarações ao longo de um programa. Na aula seguinte, eu vou mostrar-lhe a melhor forma de criar loops em seu programa.

Resumo


Se a declaração pode ser escrito em várias maneiras de implementar diferentes ramos da lógica. O switch permite uma escolha entre um conjunto de bool, enum, integral, ou tipos string.

Você usa break, continue, goto, o retorno, ou atirar declarações ao sair de uma declaração caso.Certifique-se de evitar o goto declaração em seu código, a menos que você tenha um excelente motivo para utilizá-lo.

Além de ramificação baseia-se numa condição, é útil para ser capaz de executar um bloco de declarações várias vezes.

Tutorial traduzido automaticamente de: http://www.csharp-station.com/Tutorials/Lesson03.aspx

Mais sobre: curso c sharp, if, case
Share Tweet
DESTAQUESRecomendadoMais compartilhados
Comentários
Continue lendo