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

  • Artigo

As ações que um programa realiza são expressas em declarações. As ações comuns incluem declarar variáveis, atribuir valores, chamar métodos, percorrer coleções e ramificar para um ou outro 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 toda vez que um programa é executado, dependendo de como o programa reage à entrada que recebe em tempo de execução.

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

    public 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 declarações

A tabela a seguir lista os vários tipos de instruções em C# e suas palavras-chave associadas, com links para tópicos que incluem mais informações:

Categoria Palavras-chave / notas em C#
Declaraçõ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 constante, a atribuição é necessária.
Enunciados de expressão As instruções de expressão que calculam um valor devem armazenar o valor em uma variável.
Declarações de seleção As instruções de seleção permitem ramificar para diferentes seções de código, dependendo de uma ou mais condições especificadas. Para obter mais informações, consulte os seguintes tópicos:
Instruções de iteração As instruções de iteração permitem que você percorra coleções como matrizes ou execute o mesmo conjunto de instruções repetidamente até que uma condição especificada seja atendida. Para obter mais informações, consulte os seguintes tópicos:
Instruções de salto As instruções Jump transferem o controle para outra seção do código. Para obter mais informações, consulte os seguintes tópicos:
Declarações de tratamento de exceções As instruções de tratamento de exceções permitem que você se recupere normalmente de condições excecionais que ocorrem em tempo de execução. Para obter mais informações, consulte os seguintes tópicos:
checked e unchecked As checked instruções and unchecked permitem especificar se operações numéricas de tipo integral podem causar um estouro quando o resultado é armazenado em uma variável que é muito pequena para manter o valor resultante.
A await declaração Se você marcar um método com o modificador async , poderá usar o operador await no método. Quando o controle atinge uma await expressão no método assíncrono, o controle retorna ao chamador e o progresso no método é suspenso até que a tarefa aguardada seja concluída. Quando a tarefa estiver concluída, a execução poderá ser retomada no método.

Para obter um exemplo simples, consulte a seção "Métodos assíncronos" de Métodos. Para obter mais informações, consulte Programação assíncrona com assíncrono e aguarde.
A yield return declaração Um iterador executa uma iteração personalizada sobre uma coleção, como uma lista ou uma matriz. Um iterador usa a instrução yield return para retornar cada elemento, um de cada vez. Quando uma yield return instrução é alcançada, o local atual no código é lembrado. A execução é reiniciada a partir desse local quando o iterador é chamado na próxima vez.

Para obter mais informações, consulte Iteradores.
A fixed declaração A declaração fixa impede que o coletor de lixo realoque uma variável móvel. Para obter mais informações, consulte fixo.
A lock declaração A instrução lock permite limitar o acesso a blocos de código a apenas um thread de cada vez. Para obter mais informações, consulte bloquear.
Declarações rotuladas Você pode dar um rótulo a uma instrução e, em seguida, usar a palavra-chave goto para ir para a instrução rotulada. (Veja o exemplo na linha a seguir.)
A declaração vazia A instrução vazia consiste em um único ponto-e-vírgula. Ele não faz nada e pode ser usado em locais onde uma declaração é necessária, mas nenhuma ação precisa ser executada.

Declarações de declaração

O código a seguir mostra exemplos de declarações de variáveis com e sem uma atribuição inicial e uma declaração constante com a inicialização necessária.

// Variable declaration statements.
double area;
double radius = 2;

// Constant declaration statement.
const double pi = 3.14159;

Enunciados de expressão

O código a seguir mostra exemplos de instruções de expressão, incluindo atribuição, criação de objeto com atribuição e invocação de método.

// 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>();

A declaração vazia

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, por exemplo, instruções de iteração, sempre têm uma instrução incorporada que as segue. Esta instrução incorporada pode ser uma única instrução ou várias instruções entre {} parênteses em um bloco de instrução. Mesmo instruções incorporadas de linha única podem ser colocadas entre {} parênteses, 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 que não está entre {} parênteses não pode ser uma 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

Os 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.";

Declarações inacessíveis

Se o compilador determinar que o fluxo de controle nunca pode alcançar uma instrução específica em nenhuma circunstância, ele produzirá aviso CS0162, como 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
}

Especificação da linguagem C#

Para obter mais informações, consulte a seção Instruções da especificação da linguagem C#.

Consulte também