13 Declarações

13.1 Generalidades

C# fornece uma variedade de instruções.

Nota: A maioria dessas instruções será familiar para desenvolvedores que programaram em C e C++. Nota final

statement
    : labeled_statement
    | declaration_statement
    | embedded_statement
    ;

embedded_statement
    : block
    | empty_statement
    | expression_statement
    | selection_statement
    | iteration_statement
    | jump_statement
    | try_statement
    | checked_statement
    | unchecked_statement
    | lock_statement
    | using_statement
    | yield_statement
    | unsafe_statement   // unsafe code support
    | fixed_statement    // unsafe code support
    ;

unsafe_statement (§23.2) e fixed_statement (§23.7) só estão disponíveis em código não seguro (§23).

O embedded_statement nonterminal é usado para instruções que aparecem dentro de outras instruções. O uso de embedded_statement em vez de declaração exclui o uso de declarações e declarações rotuladas nesses contextos.

Exemplo: O código

void F(bool b)
{
   if (b)
      int i = 44;
}

resulta em um erro em tempo de compilação porque uma if instrução requer um embedded_statement em vez de uma instrução para sua if ramificação. Se esse código fosse permitido, a variável i seria declarada, mas nunca poderia ser usada. Note, no entanto, que ao colocar ia declaração de 's em um bloco, o exemplo é válido.

Exemplo final

13.2 Pontos finais e acessibilidade

Cada declaração tem um ponto final. Em termos intuitivos, o ponto final de uma declaração é o local que imediatamente se segue à declaração. As regras de execução para instruções compostas (instruções que contêm instruções incorporadas) especificam a ação que é executada quando o controle atinge o ponto final de uma instrução incorporada.

Exemplo: Quando o controle atinge o ponto final de uma instrução em um bloco, o controle é transferido para a próxima instrução no bloco. Exemplo final

Se uma declaração puder ser alcançada por execução, diz-se que a declaração é alcançável. Por outro lado, se não houver possibilidade de que uma declaração seja executada, a declaração é considerada inalcançável.

Exemplo: No código a seguir

void F()
{
    Console.WriteLine("reachable");
    goto Label;
    Console.WriteLine("unreachable");
  Label:
    Console.WriteLine("reachable");
}

a segunda invocação de Console.WriteLine é inacessível porque não há possibilidade de que a instrução seja executada.

Exemplo final

Um aviso é relatado se uma instrução diferente de throw_statement, bloquear ou empty_statement estiver inacessível. Especificamente, não é um erro que uma declaração seja inalcançável.

Nota: Para determinar se uma determinada instrução ou ponto final é alcançável, um compilador realiza a análise de fluxo de acordo com as regras de acessibilidade definidas para cada instrução. A análise de fluxo leva em conta os valores de expressões constantes (§12.23) que controlam o comportamento das afirmações, mas os possíveis valores de expressões não constantes não são considerados. Por outras palavras, para efeitos de análise do fluxo de controlo, considera-se que uma expressão não constante de um determinado tipo tem qualquer valor possível desse tipo.

No exemplo

void F()
{
    const int i = 1;
    if (i == 2)
        Console.WriteLine("unreachable");
}

a expressão booleana da if instrução é uma expressão constante porque ambos os == operandos do operador são constantes. Como a expressão constante é avaliada em tempo de compilação, produzindo o valor false, a Console.WriteLine invocação é considerada inalcançável. No entanto, se i for alterado para ser uma variável local

void F()
{
    int i = 1;
    if (i == 2)
        Console.WriteLine("reachable");
}

A invocação é considerada alcançável, ainda que, na realidade, nunca venha a Console.WriteLine ser executada.

Nota final

O bloco de um membro da função ou de uma função anónima é sempre considerado acessível. Ao avaliar sucessivamente as regras de acessibilidade de cada declaração em um bloco, a acessibilidade de qualquer declaração pode ser determinada.

Exemplo: No código a seguir

void F(int x)
{
    Console.WriteLine("start");
    if (x < 0)
        Console.WriteLine("negative");
}

A acessibilidade do segundo Console.WriteLine é determinada da seguinte forma:

• A primeira Console.WriteLine declaração de expressão é alcançável porque o bloco do F método é alcançável (§13.3).
• O ponto final da primeira Console.WriteLine declaração de expressão é alcançável porque essa declaração é alcançável (§13.7 e §13.3).
• A if declaração é alcançável porque o ponto final da primeira Console.WriteLine declaração de expressão é alcançável (§13.7 e §13.3).
• A segunda Console.WriteLine instrução de expressão é alcançável porque a expressão booleana da if instrução não tem o valor falseconstante .

Exemplo final

Há duas situações em que é um erro em tempo de compilação para o ponto final de uma instrução ser alcançável:

• Como a switch instrução não permite que uma seção de switch "caia" para a próxima seção de switch, é um erro em tempo de compilação para que o ponto final da lista de instruções de uma seção de switch seja acessível. Se esse erro ocorrer, normalmente é uma indicação de que uma break instrução está faltando.

• É um erro em tempo de compilação para o ponto final do bloco de um membro da função ou uma função anônima que calcula um valor para ser alcançável. Se esse erro ocorrer, normalmente é uma indicação de que uma return instrução está faltando (§13.10.5).

13.3 Blocos

13.3.1 Generalidades

Um bloco permite que várias instruções sejam escritas em contextos onde uma única instrução é permitida.

block
    : '{' statement_list? '}'
    ;

Um bloco consiste numa statement_list opcional (§13.3.2), encerrada por chaves. Se a lista de instruções for omitida, diz-se que o bloco está vazio.

Um bloco pode conter declarações (§13.6). O escopo de uma variável local ou constante declarada em um bloco é o bloco.

Um bloco é executado da seguinte forma:

• Se o bloco estiver vazio, o controle será transferido para o ponto final do bloco.
• Se o bloco não estiver vazio, o controle será transferido para a lista de instruções. Quando e se o controle atingir o ponto final da lista de instruções, o controle será transferido para o ponto final do bloco.

A lista de instruções de um bloco é acessível se o próprio bloco estiver acessível.

O ponto final de um bloco é alcançável se o bloco estiver vazio ou se o ponto final da lista de instruções estiver acessível.

Um bloco que contém uma ou mais yield instruções (§13.15) é chamado de bloco iterador. Os blocos iteradores são usados para implementar membros da função como iteradores (§15.14). Algumas restrições adicionais se aplicam aos blocos iteradores:

• É um erro em tempo de compilação para uma return instrução aparecer em um bloco iterador (mas yield return as instruções são permitidas).
• É um erro em tempo de compilação para um bloco iterador conter um contexto inseguro (§23.2). Um bloco iterador sempre define um contexto seguro, mesmo quando sua declaração está aninhada em um contexto inseguro.

13.3.2 Listas de declarações

Uma lista de instruções consiste em uma ou mais instruções escritas em sequência. As listas de declarações ocorrem nos blocos s (§13.3) e nos switch_blocks (§13.8.3).

statement_list
    : statement+
    ;

Uma lista de instruções é executada transferindo o controle para a primeira instrução. Quando e se o controle atingir o ponto final de uma instrução, o controle será transferido para a próxima instrução. Quando e se o controle atingir o ponto final da última instrução, o controle será transferido para o ponto final da lista de instruções.

Uma instrução em uma lista de instruções pode ser acessada se pelo menos uma das seguintes opções for verdadeira:

• A declaração é a primeira declaração e a própria lista de declarações é acessível.
• O ponto final da instrução anterior é alcançável.
• A instrução é uma declaração rotulada e o rótulo é referenciado por uma instrução alcançável goto .

O ponto final de uma lista de instruções é alcançável se o ponto final da última instrução na lista for alcançável.

13.4 A declaração vazia

Um empty_statement não faz nada.

empty_statement
    : ';'
    ;

Uma instrução vazia é usada quando não há operações a serem executadas em um contexto onde uma instrução é necessária.

A execução de uma instrução vazia simplesmente transfere o controle para o ponto final da instrução. Assim, o ponto final de uma instrução vazia é alcançável se a instrução vazia for alcançável.

Exemplo: Uma instrução vazia pode ser usada ao escrever uma while instrução com um corpo nulo:

bool ProcessMessage() {...}
void ProcessMessages()
{
    while (ProcessMessage())
        ;
}

Além disso, uma instrução vazia pode ser usada para declarar um rótulo imediatamente antes do fechamento "}" de um bloco:

void F(bool done)
{
    ...
    if (done)
    {
        goto exit;
    }
    ...
  exit:
    ;
}

Exemplo final

13.5 Advertências rotuladas

Um labeled_statement permite que uma declaração seja prefixada por um rótulo. Instruções rotuladas são permitidas em blocos, mas não são permitidas como instruções incorporadas.

labeled_statement
    : identifier ':' statement
    ;

Uma declaração rotulada declara um rótulo com o nome dado pelo identificador. O escopo de um rótulo é todo o bloco no qual o rótulo é declarado, incluindo quaisquer blocos aninhados. É um erro em tempo de compilação que dois rótulos com o mesmo nome tenham escopos sobrepostos.

Um rótulo pode ser referenciado a partir de goto declarações (§13.10.4) no âmbito do rótulo.

Nota: Isso significa que goto as instruções podem transferir o controle dentro e fora dos blocos, mas nunca em blocos. Nota final

As etiquetas têm o seu próprio espaço de declaração e não interferem com outros identificadores.

Exemplo: O exemplo

int F(int x)
{
    if (x >= 0)
    {
        goto x;
    }
    x = -x;
  x:
    return x;
}

é válido e usa o nome x como parâmetro e rótulo.

Exemplo final

A execução de uma instrução rotulada corresponde exatamente à execução da instrução após o rótulo.

Além da acessibilidade fornecida pelo fluxo normal de controle, uma instrução rotulada é alcançável se o rótulo for referenciado por uma instrução alcançável goto , a menos que a goto instrução esteja dentro do try bloco ou de um catch bloco de um try_statement que inclua um finally bloco cujo ponto final esteja inacessível e a instrução rotulada esteja fora do try_statement.

13.6 Declarações

13.6.1 Generalidades

Um declaration_statement declara uma ou mais variáveis locais, uma ou mais constantes locais ou uma função local. As instruções de declaração são permitidas em blocos e blocos de comutação, mas não são permitidas como instruções incorporadas.

declaration_statement
    : local_variable_declaration ';'
    | local_constant_declaration ';'
    | local_function_declaration
    ;

Uma variável local é declarada usando um local_variable_declaration (§13.6.2). Uma constante local é declarada usando um local_constant_declaration (§13.6.3). Uma função local é declarada usando um local_function_declaration (§13.6.4).

Os nomes declarados são introduzidos no espaço de declaração que o encerra mais próximo (ponto 7.3).

13.6.2 Declarações de variáveis locais

13.6.2.1 Generalidades

Um local_variable_declaration declara uma ou mais variáveis locais.

local_variable_declaration
    : implicitly_typed_local_variable_declaration
    | explicitly_typed_local_variable_declaration
    | explicitly_typed_ref_local_variable_declaration
    ;

As declarações digitadas implicitamente contêm a palavra-chave contextual (§6.4.4), var resultando numa ambiguidade sintática entre as três categorias, que é resolvida da seguinte forma:

• Se não houver nenhum tipo nomeado var no escopo e a entrada corresponder implicitly_typed_local_variable_declaration então ele é escolhido;
• Caso contrário, se um tipo nomeado var estiver no escopo, implicitly_typed_local_variable_declaration não será considerado como uma possível correspondência.

Dentro de um local_variable_declaration cada variável é introduzida por um declarador, que é um dos implicitly_typed_local_variable_declarator, explicitly_typed_local_variable_declarator ou ref_local_variable_declarator para variáveis locais implicitamente tipadas, explicitamente tipadas e ref, respectivamente. O declarador define o nome (identificador) e o valor inicial, se houver, da variável introduzida.

Se houver vários declaradores em uma declaração, eles são processados, incluindo quaisquer expressões inicializantes, na ordem da esquerda para a direita (§9.4.4.5).

Nota: Para uma local_variable_declaration que não ocorra como for_initializer (§13.9.4) ou resource_acquisition (§13.14), esta ordem da esquerda para a direita é equivalente a cada declarante estar dentro de um local_variable_declaration separado. Por exemplo:

void F()
{
    int x = 1, y, z = x * 2;
}

é equivalente a:

void F()
{
    int x = 1;
    int y;
    int z = x * 2;
}

Nota final

O valor de uma variável local é obtido numa expressão utilizando um simple_name (§12.8.4). Uma variável local deve ser definitivamente atribuída (§9.4) em cada local onde o seu valor é obtido. Cada variável local introduzida por um local_variable_declaration não é inicialmente atribuída (§9.4.3). Se um declarador tiver uma expressão inicializante, a variável local introduzida é classificada como atribuída no final do declarador (§9.4.4.5).

O âmbito de uma variável local introduzida por um local_variable_declaration é definido da seguinte forma (§7.7):

• Se a declaração ocorrer como um for_initializer então o escopo é o for_initializer, for_condition, for_iterator e embedded_statement (§13.9.4);
• Se a declaração ocorrer como um resource_acquisition então o escopo é o bloco mais externo da expansão semanticamente equivalente do using_statement (§13.14);
• Caso contrário, o escopo é o bloco no qual a declaração ocorre.

É um erro referir-se a uma variável local pelo nome em uma posição textual que precede seu declarador, ou dentro de qualquer expressão inicializante dentro de seu declarador. Dentro do escopo de uma variável local, é um erro em tempo de compilação declarar outra variável local, função local ou constante com o mesmo nome.

O ref-safe-context (§9.7.2) de uma variável local ref é o ref-safe-context de sua variable_reference inicializante. O contexto ref-safe de variáveis locais não-ref é declaration-block.

13.6.2.2 Declarações de variáveis locais digitadas implicitamente

implicitly_typed_local_variable_declaration
    : 'var' implicitly_typed_local_variable_declarator
    | ref_kind 'var' ref_local_variable_declarator
    ;

implicitly_typed_local_variable_declarator
    : identifier '=' expression
    ;

Um implicitly_typed_local_variable_declaration introduz uma única variável local, identificador. A expressão ou variable_reference deve ter um tipo de tempo de compilação, T. A primeira alternativa declara uma variável com um valor inicial de T. A segunda alternativa declara uma variável ref com um valor inicial de ref variable_reference, seu tipo é quando ref T? é um tipo de referência não anulável, caso contrário, seu tipo é T.ref T (ref_kind é descrito no §15.6.1.)

Exemplo:

var i = 5;
var s = "Hello";
var d = 1.0;
var numbers = new int[] {1, 2, 3};
var orders = new Dictionary<int,Order>();
ref var j = ref i;
ref readonly var k = ref i;

As declarações de variáveis locais digitadas implicitamente acima são precisamente equivalentes às seguintes declarações explicitamente digitadas:

int i = 5;
string s = "Hello";
double d = 1.0;
int[] numbers = new int[] {1, 2, 3};
Dictionary<int,Order> orders = new Dictionary<int,Order>();
ref int j = ref i;
ref readonly int k = ref i;

As seguintes declarações de variáveis locais digitadas implicitamente estão incorretas:

var x;                  // Error, no initializer to infer type from
var y = {1, 2, 3};      // Error, array initializer not permitted
var z = null;           // Error, null does not have a type
var u = x => x + 1;     // Error, anonymous functions do not have a type
var v = v++;            // Error, initializer cannot refer to v itself

Exemplo final

13.6.2.3 Declarações de variáveis locais digitadas explicitamente

explicitly_typed_local_variable_declaration
    : type explicitly_typed_local_variable_declarators
    ;

explicitly_typed_local_variable_declarators
    : explicitly_typed_local_variable_declarator
      (',' explicitly_typed_local_variable_declarator)*
    ;

explicitly_typed_local_variable_declarator
    : identifier ('=' local_variable_initializer)?
    ;

local_variable_initializer
    : expression
    | array_initializer
    ;

Um explicity_typed_local_variable_declaration introduz uma ou mais variáveis locais com o tipo especificado.

Se uma local_variable_initializer estiver presente, seu tipo será apropriado de acordo com as regras de atribuição simples (§12.21.2) ou inicialização de matriz (§17.7) e seu valor será atribuído como o valor inicial da variável.

13.6.2.4 Declarações de variáveis locais ref explicitamente digitadas

explicitly_typed_ref_local_variable_declaration
    : ref_kind type ref_local_variable_declarators
    ;

ref_local_variable_declarators
    : ref_local_variable_declarator (',' ref_local_variable_declarator)*
    ;

ref_local_variable_declarator
    : identifier '=' 'ref' variable_reference
    ;

O variable_reference inicializador deve ter tipo de tipo e satisfazer os mesmos requisitos que para uma atribuição ref (§12.21.3).

Se ref_kind for ref readonly, o(s) identificador(es) que está sendo declarado(s) são referências a variáveis que são tratadas como somente leitura. Caso contrário, se ref_kind for ref, o (s) identificador(es) declarado(s) são referências a variáveis que devem ser graváveis.

É um erro em tempo de compilação declarar uma variável local ref, ou uma variável de um ref struct tipo, dentro de um método declarado com o method_modifierasync, ou dentro de um iterador (§15.14).

13.6.3 Declarações constantes locais

Um local_constant_declaration declara uma ou mais constantes locais.

local_constant_declaration
    : 'const' type constant_declarators
    ;

constant_declarators
    : constant_declarator (',' constant_declarator)*
    ;

constant_declarator
    : identifier '=' constant_expression
    ;

O tipo de local_constant_declaration especifica o tipo das constantes introduzidas pela declaração. O tipo é seguido por uma lista de constant_declarators, cada um dos quais introduz uma nova constante. Um constant_declarator consiste em um identificador que nomeia a constante, seguido por um token "=", seguido por um constant_expression (§12.23) que dá o valor da constante.

O tipo e a constant_expression de uma declaração constante local devem seguir as mesmas regras que as de uma declaração de membro constante (§15.4).

O valor de uma constante local é obtido numa expressão utilizando um simple_name (§12.8.4).

O escopo de uma constante local é o bloco no qual a declaração ocorre. É um erro referir-se a uma constante local em uma posição textual que precede o final de sua constant_declarator.

Uma declaração constante local que declara várias constantes é equivalente a várias declarações de constantes únicas com o mesmo tipo.

13.6.4 Declarações de função local

Um local_function_declaration declara uma função local.

local_function_declaration
    : local_function_modifier* return_type local_function_header
      local_function_body
    | ref_local_function_modifier* ref_kind ref_return_type
      local_function_header ref_local_function_body
    ;

local_function_header
    : identifier '(' parameter_list? ')'
    | identifier type_parameter_list '(' parameter_list? ')'
      type_parameter_constraints_clause*
    ;

local_function_modifier
    : ref_local_function_modifier
    | 'async'
    ;

ref_local_function_modifier
    : 'static'
    | unsafe_modifier   // unsafe code support
    ;

local_function_body
    : block
    | '=>' null_conditional_invocation_expression ';'
    | '=>' expression ';'
    ;

ref_local_function_body
    : block
    | '=>' 'ref' variable_reference ';'
    ;

Nota gramatical: Ao reconhecer um local_function_body se forem aplicáveis as alternativas de null_conditional_invocation_expression e expressão , deve ser escolhida a primeira. (§15.6.1)

Exemplo: Há dois casos de uso comuns para funções locais: métodos iteradores e métodos assíncronos. Nos métodos iteradores, quaisquer exceções são observadas somente ao chamar o código que enumera a sequência retornada. Em métodos assíncronos, quaisquer exceções só são observadas quando a Tarefa retornada é aguardada. O exemplo a seguir demonstra a separação da validação de parâmetros da implementação do iterador usando uma função local:

public static IEnumerable<char> AlphabetSubset(char start, char end)
{
    if (start < 'a' || start > 'z')
    {
        throw new ArgumentOutOfRangeException(paramName: nameof(start),
            message: "start must be a letter");
    }
    if (end < 'a' || end > 'z')
    {
        throw new ArgumentOutOfRangeException(paramName: nameof(end),
            message: "end must be a letter");
    }
    if (end <= start)
    {
        throw new ArgumentException(
            $"{nameof(end)} must be greater than {nameof(start)}");
    }
    return AlphabetSubsetImplementation();

    IEnumerable<char> AlphabetSubsetImplementation()
    {
        for (var c = start; c < end; c++)
        {
            yield return c;
        }
    }
}

Exemplo final

A menos que especificado de outra forma abaixo, a semântica de todos os elementos gramaticais é a mesma que para method_declaration (§15.6.1), lida no contexto de uma função local em vez de um método.

O identificador de um local_function_declaration deve ser único no seu âmbito de bloco declarado, incluindo quaisquer espaços de declaração variáveis locais que incluam. Uma consequência disso é que local_function_declarationsobrecarregados não são permitidos.

Um local_function_declaration pode incluir um async modificador (§15.15) e um unsafe modificador (§23.1). Se a declaração incluir o async modificador, o tipo de retorno deve ser void ou um «TaskType» tipo (§15.15.1). Se a declaração incluir o static modificador, a função é uma função local estática, caso contrário, é uma função local não estática. É um erro em tempo de compilação para type_parameter_list ou parameter_list para conter atributos. Se a função local for declarada em um contexto não seguro (§23.2), a função local pode incluir código não seguro, mesmo que a declaração da função local não inclua o unsafe modificador.

Uma função local é declarada no escopo do bloco. Uma função local não estática pode capturar variáveis do escopo que o encerra, enquanto uma função local estática não deve (portanto, não tem acesso a locais fechados, parâmetros, funções locais não estáticas ou this). É um erro em tempo de compilação se uma variável capturada é lida pelo corpo de uma função local não estática, mas não é definitivamente atribuída antes de cada chamada para a função. Um compilador deve determinar quais variáveis são definitivamente atribuídas no retorno (§9.4.4.33).

Quando o tipo de é um tipo struct, é um erro em tempo de this compilação para o corpo de uma função local para acessar this. Isso é verdadeiro se o acesso for explícito (como em this.x) ou implícito (como em x onde x é um membro de instância do struct). Esta regra apenas proíbe esse acesso e não afeta se a pesquisa de membros resulta em um membro da struct.

É um erro em tempo de compilação para o corpo da função local conter uma goto instrução, uma break instrução ou uma continue instrução cujo destino está fora do corpo da função local.

Nota: as regras acima para this e goto espelham as regras para funções anónimas no §12.19.3. Nota final

Uma função local pode ser chamada a partir de um ponto lexical antes de sua declaração. No entanto, é um erro em tempo de compilação que a função seja declarada lexicamente antes da declaração de uma variável usada na função local (§7.7).

É um erro em tempo de compilação para uma função local declarar um parâmetro, parâmetro de tipo ou variável local com o mesmo nome que um declarado em qualquer espaço de declaração de variável local que o inclua.

Os órgãos funcionais locais estão sempre acessíveis. O ponto de extremidade de uma declaração de função local é alcançável se o ponto inicial da declaração de função local estiver acessível.

Exemplo: No exemplo a seguir, o corpo de L é alcançável mesmo que o ponto inicial de L não seja alcançável. Como o ponto inicial de L não é alcançável, a instrução que segue o ponto de extremidade de L não é alcançável:

class C
{
    int M()
    {
        L();
        return 1;

        // Beginning of L is not reachable
        int L()
        {
            // The body of L is reachable
            return 2;
        }
        // Not reachable, because beginning point of L is not reachable
        return 3;
    }
}

Em outras palavras, o local de uma declaração de função local não afeta a acessibilidade de nenhuma instrução na função que contém. Exemplo final

Se o tipo de argumento para uma função local for dynamic, a função a ser chamada deve ser resolvida em tempo de compilação, não em tempo de execução.

Não deve ser utilizada uma função local numa árvore de expressão.

Uma função local estática

• Pode fazer referência a membros estáticos, parâmetros de tipo, definições constantes e funções locais estáticas a partir do escopo anexo.
• Não deve fazer referência this ou base nem membros da instância a partir de uma referência implícita this , nem variáveis locais, parâmetros ou funções locais não estáticas do âmbito anexo. No entanto, tudo isso é permitido em uma nameof() expressão.

13.7 Enunciados de expressão

Um expression_statement avalia uma determinada expressão. O valor calculado pela expressão, se houver, é descartado.

expression_statement
    : statement_expression ';'
    ;

statement_expression
    : null_conditional_invocation_expression
    | invocation_expression
    | object_creation_expression
    | assignment
    | post_increment_expression
    | post_decrement_expression
    | pre_increment_expression
    | pre_decrement_expression
    | await_expression
    ;

Nem todas as expressões são permitidas como declarações.

Nota: Em particular, expressões como x + y e x == 1, que apenas computam um valor (que será descartado), não são permitidas como declarações. Nota final

A execução de um expression_statement avalia a expressão contida e, em seguida, transfere o controle para o ponto final do expression_statement. O ponto final de um expression_statement é alcançável se esse expression_statement for alcançável.

13.8 Declarações de seleção

13.8.1 Generalidades

As instruções de seleção selecionam uma das várias instruções possíveis para execução com base no valor de alguma expressão.

selection_statement
    : if_statement
    | switch_statement
    ;

13.8.2 A declaração if

A if instrução seleciona uma instrução para execução com base no valor de uma expressão booleana.

if_statement
    : 'if' '(' boolean_expression ')' embedded_statement
    | 'if' '(' boolean_expression ')' embedded_statement
      'else' embedded_statement
    ;

Uma else parte está associada ao precedente if lexicamente mais próximo que é permitido pela sintaxe.

Exemplo: Assim, uma if declaração do formulário

if (x) if (y) F(); else G();

é equivalente a

if (x)
{
    if (y)
    {
        F();
    }
    else
    {
        G();
    }
}

Exemplo final

Uma if instrução é executada da seguinte forma:

• A boolean_expression (§12.24) é avaliada.
• Se a expressão booleana produzir true, o controle será transferido para a primeira instrução incorporada. Quando e se o controle atingir o ponto final dessa instrução, o controle será transferido para o ponto final da if instrução.
• Se a expressão booleana produzir false e se uma else parte estiver presente, o controle será transferido para a segunda instrução incorporada. Quando e se o controle atingir o ponto final dessa instrução, o controle será transferido para o ponto final da if instrução.
• Se a expressão booleana ceder false e se uma else parte não estiver presente, o if controle será transferido para o ponto final da instrução.

A primeira instrução incorporada de uma if instrução é alcançável se a if instrução for alcançável e a expressão booleana não tiver o valor falseconstante .

A segunda instrução incorporada de uma if instrução, se presente, é alcançável se a if instrução é alcançável e a expressão booleana não tem o valor trueconstante .

O ponto final de uma if instrução é alcançável se o ponto final de pelo menos uma de suas instruções incorporadas for alcançável. Além disso, o ponto final de uma if instrução sem else parte é alcançável se a if instrução for alcançável e a expressão booleana não tiver o valor trueconstante .

13.8.3 A instrução switch

A switch instrução seleciona para execução uma lista de instruções com um rótulo de switch associado que corresponde ao valor da expressão switch.

switch_statement
    : 'switch' '(' expression ')' switch_block
    ;

switch_block
    : '{' switch_section* '}'
    ;

switch_section
    : switch_label+ statement_list
    ;

switch_label
    : 'case' pattern case_guard?  ':'
    | 'default' ':'
    ;

case_guard
    : 'when' expression
    ;

Um switch_statement consiste na palavra-chave , seguida por uma expressão entre parênteses (chamadaswitch), seguida por uma switch_block. O switch_block consiste em zero ou mais switch_sections, fechados em chaves. Cada switch_section consiste em uma ou mais switch_labelseguidas de uma statement_list (§13.3.2). Cada switch_label contendo case tem um padrão associado (§11) em relação ao qual o valor da expressão switch é testado. Se case_guard estiver presente, a sua expressão deve ser implicitamente convertível em tipo bool e essa expressão é avaliada como uma condição adicional para que o caso seja considerado preenchido.

O tipo que rege uma switch instrução é estabelecido pela expressão switch.

• Se o tipo da expressão switch for sbyte, byte, , shortushort, int, uint, long, ulong, charboolstringou um enum_type, ou se for o tipo de valor anulável correspondente a um desses tipos, esse é o tipo que rege a switch instrução.
• Caso contrário, se existir exatamente uma conversão implícita definida pelo usuário do tipo da expressão switch para um dos seguintes tipos de governo possíveis: sbyte, byte, short, ushort, int, uintlongulongcharstring, , ou, um tipo de valor anulável correspondente a um desses tipos, então o tipo convertido é o tipo que rege a switch instrução.
• Caso contrário, o tipo regulador da switch instrução é o tipo da expressão switch. É um erro se esse tipo não existir.

Pode haver, no máximo, um default rótulo numa switch declaração.

É um erro se o padrão de qualquer rótulo de comutador não for aplicável (§11.2.1) ao tipo da expressão de entrada.

É um erro se o padrão de qualquer rótulo de switch for subsumido por (§11.3) o conjunto de padrões de rótulos de switch anteriores da instrução switch que não têm um protetor de caixa ou cujo protetor de caixa é uma expressão constante com o valor true.

Exemplo:

switch (shape)
{
    case var x:
        break;
    case var _: // error: pattern subsumed, as previous case always matches
        break;
    default:
        break;  // warning: unreachable, all possible values already handled.
}

Exemplo final

Uma switch instrução é executada da seguinte forma:

• A expressão switch é avaliada e convertida para o tipo de governante.
• O controle é transferido de acordo com o valor da expressão de switch convertida:
  • O primeiro padrão lexicamente no conjunto de rótulos na mesma case instrução que corresponde ao valor da expressão switch e para o qual a expressão guard está ausente ou é avaliada como true, faz com que o controle seja transferido para a lista de switch instruções seguindo o rótulo correspondentecase.
  • Caso contrário, se um default rótulo estiver presente, o controle será transferido para a lista de instruções após o default rótulo.
  • Caso contrário, o controle é transferido para o ponto final da switch instrução.

Nota: A ordem na qual os padrões são correspondidos em tempo de execução não está definida. Um compilador é permitido (mas não necessário) para corresponder padrões fora de ordem e reutilizar os resultados de padrões já combinados para calcular o resultado da correspondência de outros padrões. No entanto, um compilador é necessário para determinar o primeiro padrão em ordem lexical que corresponde à expressão e para o qual a cláusula de proteção está ausente ou resulta em true. Nota final

Se o ponto final da lista de instruções de uma seção de switch estiver acessível, ocorrerá um erro em tempo de compilação. Isto é conhecido como a regra "no fall through".

Exemplo: O exemplo

switch (i)
{
    case 0:
        CaseZero();
        break;
    case 1:
        CaseOne();
        break;
    default:
        CaseOthers();
        break;
}

é válido porque nenhuma secção do comutador tem um ponto final alcançável. Ao contrário de C e C++, a execução de uma seção de switch não tem permissão para "cair" para a próxima seção de switch, e o exemplo

switch (i)
{
    case 0:
        CaseZero();
    case 1:
        CaseZeroOrOne();
    default:
        CaseAny();
}

resulta em um erro em tempo de compilação. Quando a execução de uma secção de comutação tiver de ser seguida da execução de outra secção de comutador, deve ser utilizada uma declaração ou goto case uma declaração explícitagoto default:

switch (i)
{
    case 0:
        CaseZero();
        goto case 1;
    case 1:
        CaseZeroOrOne();
        goto default;
    default:
        CaseAny();
        break;
}

Exemplo final

Vários rótulos são permitidos em um switch_section.

Exemplo: O exemplo

switch (i)
{
    case 0:
        CaseZero();
        break;
    case 1:
        CaseOne();
        break;
    case 2:
    default:
        CaseTwo();
        break;
}

é válida. O exemplo não viola a regra "no fall through" porque os rótulos case 2: e default: fazem parte do mesmo switch_section.

Exemplo final

Nota: A regra "no fall through" impede uma classe comum de bugs que ocorrem em C e C++ quando break instruções são omitidas acidentalmente. Por exemplo, as seções da instrução acima podem ser revertidas switch sem afetar o comportamento da instrução:

switch (i)
{
    default:
        CaseAny();
        break;
    case 1:
        CaseZeroOrOne();
        goto default;
    case 0:
        CaseZero();
        goto case 1;
}

Nota final

Nota: A lista de instruções de uma seção de switch normalmente termina em uma breakinstrução , goto caseou goto default , mas qualquer construção que torne o ponto final da lista de instruções inacessível é permitida. Por exemplo, sabe-se que uma while instrução controlada pela expressão true booleana nunca chega ao seu ponto final. Da mesma forma, uma throw instrução ou return sempre transfere o controle para outro lugar e nunca chega ao seu ponto final. Assim, o seguinte exemplo é válido:

switch (i)
{
     case 0:
         while (true)
         {
             F();
         }
     case 1:
         throw new ArgumentException();
     case 2:
         return;
}

Nota final

Exemplo: O tipo que rege uma switch instrução pode ser o tipo string. Por exemplo:

void DoCommand(string command)
{
    switch (command.ToLower())
    {
        case "run":
            DoRun();
            break;
        case "save":
            DoSave();
            break;
        case "quit":
            DoQuit();
            break;
        default:
            InvalidCommand(command);
            break;
    }
}

Exemplo final

Nota: Como os operadores de igualdade de string (§12.12.8), a instrução diferencia maiúsculas de minúsculas switch e executará uma determinada seção de switch somente se a string de expressão de switch corresponder exatamente a uma case constante de rótulo. nota final Quando o tipo regulador de uma switch instrução é string ou um tipo de valor anulável, o valor null é permitido como uma case constante de rótulo.

Os statement_listde um switch_block podem conter declarações (§13.6). O escopo de uma variável local ou constante declarada em um bloco de switch é o bloco de switch.

Um rótulo de switch pode ser acessado se pelo menos uma das seguintes opções for verdadeira:

• A expressão switch é um valor constante e
  • o rótulo é um case cujo padrão corresponderia (§11.2.1) a esse valor, e a proteção do rótulo está ausente ou não é uma expressão constante com o valor false;
  • É um default rótulo, e nenhuma seção de switch contém um rótulo de caso cujo padrão corresponderia a esse valor e cuja proteção está ausente ou é uma expressão constante com o valor true.
• A expressão switch não é um valor constante e
  • o rótulo é um case sem guarda ou com um guarda cujo valor não é a constante falsa;
  • é um default rótulo e
    • o conjunto de padrões que aparecem entre os casos da instrução switch que não têm proteções ou têm proteções cujo valor é a constante true, não é exaustivo (§11.4) para o tipo de regulador do interruptor;
    • O tipo de controle do switch é um tipo anulável e o conjunto de padrões que aparecem entre os casos da instrução switch que não têm proteções ou têm proteções cujo valor é a constante true não contém um padrão que corresponderia ao valor null.
• O rótulo do switch é referenciado por uma instrução ou goto case acessívelgoto default.

A lista de instruções de uma determinada seção de switch estará acessível se a switch instrução estiver acessível e a seção de switch contiver um rótulo de switch acessível.

O ponto final de uma switch instrução é alcançável se a instrução switch estiver acessível e pelo menos uma das seguintes opções for verdadeira:

• A switch declaração contém uma declaração acessível break que sai da switch declaração.
• Nenhum default rótulo está presente e
  • A expressão switch é um valor não constante, e o conjunto de padrões que aparecem entre os casos da instrução switch que não têm proteções ou têm proteções cujo valor é a constante true, não é exaustivo (§11.4) para o tipo de regulador do interruptor.
  • A expressão switch é um valor não constante de um tipo anulável, e nenhum padrão que aparece entre os casos da instrução switch que não têm proteções ou têm proteções cujo valor é a constante true corresponderia ao valor null.
  • A expressão switch é um valor constante e nenhum case rótulo sem um protetor ou cujo protetor é o verdadeiro constante corresponderia a esse valor.

Exemplo: O código a seguir mostra um uso sucinto da when cláusula:

static object CreateShape(string shapeDescription)
{
   switch (shapeDescription)
   {
        case "circle":
            return new Circle(2);
        …
        case var o when string.IsNullOrWhiteSpace(o):
            return null;
        default:
            return "invalid shape description";
    }
}

O caso var corresponde a null, a cadeia de caracteres vazia ou qualquer cadeia de caracteres que contenha apenas espaço em branco. Exemplo final

13.9 Instruções de iteração

13.9.1 Generalidades

As instruções de iteração executam repetidamente uma instrução incorporada.

iteration_statement
    : while_statement
    | do_statement
    | for_statement
    | foreach_statement
    ;

13.9.2 A declaração while

A while instrução executa condicionalmente uma instrução incorporada zero ou mais vezes.

while_statement
    : 'while' '(' boolean_expression ')' embedded_statement
    ;

Uma while instrução é executada da seguinte forma:

• A boolean_expression (§12.24) é avaliada.
• Se a expressão booleana produzir true, o controle será transferido para a instrução incorporada. Quando e se o controle atingir o ponto final da instrução incorporada (possivelmente a partir da execução de uma continue instrução), o while controle será transferido para o início da instrução.
• Se a expressão booleana produzir false, o controle será transferido para o ponto final da while instrução.

Dentro da instrução incorporada de uma while declaração, uma break instrução (§13.10.2) pode ser usada para transferir o controle para o ponto final da while instrução (terminando assim a iteração da instrução incorporada), e uma continue instrução (§13.10.3) pode ser usada para transferir o controle para o ponto final da instrução incorporada (executando assim outra iteração da while declaração).

A instrução incorporada de uma while instrução é alcançável se a while instrução é alcançável e a expressão booleana não tem o valor falseconstante .

O ponto final de uma while instrução é alcançável se pelo menos uma das seguintes situações for verdadeira:

• A while declaração contém uma declaração acessível break que sai da while declaração.
• A while instrução é alcançável e a expressão booleana não tem o valor trueconstante .

13.9.3 A declaração do

A do instrução condicionalmente executa uma instrução incorporada uma ou mais vezes.

do_statement
    : 'do' embedded_statement 'while' '(' boolean_expression ')' ';'
    ;

Uma do instrução é executada da seguinte forma:

• O controle é transferido para a instrução incorporada.
• Quando e se o controle atingir o ponto final da declaração incorporada (possivelmente a partir da execução de uma continue declaração), o boolean_expression (§12.24) é avaliado. Se a expressão booleana render, trueo controle será transferido para o início da do instrução. Caso contrário, o controle é transferido para o ponto final da do instrução.

Dentro da instrução incorporada de uma do declaração, uma break instrução (§13.10.2) pode ser usada para transferir o controle para o ponto final da do instrução (terminando assim a iteração da instrução incorporada), e uma continue instrução (§13.10.3) pode ser usada para transferir o controle para o ponto final da instrução incorporada (executando assim outra iteração da do declaração).

A instrução incorporada de uma do instrução é acessível se a do instrução for alcançável.

O ponto final de uma do instrução é alcançável se pelo menos uma das seguintes situações for verdadeira:

• A do declaração contém uma declaração acessível break que sai da do declaração.
• O ponto final da instrução incorporada é alcançável e a expressão booleana não tem o valor trueconstante .

13.9.4 O para declaração

A for instrução avalia uma sequência de expressões de inicialização e, em seguida, enquanto uma condição é verdadeira, executa repetidamente uma instrução incorporada e avalia uma sequência de expressões de iteração.

for_statement
    : 'for' '(' for_initializer? ';' for_condition? ';' for_iterator? ')'
      embedded_statement
    ;

for_initializer
    : local_variable_declaration
    | statement_expression_list
    ;

for_condition
    : boolean_expression
    ;

for_iterator
    : statement_expression_list
    ;

statement_expression_list
    : statement_expression (',' statement_expression)*
    ;

O for_initializer, se existir, consiste num local_variable_declaration (§13.6.2) ou numa lista de statement_expressions (§13.7) separados por vírgulas. O escopo de uma variável local declarada por um for_initializer é o for_initializer, for_condition, for_iterator e embedded_statement.

O for_condition, se existir, será um boolean_expression (§12.24).

O for_iterator, se existir, consiste numa lista de statement_expressions (§13.7) separados por vírgulas.

Uma for instrução é executada da seguinte forma:

• Se um for_initializer estiver presente, os inicializadores de variáveis ou expressões de instrução serão executados na ordem em que são gravados. Esta etapa é executada apenas uma vez.
• Se uma for_condition estiver presente, ela é avaliada.
• Se o for_condition não estiver presente ou se a avaliação render true, o controle é transferido para a instrução incorporada. Quando e se o controle atinge o ponto final da instrução incorporada (possivelmente a partir da execução de uma continue instrução), as expressões do for_iterator, se houver, são avaliadas em sequência e, em seguida, outra iteração é executada, começando com a avaliação do for_condition na etapa acima.
• Se o for_condition estiver presente e a avaliação render, falseo controle é transferido para o for ponto final da declaração.

Dentro da instrução incorporada de uma for declaração, uma break instrução (§13.10.2) pode ser usada para transferir o controle para o ponto final da for instrução (terminando assim a iteração da instrução incorporada), e uma continue instrução (§13.10.3) pode ser usada para transferir o controle para o ponto final da instrução incorporada (executando assim o for_iterator e executando outra iteração da for declaração, começando pelo for_condition).

A instrução incorporada de uma for instrução pode ser acessada se uma das seguintes opções for verdadeira:

• A for declaração está acessível e nenhum for_condition está presente.
• A for instrução é alcançável e um for_condition está presente e não tem o valor falseconstante .

O ponto final de uma for instrução é alcançável se pelo menos uma das seguintes situações for verdadeira:

• A for declaração contém uma declaração acessível break que sai da for declaração.
• A for instrução é alcançável e um for_condition está presente e não tem o valor trueconstante .

13.9.5 A declaração foreach

A foreach instrução enumera os elementos de uma coleção, executando uma instrução incorporada para cada elemento da coleção.

foreach_statement
    : 'foreach' '(' ref_kind? local_variable_type identifier 'in' 
      expression ')' embedded_statement
    ;

O local_variable_type e o identificador de uma instrução foreach declaram a variável de iteração da instrução. Se o var identificador é dado como o local_variable_type, e nenhum tipo nomeado var está no escopo, a variável de iteração é dita como sendo uma variável de iteração digitada implicitamente, e seu tipo é tomado como o tipo de elemento da foreach instrução, conforme especificado abaixo.

Se o foreach_statement contiver ambos ou nenhum ref e readonly, a variável de iteração denotará uma variável que é tratada como somente leitura. Caso contrário, se foreach_statement contiver ref sem readonly, a variável de iteração denota uma variável que deve ser gravável.

A variável de iteração corresponde a uma variável local com um escopo que se estende sobre a instrução incorporada. Durante a execução de uma foreach instrução, a variável de iteração representa o elemento de coleção para o qual uma iteração está sendo executada no momento. Se a variável de iteração denotar uma variável somente leitura, ocorrerá um erro em tempo de compilação se a instrução incorporada tentar modificá-la (via atribuição ou os ++ operadores and -- ) ou passá-la como um parâmetro de referência ou saída.

A seguir, para brevidade, IEnumerable, IEnumeratorIEnumerable<T> , e IEnumerator<T> referem-se aos tipos correspondentes nos namespaces System.Collections e System.Collections.Generic.

O processamento em tempo de compilação de uma foreach instrução primeiro determina o tipo de coleção, o tipo de enumerador e o tipo de iteração da expressão. Esta determinação procede da seguinte forma:

• Se o tipo X de expressão é um tipo de matriz, então há uma conversão de referência implícita de X para a IEnumerable interface (uma vez que System.Array implementa esta interface). O tipo de coleção é a IEnumerable interface, o tipo de enumerador é a IEnumerator interface e o tipo de iteração é o tipo de elemento do tipo Xde matriz.
• Se o tipo X de expressão for dynamic , então há uma conversão implícita da expressão para a IEnumerable interface (§10.2.10). O tipo de coleção é a IEnumerable interface e o tipo de enumerador é a IEnumerator interface. Se o var identificador é dado como o local_variable_type então o tipo de iteração é dynamic, caso contrário, é object.
• Caso contrário, determine se o tipo X tem um método apropriado GetEnumerator :
  • Execute a pesquisa de membro no tipo X com identificador GetEnumerator e sem argumentos de tipo. Se a pesquisa de membro não produzir uma correspondência, ou produzir uma ambiguidade, ou produzir uma correspondência que não seja um grupo de método, verifique se há uma interface enumerável conforme descrito abaixo. Recomenda-se que um aviso seja emitido se a pesquisa de membros produzir qualquer coisa, exceto um grupo de métodos ou nenhuma correspondência.
  • Execute a resolução de sobrecarga usando o grupo de métodos resultante e uma lista de argumentos vazia. Se a resolução de sobrecarga não resultar em nenhum método aplicável, resultar em uma ambiguidade ou resultar em um único melhor método, mas esse método for estático ou não público, verifique se há uma interface enumerável conforme descrito abaixo. Recomenda-se que seja emitido um aviso se a resolução de sobrecarga produzir qualquer coisa, exceto um método de instância pública inequívoca ou nenhum método aplicável.
  • Se o tipo E de retorno do GetEnumerator método não for uma classe, struct ou tipo de interface, um erro será produzido e nenhuma outra etapa será executada.
  • A pesquisa de membros é realizada com E o identificador Current e sem argumentos de tipo. Se a pesquisa de membro não produzir nenhuma correspondência, o resultado será um erro ou o resultado será qualquer coisa, exceto uma propriedade de instância pública que permite a leitura, um erro será produzido e nenhuma outra etapa será executada.
  • A pesquisa de membros é realizada com E o identificador MoveNext e sem argumentos de tipo. Se a pesquisa de membro não produzir nenhuma correspondência, o resultado for um erro ou o resultado for qualquer coisa, exceto um grupo de métodos, um erro será produzido e nenhuma outra etapa será executada.
  • A resolução de sobrecarga é executada no grupo de métodos com uma lista de argumentos vazia. Se a resolução de sobrecarga não resultar em nenhum método aplicável, resultar em uma ambiguidade ou resultar em um único melhor método, mas esse método for estático ou não público, ou seu tipo de retorno não boolfor , um erro será produzido e nenhuma outra etapa será tomada.
  • O tipo de coleção é X, o tipo de enumerador é E, e o tipo de iteração é o tipo da Current propriedade. A Current propriedade pode incluir o ref modificador, caso em que a expressão retornada é um variable_reference (§9.5) que é opcionalmente somente leitura.
• Caso contrário, verifique se há uma interface enumerável:
  • Se entre todos os tipos Tᵢ para os quais há uma conversão implícita de X para IEnumerable<Tᵢ>, há um tipo T único tal que T não dynamic é e para todos os outros Tᵢ há uma conversão implícita de para IEnumerable<T>, então o tipo de coleção é a interface IEnumerable<Tᵢ>, o tipo de enumerador é a interface IEnumerable<T>, e o tipo de IEnumerator<T> iteração é T.
  • Caso contrário, se houver mais de um desses tipos T, então um erro é produzido e nenhuma outra etapa é tomada.
  • Caso contrário, se houver uma conversão implícita de para a X interface, o tipo de coleção é essa interface, o tipo de enumerador é a interface System.Collections.IEnumerablee o tipo de System.Collections.IEnumerator iteração é object.
  • Caso contrário, é produzido um erro e não são tomadas mais medidas.

As etapas acima, se bem-sucedidas, produzem inequivocamente um tipo Cde coleção, tipo E de enumerador e tipo Tde iteração, ref Tou ref readonly T. Uma foreach declaração do formulário

foreach (V v in x) «embedded_statement»

é então equivalente a:

{
    E e = ((C)(x)).GetEnumerator();
    try
    {
        while (e.MoveNext())
        {
            V v = (V)(T)e.Current;
            «embedded_statement»
        }
    }
    finally
    {
        ... // Dispose e
    }
}

A variável e não é visível ou acessível à expressão x ou à instrução incorporada ou a qualquer outro código-fonte do programa. A variável v é somente leitura na instrução incorporada. Se não houver uma conversão explícita (§10.3) de (o tipo de T iteração) para V (o local_variable_type na foreach declaração), um erro é produzido e nenhuma outra etapa é tomada.

Quando a variável de iteração é uma variável de referência (§9.7), uma foreach declaração do formulário

foreach (ref V v in x) «embedded_statement»

é então equivalente a:

{
    E e = ((C)(x)).GetEnumerator();
    try
    {
        while (e.MoveNext())
        {
            ref V v = ref e.Current;
            «embedded_statement»
        }
    }
    finally
    {
        ... // Dispose e
    }
}

A variável e não é visível ou acessível à expressão x ou à instrução incorporada ou a qualquer outro código-fonte do programa. A variável v de referência é leitura-escrita na instrução incorporada, mas v não deve ser reatribuída (§12.21.3). Se não houver uma conversão de identidade (§10.2.2) de (o tipo de T iteração) para V (o local_variable_type na foreach instrução), um erro é produzido e nenhuma outra etapa é tomada.

Uma foreach instrução do formulário foreach (ref readonly V v in x) «embedded_statement» tem uma forma equivalente semelhante, mas a variável v de referência está ref readonly na instrução incorporada e, portanto, não pode ser reatribuída ou reatribuída.

Nota: Se x tiver o valor null, a System.NullReferenceException é lançado em tempo de execução. Nota final

Uma implementação é permitida para implementar um determinado foreach_statement de forma diferente, por exemplo, por razões de desempenho, desde que o comportamento seja consistente com a expansão acima.

A colocação de dentro do vwhile loop é importante para a forma como é capturado (§12.19.6.2) por qualquer função anónima que ocorra no embedded_statement.

Exemplo:

int[] values = { 7, 9, 13 };
Action f = null;
foreach (var value in values)
{
    if (f == null)
    {
        f = () => Console.WriteLine("First value: " + value);
    }
}
f();

Se v na forma expandida fosse declarado fora do while loop, ele seria compartilhado entre todas as iterações, e seu valor após o for loop seria o valor final, 13que é o que a invocação de f imprimiria. Em vez disso, como cada iteração tem sua própria variável v, a capturada na f primeira iteração continuará a manter o valor 7, que é o que será impresso. (Observe que as versões anteriores do C# declaradas v fora do while loop.)

Exemplo final

O corpo do finally bloco é construído de acordo com as seguintes etapas:

• Se houver uma conversão implícita de E para a System.IDisposable interface, então

  • Se E for um tipo de valor não anulável, a finally cláusula será expandida para o equivalente semântico de:

    finally
    {
        ((System.IDisposable)e).Dispose();
    }
    

  • Caso contrário, a finally cláusula é expandida para o equivalente semântico de:

    finally
    {
        System.IDisposable d = e as System.IDisposable;
        if (d != null)
        {
            d.Dispose();
        }
    }
    

    exceto que se E for um tipo de valor, ou um parâmetro de tipo instanciado para um tipo de valor, então a conversão de e para System.IDisposable não deve causar boxing para ocorrer.

• Caso contrário, se E for um tipo selado, a finally cláusula é expandida para um bloco vazio:

  finally {}
  

• Caso contrário, a finally cláusula é alargada para:

  finally
  {
      System.IDisposable d = e as System.IDisposable;
      if (d != null)
      {
          d.Dispose();
      }
  }
  

A variável d local não é visível ou acessível a qualquer código de usuário. Em particular, não entra em conflito com qualquer outra variável cujo âmbito inclua o finally bloco.

A ordem em que foreach atravessa os elementos de uma matriz, é a seguinte: Para matrizes unidimensionais, os elementos são percorridos em ordem de índice crescente, começando com o índice 0 e terminando com o índice Length – 1. Para matrizes multidimensionais, os elementos são percorridos de tal forma que os índices da dimensão mais à direita são aumentados primeiro, depois a próxima dimensão esquerda e assim por diante para a esquerda.

Exemplo: O exemplo a seguir imprime cada valor em uma matriz bidimensional, na ordem dos elementos:

class Test
{
    static void Main()
    {
        double[,] values =
        {
            {1.2, 2.3, 3.4, 4.5},
            {5.6, 6.7, 7.8, 8.9}
        };
        foreach (double elementValue in values)
        {
            Console.Write($"{elementValue} ");
        }
        Console.WriteLine();
    }
}

A produção é a seguinte:

1.2 2.3 3.4 4.5 5.6 6.7 7.8 8.9

Exemplo final

Exemplo: No exemplo a seguir

int[] numbers = { 1, 3, 5, 7, 9 };
foreach (var n in numbers)
{
    Console.WriteLine(n);
}

o tipo de é inferido como sendo n, o tipo de int iteração de numbers.

Exemplo final

13.10 Instruções de salto

13.10.1 Generalidades

Instruções de salto transferem incondicionalmente o controle.

jump_statement
    : break_statement
    | continue_statement
    | goto_statement
    | return_statement
    | throw_statement
    ;

O local para o qual uma instrução jump transfere o controle é chamado de destino da instrução jump.

Quando uma instrução de salto ocorre dentro de um bloco, e o alvo dessa instrução de salto está fora desse bloco, a instrução de salto é dita para sair do bloco. Embora uma instrução jump possa transferir o controle de um bloco, ela nunca pode transferir o controle para um bloco.

A execução de declarações de salto é complicada pela presença de declarações intervenientes try . Na ausência de tais try declarações, uma instrução jump transfere incondicionalmente o controle da instrução jump para seu alvo. Na presença de tais declarações intervenientes try , a execução é mais complexa. Se a instrução jump sair de um ou mais try blocos com blocos associados finally , o controle será inicialmente transferido para o finally bloco da instrução mais try interna. Quando e se o controle atingir o ponto final de um finally bloco, o controle será transferido para o finally bloco da próxima instrução anexa try . Este processo é repetido até que os finally blocos de todas as instruções intervenientes try tenham sido executados.

Exemplo: No código a seguir

class Test
{
    static void Main()
    {
        while (true)
        {
            try
            {
                try
                {
                    Console.WriteLine("Before break");
                    break;
                }
                finally
                {
                    Console.WriteLine("Innermost finally block");
                }
            }
            finally
            {
                Console.WriteLine("Outermost finally block");
            }
        }
        Console.WriteLine("After break");
    }
}

Os finally blocos associados a duas try instruções são executados antes que o controle seja transferido para o destino da instrução Jump. A produção é a seguinte:

Before break
Innermost finally block
Outermost finally block
After break

Exemplo final

13.10.2 A declaração de interrupção

A break instrução sai do anexo switch, while, do, for, ou foreach instrução mais próximo.

break_statement
    : 'break' ';'
    ;

O destino de uma break instrução é o ponto final da declaração , switchwhile, do, for, ou foreach declaração mais próxima. Se uma break instrução não for incluída por uma switchinstrução , while, , dofor, ou , ocorrerá foreach um erro em tempo de compilação.

Quando várias switchinstruções , while, dofor, , ou foreach são aninhadas umas nas outras, uma break instrução se aplica apenas à instrução mais interna. Para transferir o controlo através de vários níveis de nidificação, deve ser utilizada uma goto declaração (§13.10.4).

Uma break declaração não pode sair de um finally bloco (§13.11). Quando uma break instrução ocorre dentro de um finally bloco, o alvo da instrução deve estar dentro do mesmo break bloco, caso contrário, ocorre um erro em tempo de finally compilação.

Uma break instrução é executada da seguinte forma:

• Se a break instrução sair de um ou mais try blocos com blocos associados finally , o controle será inicialmente transferido para o finally bloco da instrução mais try interna. Quando e se o controle atingir o ponto final de um finally bloco, o controle será transferido para o finally bloco da próxima instrução anexa try . Este processo é repetido até que os finally blocos de todas as instruções intervenientes try tenham sido executados.
• O controle é transferido para o break alvo da declaração.

Como uma break instrução transfere incondicionalmente o controle para outro lugar, o ponto final de uma break instrução nunca é alcançável.

13.10.3 A declaração de continuação

A continue instrução inicia uma nova iteração do anexo while, do, for, ou foreach instrução mais próximo.

continue_statement
    : 'continue' ';'
    ;

O destino de uma continue instrução é o ponto final da instrução incorporada da declaração anexa while, do, for, ou foreach instrução mais próxima. Se uma continue instrução não estiver incluída por uma whileinstrução , do, for, ou , ocorrerá foreach um erro em tempo de compilação.

Quando várias whileinstruções , do, for, ou foreach são aninhadas umas nas outras, uma continue instrução se aplica apenas à instrução mais interna. Para transferir o controlo através de vários níveis de nidificação, deve ser utilizada uma goto declaração (§13.10.4).

Uma continue declaração não pode sair de um finally bloco (§13.11). Quando uma continue instrução ocorre dentro de um finally bloco, o alvo da instrução deve estar dentro do mesmo continue bloco, caso contrário, ocorre um erro em tempo de finally compilação.

Uma continue instrução é executada da seguinte forma:

• Se a continue instrução sair de um ou mais try blocos com blocos associados finally , o controle será inicialmente transferido para o finally bloco da instrução mais try interna. Quando e se o controle atingir o ponto final de um finally bloco, o controle será transferido para o finally bloco da próxima instrução anexa try . Este processo é repetido até que os finally blocos de todas as instruções intervenientes try tenham sido executados.
• O controle é transferido para o continue alvo da declaração.

Como uma continue instrução transfere incondicionalmente o controle para outro lugar, o ponto final de uma continue instrução nunca é alcançável.

13.10.4 A declaração goto

A goto instrução transfere o controle para uma instrução marcada por um rótulo.

goto_statement
    : 'goto' identifier ';'
    | 'goto' 'case' constant_expression ';'
    | 'goto' 'default' ';'
    ;

O destino de uma gotoinstrução identificador é a declaração rotulada com o rótulo fornecido. Se um rótulo com o nome próprio não existir no membro da função atual, ou se a goto instrução não estiver dentro do escopo do rótulo, ocorrerá um erro em tempo de compilação.

Nota: Esta regra permite o uso de uma goto instrução para transferir o controle de um escopo aninhado , mas não para um escopo aninhado. No exemplo

class Test
{
    static void Main(string[] args)
    {
        string[,] table =
        {
            {"Red", "Blue", "Green"},
            {"Monday", "Wednesday", "Friday"}
        };
        foreach (string str in args)
        {
            int row, colm;
            for (row = 0; row <= 1; ++row)
            {
                for (colm = 0; colm <= 2; ++colm)
                {
                    if (str == table[row,colm])
                    {
                        goto done;
                    }
                }
            }
            Console.WriteLine($"{str} not found");
            continue;
          done:
            Console.WriteLine($"Found {str} at [{row}][{colm}]");
        }
    }
}

Uma goto instrução é usada para transferir o controle para fora de um escopo aninhado.

Nota final

O alvo de uma goto case declaração é a lista de instruções na declaração imediatamente anexa switch (§13.8.3) que contém um case rótulo com um padrão constante do valor constante dado e sem proteção. Se a goto case declaração não for anexada por uma switch instrução, se a declaração anexa switch mais próxima não contiver tal case, ou se a constant_expression não for implicitamente convertível (§10.2) para o tipo regulador da declaração anexa switch mais próxima, ocorrerá um erro em tempo de compilação.

O alvo de uma goto default declaração é a lista de declarações na declaração imediatamente anexa switch (§13.8.3), que contém um default rótulo. Se a goto default instrução não estiver incluída por uma switch instrução, ou se a instrução anexa switch mais próxima não contiver um default rótulo, ocorrerá um erro em tempo de compilação.

Uma goto declaração não pode sair de um finally bloco (§13.11). Quando uma goto instrução ocorre dentro de um finally bloco, o alvo da instrução deve estar dentro do mesmo goto bloco, ou então ocorre um erro em tempo de finally compilação.

Uma goto instrução é executada da seguinte forma:

• Se a goto instrução sair de um ou mais try blocos com blocos associados finally , o controle será inicialmente transferido para o finally bloco da instrução mais try interna. Quando e se o controle atingir o ponto final de um finally bloco, o controle será transferido para o finally bloco da próxima instrução anexa try . Este processo é repetido até que os finally blocos de todas as instruções intervenientes try tenham sido executados.
• O controle é transferido para o goto alvo da declaração.

Como uma goto instrução transfere incondicionalmente o controle para outro lugar, o ponto final de uma goto instrução nunca é alcançável.

13.10.5 Declaração de devolução

A return instrução retorna o controle para o chamador atual do membro da função no qual a instrução return aparece, opcionalmente retornando um valor ou um variable_reference (§9.5).

return_statement
    : 'return' ';'
    | 'return' expression ';'
    | 'return' 'ref' variable_reference ';'
    ;

Um return_statement sem expressão é chamado de retorno sem valor, um que contém expressão é chamado deref e um que contém apenas expressão é chamado de retorno por valor.

É um erro em tempo de compilação usar um return-no-value de um método declarado como sendo returns-by-value ou returns-by-ref (§15.6.1).

É um erro em tempo de compilação usar um return-by-ref de um método declarado como sendo returns-no-value ou returns-by-value.

É um erro em tempo de compilação usar um return-by-value de um método declarado como sendo returns-no-value ou returns-by-ref.

É um erro em tempo de compilação usar um return-by-ref se a expressão não for um variable_reference ou for uma referência a uma variável cujo ref-safe-context não é caller-context (§9.7.2).

É um erro em tempo de compilação usar um return-by-ref de um método declarado com o method_modifierasync.

Diz-se que um membro da função calcula um valor se for um método com um método returns-by-value (§15.6.11), um accessor de retorno por valor de uma propriedade ou indexador, ou um operador definido pelo usuário. Os membros da função que são retornos sem valor não calculam um valor e são métodos com o tipo voidde retorno efetivo, definem acessadores de propriedades e indexadores, adicionam e removem acessadores de eventos, construtores de instância, construtores estáticos e finalizadores. Os membros da função que são returns-by-ref não calculam um valor.

Para um retorno por valor, deve existir uma conversão implícita (§10.2) do tipo de expressão para o tipo de retorno efetivo (§15.6.11) do membro da função que o contém. Para um retorno por referência, deve existir uma conversão de identidade (§10.2.2) entre o tipo de expressão e o tipo de retorno efetivo do membro da função que o contém.

return As instruções também podem ser usadas no corpo de expressões de função anônimas (§12.19) e participar na determinação de quais conversões existem para essas funções (§10.7.1).

É um erro em tempo de compilação para uma return instrução aparecer em um finally bloco (§13.11).

Uma return instrução é executada da seguinte forma:

• Para um retorno por valor, a expressão é avaliada e seu valor é convertido para o tipo de retorno efetivo da função que contém por uma conversão implícita. O resultado da conversão torna-se o valor de resultado produzido pela função. Para um retorno por ref, a expressão é avaliada e o resultado deve ser classificado como uma variável. Se o return-by-ref do método de delimitação incluir readonly, a variável resultante será somente leitura.
• Se a return instrução estiver delimitada por um ou mais try blocos com catch blocos associados finally , o controle será inicialmente transferido para o finally bloco da instrução mais try interna. Quando e se o controle atingir o ponto final de um finally bloco, o controle será transferido para o finally bloco da próxima instrução anexa try . Este processo é repetido até que os finally blocos de todas as instruções anexas try tenham sido executados.
• Se a função de contenção não for uma função assíncrona, o controle será retornado ao chamador da função de contenção, juntamente com o valor do resultado, se houver.
• Se a função de contenção for uma função assíncrona, o controle será retornado ao chamador atual e o valor do resultado, se houver, será registrado na tarefa de retorno, conforme descrito em (§15.15.3).

Como uma return instrução transfere incondicionalmente o controle para outro lugar, o ponto final de uma return instrução nunca é alcançável.

13.10.6 A declaração de lançamento

A throw declaração lança uma exceção.

throw_statement
    : 'throw' expression? ';'
    ;

Uma throw instrução com uma expressão lança uma exceção produzida pela avaliação da expressão. A expressão deve ser implicitamente convertível em System.Exception, e o resultado da avaliação da expressão é convertido em System.Exception antes de ser lançada. Se o resultado da conversão for null, a System.NullReferenceException é lançado em vez disso.

Uma throw instrução sem expressão só pode ser usada em um catch bloco, caso em que essa instrução relança a exceção que está sendo manipulada atualmente por esse catch bloco.

Como uma throw instrução transfere incondicionalmente o controle para outro lugar, o ponto final de uma throw instrução nunca é alcançável.

Quando uma exceção é lançada, o controle é transferido para a primeira catch cláusula em uma instrução anexa try que pode lidar com a exceção. O processo que ocorre do ponto em que a exceção está sendo lançada até o ponto de transferência de controle para um manipulador de exceção adequado é conhecido como propagação de exceção. A propagação de uma exceção consiste em avaliar repetidamente as etapas a seguir até que uma catch cláusula que corresponda à exceção seja encontrada. Nesta descrição, o ponto de lançamento é inicialmente o local no qual a exceção é lançada. Este comportamento é especificado em (§21.4).

• No membro da função atual, cada try instrução que encerra o ponto de lançamento é examinada. Para cada afirmação S, começando com a declaração mais try interna e terminando com a declaração mais try externa, as seguintes etapas são avaliadas:

  • Se o try bloco de inclui o ponto de S lançamento e se S tem uma ou mais catch cláusulas, as catch cláusulas são examinadas em ordem de aparência para localizar um manipulador adequado para a exceção. A primeira catch cláusula que especifica um tipo T de exceção (ou um parâmetro de tipo que, em tempo de execução, denota um tipo Tde exceção) de tal forma que o tipo de tempo de execução deriva é ET considerado uma correspondência. Se a cláusula contiver um filtro de exceção, o objeto de exceção será atribuído à variável de exceção e o filtro de exceção será avaliado. Quando uma catch cláusula contém um filtro de exceção, essa catch cláusula é considerada uma correspondência se o filtro de exceção for avaliado como true. Uma cláusula geral catch (§13.11) é considerada uma correspondência para qualquer tipo de exceção. Se uma cláusula correspondente catch estiver localizada, a propagação da exceção será concluída transferindo o controle para o bloco dessa catch cláusula.
  • Caso contrário, se o try bloco ou um catch bloco de encerra o ponto de lançamento e se S tem um S bloco, o controle é transferido finally para o finally bloco. Se o finally bloco lançar outra exceção, o processamento da exceção atual será encerrado. Caso contrário, quando o controle atingir o ponto final do bloco, o finally processamento da exceção atual será continuado.

• Se um manipulador de exceção não foi localizado na chamada de função atual, a invocação de função é encerrada e uma das seguintes situações ocorre:

  • Se a função atual não for assíncrona, as etapas acima serão repetidas para o chamador da função com um ponto de lançamento correspondente à instrução a partir da qual o membro da função foi invocado.

  • Se a função atual for assíncrona e retornar tarefas, a exceção será registrada na tarefa de retorno, que é colocada em um estado com defeito ou cancelado, conforme descrito no §15.15.3.

  • Se a função atual for assíncrona e void-returning, o contexto de sincronização do thread atual será notificado conforme descrito no §15.15.4.

• Se o processamento de exceção encerrar todas as invocações de membro de função no thread atual, indicando que o thread não tem manipulador para a exceção, o próprio thread será encerrado. O impacto dessa rescisão é definido pela implementação.

13.11 A declaração de tentativa

A try instrução fornece um mecanismo para capturar exceções que ocorrem durante a execução de um bloco. Além disso, a try instrução fornece a capacidade de especificar um bloco de código que é sempre executado quando o controle deixa a try instrução.

try_statement
    : 'try' block catch_clauses
    | 'try' block catch_clauses? finally_clause
    ;

catch_clauses
    : specific_catch_clause+
    | specific_catch_clause* general_catch_clause
    ;

specific_catch_clause
    : 'catch' exception_specifier exception_filter? block
    | 'catch' exception_filter block
    ;

exception_specifier
    : '(' type identifier? ')'
    ;

exception_filter
    : 'when' '(' boolean_expression ')'
    ;

general_catch_clause
    : 'catch' block
    ;

finally_clause
    : 'finally' block
    ;

Um try_statement consiste na palavra-chave try seguida por um bloco, depois zero ou mais catch_clauses e, em seguida, um finally_clause opcional. Deve haver pelo menos um catch_clause ou um finally_clause.

Num exception_specifier o tipo, ou a sua classe de base efetiva, se for um type_parameter, deve ser System.Exception ou um tipo que dele derive.

Quando uma catch cláusula especifica um class_type e um identificador, uma variável de exceção do nome e do tipo fornecidos é declarada. A variável de exceção é introduzida no espaço de declaração do specific_catch_clause (§7.3). Durante a execução do exception_filtercatchbloco, a variável de exceção representa a exceção que está sendo tratada no momento. Para fins de verificação de atribuição definida, a variável de exceção é considerada definitivamente atribuída em todo o seu escopo.

A menos que uma catch cláusula inclua um nome de variável de exceção, é impossível acessar o objeto de exceção no filtro e catch no bloco.

Uma catch cláusula que não especifica nem um tipo de exceção nem um nome de variável de exceção é chamada de cláusula geral catch . Uma try declaração só pode ter uma cláusula geral catch e, se estiver presente, será a última catch cláusula.

Nota: Algumas linguagens de programação podem suportar exceções que não são representáveis como um objeto derivado do System.Exception, embora tais exceções nunca possam ser geradas pelo código C#. Poderá ser utilizada uma cláusula geral catch para abranger essas exceções. Assim, uma cláusula geral catch é semanticamente diferente daquela que especifica o tipo System.Exception, na medida em que a primeira também pode apanhar exceções de outras línguas. Nota final

A fim de localizar um manipulador para uma exceção, catch as cláusulas são examinadas em ordem lexical. Se uma catch cláusula especifica um tipo, mas nenhum filtro de exceção, é um erro em tempo de compilação para uma cláusula posterior catch da mesma try instrução especificar um tipo que é o mesmo que, ou é derivado de, esse tipo.

Nota: Sem esta restrição, seria possível escrever cláusulas inalcançáveis catch . Nota final

Dentro de um catch bloco, uma throw instrução (§13.10.6) sem expressão pode ser usada para relançar a exceção que foi capturada catch pelo bloco. As atribuições a uma variável de exceção não alteram a exceção que é relançada.

Exemplo: No código a seguir

class Test
{
    static void F()
    {
        try
        {
            G();
        }
        catch (Exception e)
        {
            Console.WriteLine("Exception in F: " + e.Message);
            e = new Exception("F");
            throw; // re-throw
        }
    }

    static void G() => throw new Exception("G");

    static void Main()
    {
        try
        {
            F();
        }
        catch (Exception e)
        {
            Console.WriteLine("Exception in Main: " + e.Message);
        }
    }
}

O método F captura uma exceção, grava algumas informações de diagnóstico no console, altera a variável de exceção e lança novamente a exceção. A exceção que é relançada é a exceção original, portanto, a saída produzida é:

Exception in F: G
Exception in Main: G

Se o primeiro catch bloco tivesse lançado e em vez de relançar a exceção atual, a saída produzida seria a seguinte:

Exception in F: G
Exception in Main: F

Exemplo final

É um erro em tempo de compilação para uma breakinstrução , continueou goto para transferir o controle para fora de um finally bloco. Quando uma breakinstrução , continue, ou goto ocorre em um finally bloco, o alvo da instrução deve estar dentro do mesmo finally bloco, ou então ocorre um erro em tempo de compilação.

É um erro em tempo de compilação para uma return instrução ocorrer em um finally bloco.

Quando a execução atinge uma try declaração, o controle é transferido para o try bloco. Se o controle atingir o ponto final do bloco sem que uma exceção seja propagada, o controle será transferido try para o finally bloco, se existir. Se nenhum finally bloco existir, o controle será transferido para o ponto final da try instrução.

Se uma exceção tiver sido propagada, as catch cláusulas, se houver, são examinadas em ordem lexical buscando a primeira correspondência para a exceção. A busca por uma cláusula de correspondência catch continua com todos os blocos anexos, conforme descrito no §13.10.6. Uma catch cláusula é uma correspondência se o tipo de exceção corresponder a qualquer exception_specifier e qualquer exception_filter for verdadeira. Uma catch cláusula sem exception_specifier corresponde a qualquer tipo de exceção. O tipo de exceção corresponde ao exception_specifier quando o exception_specifier especifica o tipo de exceção ou um tipo base do tipo de exceção. Se a cláusula contiver um filtro de exceção, o objeto de exceção será atribuído à variável de exceção e o filtro de exceção será avaliado.

Se uma exceção tiver sido propagada e uma cláusula correspondente catch for encontrada, o controle será transferido para o primeiro bloco correspondente catch . Se o controle atingir o ponto final do bloco sem que uma exceção seja propagada, o controle será transferido catch para o finally bloco, se existir. Se nenhum finally bloco existir, o controle será transferido para o ponto final da try instrução. Se uma exceção tiver sido propagada a partir do bloco, o catch controle será transferido para o finally bloco, se existir. A exceção é propagada para a próxima instrução anexa try .

Se uma exceção tiver sido propagada e nenhuma cláusula correspondente catch for encontrada, o controle será transferido para o finally bloco, se ele existir. A exceção é propagada para a próxima instrução anexa try .

As instruções de um finally bloco são sempre executadas quando o controle deixa uma try instrução. Isso é verdadeiro se a transferência de controle ocorre como resultado da execução normal, como resultado da execução de uma breakinstrução , continue, goto, ou return ou como resultado da propagação de uma exceção para fora da try instrução. Se o controle atingir o ponto final do finally bloco sem que uma exceção seja propagada, o try controle será transferido para o ponto final da instrução.

Se uma exceção for lançada durante a execução de um finally bloco e não for capturada dentro do mesmo finally bloco, a exceção será propagada para a próxima instrução de inclusão try . Se outra exceção estava em processo de propagação, essa exceção é perdida. O processo de propagação de uma exceção é discutido mais detalhadamente na descrição da throw declaração (§13.10.6).

Exemplo: No código a seguir

public class Test
{
    static void Main()
    {
        try
        {
            Method();
        }
        catch (Exception ex) when (ExceptionFilter(ex))
        {
            Console.WriteLine("Catch");
        }

        bool ExceptionFilter(Exception ex)
        {
            Console.WriteLine("Filter");
            return true;
        }
    }

    static void Method()
    {
        try
        {
            throw new ArgumentException();
        }
        finally
        {
            Console.WriteLine("Finally");
        }
    }
}

o método Method lança uma exceção. A primeira ação é examinar as cláusulas anexas catch , executando quaisquer filtros de exceção. Em seguida, a cláusula em finally executa antes que o Method controle seja transferido para a cláusula de correspondência catch anexa. A saída resultante é:

Filter
Finally
Catch

Exemplo final

O try bloco de uma try instrução é acessível se a try instrução estiver acessível.

Um catch bloco de uma try instrução é acessível se a try instrução estiver acessível.

O finally bloco de uma try instrução é acessível se a try instrução estiver acessível.

O ponto final de uma try instrução é alcançável se ambos os itens a seguir forem verdadeiros:

• O ponto final do try bloco é alcançável ou o ponto final de pelo menos um catch bloco é alcançável.
• Se um finally bloco estiver presente, o ponto final do finally bloco será alcançável.

13.12 As declarações verificadas e não verificadas

As checked instruções e unchecked são usadas para controlar o contexto de verificação de estouro para operações aritméticas e conversões do tipo integral.

checked_statement
    : 'checked' block
    ;

unchecked_statement
    : 'unchecked' block
    ;

A checked instrução faz com que todas as expressões no bloco sejam avaliadas em um contexto verificado, e a unchecked instrução faz com que todas as expressões no bloco sejam avaliadas em um contexto não verificado.

As checked instruções e unchecked são precisamente equivalentes aos checked operadores e unchecked (§12.8.20), exceto que operam em blocos em vez de expressões.

13.13 A declaração de bloqueio

A lock instrução obtém o bloqueio de exclusão mútua para um determinado objeto, executa uma instrução e, em seguida, libera o bloqueio.

lock_statement
    : 'lock' '(' expression ')' embedded_statement
    ;

A expressão de uma lock declaração deve indicar um valor de um tipo conhecido como referência. Nenhuma conversão implícita de boxe (§10.2.9) é executada para a expressão de uma lock instrução e, portanto, é um erro em tempo de compilação para a expressão denotar um valor de um value_type.

Uma lock declaração do formulário

lock (x) …

onde x é uma expressão de um reference_type, é precisamente equivalente a:

bool __lockWasTaken = false;
try
{
    System.Threading.Monitor.Enter(x, ref __lockWasTaken);
    ...
}
finally
{
    if (__lockWasTaken)
    {
        System.Threading.Monitor.Exit(x);
    }
}

só que só é x avaliado uma vez.

Enquanto um bloqueio de exclusão mútua é mantido, o código executado no mesmo thread de execução também pode obter e liberar o bloqueio. No entanto, o código executado em outros threads é impedido de obter o bloqueio até que o bloqueio seja liberado.

13.14 A declaração de utilização

A using instrução obtém um ou mais recursos, executa uma instrução e, em seguida, descarta o recurso.

using_statement
    : 'using' '(' resource_acquisition ')' embedded_statement
    ;

resource_acquisition
    : local_variable_declaration
    | expression
    ;

Um recurso é uma classe ou struct que implementa a System.IDisposable interface, que inclui um único método sem parâmetros chamado Dispose. O código que está usando um recurso pode chamar Dispose para indicar que o recurso não é mais necessário.

Se a forma de resource_acquisition for local_variable_declaration, o tipo de local_variable_declaration deve ser um ou um tipo que possa ser implicitamente convertido em .dynamicSystem.IDisposable Se a forma de resource_acquisition é expressão , então esta expressão deve ser implicitamente convertível em System.IDisposable.

As variáveis locais declaradas em um resource_acquisition são somente leitura e devem incluir um inicializador. Um erro em tempo de compilação ocorre se a instrução incorporada tentar modificar essas variáveis locais (via atribuição ou os ++ operadores and -- ), tomar o endereço delas ou passá-las como parâmetros de referência ou saída.

Uma using declaração é traduzida em três partes: aquisição, uso e alienação. O uso do recurso é implicitamente incluído em uma try instrução que inclui uma finally cláusula. Esta finally cláusula dispõe do recurso. Se um null recurso for adquirido, nenhuma chamada será feita e Dispose nenhuma exceção será lançada. Se o recurso for do tipo dynamic , é convertido dinamicamente através de uma conversão dinâmica implícita (§10.2.10) para IDisposable durante a aquisição, a fim de garantir que a conversão seja bem-sucedida antes da utilização e eliminação.

Uma using declaração do formulário

using (ResourceType resource = «expression» ) «statement»

corresponde a uma das três expansões possíveis. Quando ResourceType é um tipo de valor não anulável ou um parâmetro de tipo com a restrição de tipo de valor (§15.2.5), a expansão é semanticamente equivalente a

{
    ResourceType resource = «expression»;
    try
    {
        «statement»;
    }
    finally
    {
        ((IDisposable)resource).Dispose();
    }
}

exceto que o elenco de resource to System.IDisposable não deve fazer com que o boxe ocorra.

Caso contrário, quando ResourceType é dynamic, a expansão é

{
    ResourceType resource = «expression»;
    IDisposable d = resource;
    try
    {
        «statement»;
    }
    finally
    {
        if (d != null)
        {
            d.Dispose();
        }
    }
}

Caso contrário, a expansão é

{
    ResourceType resource = «expression»;
    try
    {
        «statement»;
    }
    finally
    {
        IDisposable d = (IDisposable)resource;
        if (d != null)
        {
            d.Dispose();
        }
    }
}

Em qualquer expansão, a resource variável é somente leitura na instrução incorporada, e a d variável é inacessível e invisível para a instrução incorporada.

Uma implementação é permitida para implementar um determinado using_statement de forma diferente, por exemplo, por razões de desempenho, desde que o comportamento seja consistente com a expansão acima.

Uma using declaração do formulário:

using («expression») «statement»

tem as mesmas três expansões possíveis. Neste caso ResourceType é implicitamente o tipo de tempo de compilação da expressão, se tiver um. Caso contrário, a interface IDisposable em si é usada como o ResourceType. A resource variável é inacessível e invisível para a instrução incorporada.

Quando um resource_acquisition assume a forma de um local_variable_declaration, é possível adquirir múltiplos recursos de um determinado tipo. Uma using declaração do formulário

using (ResourceType r1 = e1, r2 = e2, ..., rN = eN) «statement»

é precisamente equivalente a uma sequência de instruções aninhadas using :

using (ResourceType r1 = e1)
using (ResourceType r2 = e2)
...
using (ResourceType rN = eN)
«statement»

Exemplo: O exemplo abaixo cria um arquivo chamado log.txt e grava duas linhas de texto no arquivo. Em seguida, o exemplo abre esse mesmo arquivo para leitura e copia as linhas de texto contidas para o console.

class Test
{
    static void Main()
    {
        using (TextWriter w = File.CreateText("log.txt"))
        {
            w.WriteLine("This is line one");
            w.WriteLine("This is line two");
        }
        using (TextReader r = File.OpenText("log.txt"))
        {
            string s;
            while ((s = r.ReadLine()) != null)
            {
                Console.WriteLine(s);
            }
        }
    }
}

Como as TextWriter classes e TextReader implementam a IDisposable interface, o exemplo pode usar using instruções para garantir que o arquivo subjacente seja fechado corretamente após as operações de gravação ou leitura.

Exemplo final

13.15 A demonstração de rendimentos

A yield instrução é usada em um bloco iterador (§13.3) para produzir um valor para o objeto enumerador (§15.14.5) ou objeto enumerável (§15.14.6) de um iterador ou para sinalizar o fim da iteração.

yield_statement
    : 'yield' 'return' expression ';'
    | 'yield' 'break' ';'
    ;

yield é uma palavra-chave contextual (§6.4.4) e tem um significado especial apenas quando utilizada imediatamente antes de uma return ou break palavra-chave.

Há várias restrições sobre onde uma yield instrução pode aparecer, conforme descrito a seguir.

• É um erro em tempo de compilação para uma yield instrução (de qualquer forma) aparecer fora de um method_body, operator_body ou accessor_body.
• É um erro em tempo de compilação para uma yield instrução (de qualquer forma) aparecer dentro de uma função anônima.
• É um erro em tempo de compilação para uma yield instrução (de qualquer forma) aparecer na finally cláusula de uma try instrução.
• É um erro em tempo de compilação para uma yield return instrução aparecer em qualquer lugar em uma try instrução que contém qualquer catch_clauses.

Exemplo: O exemplo a seguir mostra alguns usos válidos e inválidos de yield instruções.

delegate IEnumerable<int> D();

IEnumerator<int> GetEnumerator()
{
    try
    {
        yield return 1; // Ok
        yield break;    // Ok
    }
    finally
    {
        yield return 2; // Error, yield in finally
        yield break;    // Error, yield in finally
    }
    try
    {
        yield return 3; // Error, yield return in try/catch
        yield break;    // Ok
    }
    catch
    {
        yield return 4; // Error, yield return in try/catch
        yield break;    // Ok
    }
    D d = delegate
    {
        yield return 5; // Error, yield in an anonymous function
    };
}

int MyMethod()
{
    yield return 1;     // Error, wrong return type for an iterator block
}

Exemplo final

Uma conversão implícita (§10.2) deve existir do tipo de expressão na yield return declaração para o tipo de rendimento (§15.14.4) do iterador.

Uma yield return instrução é executada da seguinte forma:

• A expressão dada na instrução é avaliada, implicitamente convertida para o tipo de rendimento e atribuída à Current propriedade do objeto enumerador.
• A execução do bloco iterador é suspensa. Se a yield return instrução estiver dentro de um ou mais try blocos, os blocos associados finally não serão executados no momento.
• O MoveNext método do objeto enumerador retorna true ao seu chamador, indicando que o objeto enumerador avançou com êxito para o próximo item.

A próxima chamada para o método do MoveNext objeto enumerador retoma a execução do bloco iterador de onde ele foi suspenso pela última vez.

Uma yield break instrução é executada da seguinte forma:

• Se a yield break instrução estiver delimitada por um ou mais try blocos com blocos associados finally , o controle será inicialmente transferido para o finally bloco da instrução mais try interna. Quando e se o controle atingir o ponto final de um finally bloco, o controle será transferido para o finally bloco da próxima instrução anexa try . Este processo é repetido até que os finally blocos de todas as instruções anexas try tenham sido executados.
• O controle é retornado ao chamador do bloco iterador. Este é o método ou MoveNext método Dispose do objeto enumerador.

Como uma yield break instrução transfere incondicionalmente o controle para outro lugar, o ponto final de uma yield break instrução nunca é alcançável.