Instruções (Guia de Programação em C#)

Ações que um programa recebe são expressos nas instruções. As ações comuns incluem declarar variáveis, atribuir valores, chamar métodos, dá-los um loop através de coleções, e prosseguir outro ou bloco de código, como uma condição determinada. A ordem em que as instruções são executadas em um programa é chamado no fluxo de controle ou fluxo de execução. O fluxo de controle pode variar sempre que um programa é executado, dependendo de como o programa estiver para encaixar que recebe em tempo de execução.

Uma declaração pode consistir de uma única linha de código que termina em um ponto-e-vírgula, ou em uma série de instruções de linha única em um bloco. Um bloco de declaração é incluído {} colchetes e pode conter blocos aninhados. O código a seguir mostra dois exemplos de declarações de linha única, e uma linha múltipla bloco de declaração:

    static void Main()
    {
        // Declaration statement. 
        int counter;

        // Assignment statement.
        counter = 1;

        // Error! This is an expression, not an expression statement. 
        // counter + 1;  

        // Declaration statements with initializers are functionally 
        // equivalent to  declaration statement followed by assignment statement:          
        int[] radii = { 15, 32, 108, 74, 9 }; // Declare and initialize an array. 
        const double pi = 3.14159; // Declare and initialize  constant.           

        // foreach statement block that contains multiple statements. 
        foreach (int radius in radii)
        {
            // Declaration statement with initializer. 
            double circumference = pi * (2 * radius);

            // Expression statement (method invocation). A single-line 
            // statement can span multiple text lines because line breaks 
            // are treated as white space, which is ignored by the compiler.
            System.Console.WriteLine("Radius of circle #{0} is {1}. Circumference = {2:N2}",
                                    counter, radius, circumference);

            // Expression statement (postfix increment).
            counter++;

        } // End of foreach statement block
    } // End of Main method body.
} // End of SimpleStatements class. 
/*
   Output:
    Radius of circle #1 = 15. Circumference = 94.25
    Radius of circle #2 = 32. Circumference = 201.06
    Radius of circle #3 = 108. Circumference = 678.58
    Radius of circle #4 = 74. Circumference = 464.96
    Radius of circle #5 = 9. Circumference = 56.55
*/

tipos de instruções

A tabela a seguir lista os diversos tipos de instruções em C# e em seus palavra-chave associados, com links para tópicos que incluem mais informações:

Categoria	Palavra-chave/notas C#
Instruções de declaração	Uma instrução de declaração introduz uma nova variável ou constante. Uma declaração de variável pode opcionalmente atribuir um valor à variável. Em uma declaração de constante, a atribuição é necessária. // Variable declaration statements.  double area; double radius = 2; // Constant declaration statement.  const double pi = 3.14159;
Instruções de expressão	As instruções de expressões calculam que um valor devem armazenar o valor em uma variável. // Expression statement (assignment). area = 3.14 * (radius * radius); // Error. Not statement because no assignment:  //circ * 2;  // Expression statement (method invocation). System.Console.WriteLine(); // Expression statement (new object creation). System.Collections.Generic.List<string> strings = new System.Collections.Generic.List<string>();
instruções de seleção	As instruções de seleção permite que você ramificar para seções de código diferente, dependendo de uma ou mais condições especificadas. Para obter mais informações, consulte os seguintes tópicos: se, mais, alterne, maiúscminúsc
Instruções de iteração	As instruções de iteração permite que você percorrer as coleções como matrizes, ou as executa no mesmo conjunto de instruções repetidamente até que uma condiçao específica seja satisfeita. Para obter mais informações, consulte os seguintes tópicos: faça, para, foreach, em, quando
Instruções de ignorar relatórios	Ignorar o controle de transferência de instruções para outra seção de código. Para obter mais informações, consulte os seguintes tópicos: interrupção, continue, opção, goto, retorno, produzir
Instruções de manipulação de exceção	As instruções de manipulação de exceção permite que você recupere graciosamente das circunstâncias excepcionais que ocorrem em tempo de execução. Para obter mais informações, consulte os seguintes tópicos: throw, try-catch, tente - final, try-catch - final
Verificadas e desmarcado	As instruções verificadas e desmarcadas permite que você especifique se as operações numéricas são permitidas causar um estouro quando o resultado é armazenado em uma variável que é muito pequeno armazenar o valor resultante. Para obter mais informações, consulte marcado e desmarcado.
A declaração de await	Se você marcar um método com o modificador de async , você pode usar o operador de espere no método. Quando o controle atingir uma expressão de await no método de async, o controle retorna para o chamador, e o estado o método é suspenso até que a tarefa deve terminar. Quando a tarefa estiver concluída, a execução pode continuar no método. Para um exemplo simples, consulte a seção de métodos Async” de Métodos (Guia de Programação em C#). Para obter mais informações, consulte Programação assíncrona com Async e Await (C# e Visual Basic).
A declaração de yield return	Um iterador executa uma iteração personalizado em uma coleção, como uma lista ou uma matriz. Um iterador usa a declaração de retorno de produzir para retornar um de cada vez a cada elemento. Quando uma declaração de yield return é alcançada, o local atual no código está recordado. A execução é reiniciada de aquele local quando o iterador é chamado na próxima vez. Para obter mais informações, consulte Iteradores (C# e Visual Basic).
A declaração de fixed	A instrução fixa impede que o coletor de lixo relocating uma variável móvel. Para obter mais informações, consulte fixo.
A declaração de lock	A declaração de bloqueio permite que você limitar acesso aos blocos de código para apenas um segmento de cada vez. Para obter mais informações, consulte bloqueio.
Instruções rotuladas	Você pode dar a uma instrução um rótulo e então usar a palavra-chave de goto para ignorar a instrução chamada. (Consulte o exemplo na linha seguinte.)
a instrução vazio	A instrução vazio consiste em um único ponto. Não fará nada e pode ser usada nos locais onde uma instrução é necessária nenhuma ação mas precisa ser executada. Os seguintes usos de apresentação dois exemplos para uma instrução vazia: void ProcessMessages() { while (ProcessMessage()) ; // Statement needed here. } void F() { //...  if (done) goto exit; //... exit: ; // Statement needed here. }

Instruções inseridos

Algumas declarações, incluindo faça, quando, para, e foreach, sempre têm uma instrução inserido que o segue. Essa instrução inserido pode ser uma única instrução ou mais declarações cercadas {} por colchetes em um bloco de declaração. Mesmo instruções de linha única inseridos podem ser incluídos {} colchetes, conforme mostrado no exemplo o seguir:

// Recommended style. Embedded statement in  block. 
foreach (string s in System.IO.Directory.GetDirectories(
                        System.Environment.CurrentDirectory))
{
    System.Console.WriteLine(s);
}

// Not recommended. 
foreach (string s in System.IO.Directory.GetDirectories(
                        System.Environment.CurrentDirectory))
    System.Console.WriteLine(s);

Uma instrução inserido que não é incluída {} colchetes não pode ser uma instrução de declaração ou instrução chamada. Isso é mostrado no exemplo a seguir:

if(pointB == true)
    //Error CS1023: 
    int radius = 5; 

Coloque a instrução em um bloco inserido para corrigir o erro:

if (b == true)
{
    // OK:
    System.DateTime d = System.DateTime.Now;
    System.Console.WriteLine(d.ToLongDateString());
}

Blocos aninhados de instrução

Blocos de declaração podem ser aninhados, conforme mostrado no código o seguir:

foreach (string s in System.IO.Directory.GetDirectories(
    System.Environment.CurrentDirectory))
{
    if (s.StartsWith("CSharp"))
    {
        if (s.EndsWith("TempFolder"))
        {
            return s;
        }
    }

}
return "Not found.";

instruções inacessíveis

Se o compilador determina que o fluxo de controle nunca pode alcançar uma instrução específico em qualquer condição, gerará CS0162 de aviso, conforme mostrado no exemplo o seguir:

// An over-simplified example of unreachable code. 
const int val = 5;
if (val < 4)
{
    System.Console.WriteLine("I'll never write anything."); //CS0162
}

Seções relacionadas

• Palavras-chave de instrução (Referência de C#)

• Expressões (Guia de Programação em C#)

• Operadores (Guia de Programação em C#)

Especificação da linguagem C#

Para obter mais informações, consulte a Especificação da linguagem C#. A especificação da linguagem é a fonte definitiva para a sintaxe e o uso de C#.

Consulte também

Conceitos

Guia de Programação em C#