Compartilhar via

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

As ações executadas por um programa são expressas em instruções. As ações comuns incluem declarar variáveis, atribuir valores, chamar métodos, fazer loop por meio de 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 sempre 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 um 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 #{counter} is {radius}. Circumference = {circumference:N2}");

            // 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/anotações em C#
Declarações Uma instrução de declaração apresenta uma nova variável ou constante. Uma declaração de variável pode, opcionalmente, atribuir um valor à variável. Uma declaração constante, a atribuição é obrigatória.
Declarações de expressão As instruções de expressão que calculam um valor devem armazenar o valor em uma variável.
Instruções de seleção As instruções de seleção permitem ramificar-se em 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ê faça loop por meio de 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 atalho Instruções de salto transferem o controle para outra seção do código. Para obter mais informações, consulte os seguintes tópicos:
Instruções para manipulação de exceções Instruções para tratamento de exceções permitem que você se recupere normalmente de condições excepcionais que ocorrem em tempo de execução. Para obter mais informações, consulte os seguintes tópicos:
checked e unchecked As instruções checked e unchecked permitem especificar se as operações numéricas de tipo integral podem causar um estouro quando o resultado é armazenado em uma variável muito pequena para conter o valor resultante.
A instrução await Se você marcar um método com o modificador assíncrono , 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 for 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 async e await.
A instrução yield return Um iterador realiza uma iteração personalizada em uma coleção, como uma lista ou uma matriz. Um iterador usa a instrução de retorno de rendimento para retornar cada elemento um de cada vez. Quando uma instrução yield return for atingida, o local atual no código será lembrado. A execução é reiniciada desse local quando o iterador é chamado na próxima vez.

Para obter mais informações, consulte Iteradores.
A instrução fixed A instrução fixa impede que o coletor de lixo realoque uma variável móvel. Para obter mais informações, consulte fixed.
A instrução lock A instrução de bloqueio permite limitar o acesso a blocos de código a apenas um thread de cada vez. Para obter mais informações, consulte lock.
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. (Consulte o exemplo na linha a seguir.)
A instrução vazia A instrução vazia consiste em um único ponto e vírgula. Ele não faz nada e pode ser usado em situações onde uma declaração é necessária, mas nenhuma ação precisa ser executada.

Instruções de declaração

O código a seguir mostra exemplos de declarações 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;

Instruções 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);

// Expression statement (result discarded).
int x = 0;
x++;

// 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 instrução vazia

Os exemplos a seguir mostram dois usos para uma declaração vazia:

void ProcessMessages()
{
    while (ProcessMessage())
        ; // Statement needed here.
}

void F()
{
    //...
    if (done) goto exit;
//...
exit:
    ; // Statement needed here.
}

Declarações incorporadas

Algumas instruções, por exemplo, instruções de iteração, sempre têm uma instrução inserida que as segue. Essa declaração inserida pode ser uma única declaração ou várias declarações delimitadas por colchetes angulares {} em um bloco de declaração. Até mesmo instruções inseridas de uma única linha podem ser colocadas entre colchetes {}, conforme mostrado no seguinte exemplo:

// 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 declaração inserida que não está entre colchetes {} não pode ser uma declaração ou uma declaração rotulada. Isso é mostrado no exemplo a seguir:

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

Coloque a instrução inserida 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.";

Declarações inalcançáveis

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

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