Instruções (guia de programação de C#)

As ações que leva a um programa são expressos em instruções. Ações comuns incluem a declaração de variáveis, atribuindo valores, chamar métodos, o loop pelas coleções e a ramificação de um ou outro de bloco de código, dependendo de uma determinada condição. A ordem na qual as instruções são executadas em um programa é chamada de fluxo de controle ou fluxo de execução. O fluxo de controle pode variar sempre que um programa é executado, dependendo de como o programa reage à entrada que ele recebe em tempo de execução.

Uma instrução pode consistir em uma simples linha de código que termina com um ponto-e-vírgula, ou uma série de linhas de instruções em um Bloco. Um bloco de instrução está entre chaves {} e pode conter blocos aninhados. O código a seguir mostra dois exemplos de instruções simples e um bloco de instruções  em várias linhas:

    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 suas palavras-chave associadas, com links para tópicos que contêm mais informações:

<strong>Categoria</strong>	Palavras-chave C# / Observações
Instruções de declaração	Uma instrução de declaração apresenta uma nova variável ou constante. Uma declaração de variável opcionalmente pode 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	Instruções de expressão para calculam um valor necessário 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	Instruções de seleção permitem que você efetuar a ramificação diferentes seções de código, dependendo de uma ou mais condições especificadas. Para obter mais informações, consulte os seguintes tópicos: if, else, switch, case
Instruções de iteração	Instruções de iteração permitem percorrer coleções como arrays ou executam o mesmo conjunto de instruções repetidamente até que uma condição especificada for satisfeita. Para obter mais informações, consulte os seguintes tópicos: do, for, foreach, in, while
Instruções de salto.	Pular o controle de transferência de declarações para outra seção do código. Para obter mais informações, consulte os seguintes tópicos: break, continue, default, goto, return, yield
Instruções de tratamento de exceção	Instruções de tratamento de exceção permitem recuperar-se normalmente de condições excepcionais que ocorrem em tempo de execução. Para obter mais informações, consulte os seguintes tópicos: Lançar, try-catch, try-finally, try-catch-finally
Marcados e desmarcados	Marcada e desmarcadas instruções permitem especificar se as operações numéricas são permitidas para causar um estouro quando o resultado é armazenado em uma variável que é muito pequena para conter o valor resultante. Para obter mais informações, consulte check- e não verificado.
O fixed instrução	A instrução fixed impede que o coletor de lixo realocando a uma variável móvel. Para obter mais informações, consulte fixa.
O lock instrução	A instrução lock permite limitar o acesso a blocos de código para apenas um thread por vez. Para obter mais informações, consulte lock.
Instruções rotuladas	Você pode fornecer um rótulo de uma instrução e, em seguida, use o goto palavra-chave para saltar para a instrução rotulada. (Consulte o exemplo na linha seguinte).
A instrução vazia	A instrução vazia consiste em um ponto e vírgula único. Ele não faz nada e pode ser usado em locais onde uma instrução é necessária, mas nenhuma ação precisa ser executada. Os exemplos a seguir mostram dois usos para uma instrução vazia: void ProcessMessages() { while (ProcessMessage()) ; // Statement needed here. } void F() { //... if (done) goto exit; //... exit: ; // Statement needed here. }

Instruções incorporadas

Algumas instruções, incluindo 370s1zax(v=vs.100).md, enquanto, para, e foreach, tenha sempre uma instrução incorporada que segue. Esta instrução incorporada pode ser uma única instrução ou várias instruções entre colchetes de {} em um bloco de instrução. Instruções de linha única, mesmo incorporadas podem ser delimitada por colchetes {}, conforme mostrado no exemplo a 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 incorporada, não está entre colchetes {} não pode ser uma instrução de declaração ou uma instrução rotulada. Isso é mostrado no exemplo a seguir:

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

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

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

Blocos de instrução aninhados

Blocos de instrução podem ser aninhados, conforme mostrado no código a 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 um determinado demonstrativo sob qualquer circunstância, ele produzirá aviso CS0162, conforme mostrado no exemplo a 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 de C#)

• Operadores (guia de programação de C#)

Especificação da linguagem C#

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

Consulte também

Conceitos

C# Programming Guide