Anexo B Questões de portabilidade

Esta cláusula é informativa.

B.1 Geral

Este anexo recolhe algumas informações sobre a portabilidade que constam desta especificação.

B.2 Comportamento indefinido

O comportamento é indefinido nas seguintes circunstâncias:

1. O comportamento da função assíncrona delimitante quando um aguardador implementa os métodos INotifyCompletion.OnCompleted de interface e ICriticalNotifyCompletion.UnsafeOnCompleted não faz com que o delegado de retomada seja invocado no máximo uma vez (§12.9.9.4).
2. Passando ponteiros como parâmetros de referência ou saída (§24.3).
3. Ao desreferenciar o resultado da conversão de um tipo de ponteiro em outro e o ponteiro resultante não estiver alinhado corretamente para o tipo apontado. (§24.5.1).
4. Quando o operador unário * é aplicado a um ponteiro que contém um valor inválido (§24.6.2).
5. Quando um ponteiro é subscrito para acessar um elemento fora dos limites (§24.6.4).
6. Modificando objetos de tipo gerenciado por meio de ponteiros fixos (§24.7).
7. O conteúdo da memória recém-alocado por stackalloc (§12.8.22).
8. Tentando alocar um número negativo de itens usando stackalloc(§12.8.22).
9. Conversões dinâmicas implícitas (§10.2.10) de parâmetros de entrada com argumentos de valor (§12.6.4.2).

B.3 Comportamento definido pela implementação

Uma implementação em conformidade é necessária para documentar sua escolha de comportamento em cada uma das áreas listadas nesta subcláusula. Os itens a seguir são definidos pela implementação:

1. A manipulação do caractere Unicode NULL (U+0000) em uma unidade de compilação. (§6.1)
2. O comportamento quando um identificador que não está no Formulário de Normalização C é encontrado. (§6.4.3)
3. O valor máximo permitido para Decimal_Digit+ em PP_Line_Indicator. (§6.5.8)
4. A interpretação do input_characters no pp_pragma-texto de uma diretiva #pragma. (§6.5.10)
5. Os valores de todos os parâmetros do aplicativo passados Main pelo ambiente do host antes da inicialização do aplicativo. (§7.1)
6. O mecanismo para determinar se um programa é compilado como uma biblioteca de classes ou como um aplicativo. (§7.1)
7. A política ou os mecanismos usados por uma implementação para a criação e destruição de domínios de aplicativo. (§7.1)
8. O código de saída se o método de ponto de entrada efetivo for encerrado devido a uma exceção. (§7.2)
9. Se os finalizadores são ou não executados como parte do encerramento do aplicativo. (§7.2)
10. Se as APIs permitem que um finalizador seja executado mais de uma vez. (§7.9)
11. Se os finalizadores são ou não executados como parte do encerramento do aplicativo. (§7.9)
12. A superfície da API fornecida por Expression<TDelegate> além do requisito de um Compile método. (§8.6)
13. A estrutura precisa da árvore de expressão, bem como o processo exato para criá-la, quando uma função anônima é convertida em uma árvore de expressão. (§10.7.3)
14. O motivo pelo qual uma conversão em um tipo delegado compatível pode falhar em tempo de compilação. (§10.7.3)
15. O valor retornado quando uma alocação de pilha de tamanho zero é feita. (§12.8.22)
16. Se um System.ArithmeticException (ou uma subclasse dele) é lançado ou o estouro não é relatado com o valor resultante sendo o do operando esquerdo, quando em um unchecked contexto e o operando esquerdo de uma divisão inteira é o valor negativo máximo int ou long e o operando direito é –1. (§12.12.3)
17. Quando a System.ArithmeticException (ou uma subclasse dela) é lançada ao executar uma operação de resto decimal. (§12.12.4)
18. O impacto do encerramento do thread quando um thread não tem nenhum manipulador para uma exceção e o próprio thread é encerrado. (§13.10.6)
19. O mecanismo pelo qual a ligação a um método externo é alcançada. (seção 15.6.8)
20. O impacto do encerramento do thread quando nenhuma cláusula correspondente catch é encontrada para uma exceção e o código que iniciou inicialmente esse thread é alcançado. (§22,4).
21. Um ambiente de execução pode fornecer atributos adicionais que afetam a execução de um programa C#. (§23.5.1)
22. Os mapeamentos entre ponteiros e inteiros. (§24.5.1)
23. O efeito de aplicar o operador unário * a um null ponteiro. (§24.6.2)
24. O comportamento quando a aritmética do ponteiro ultrapassa o domínio do tipo de ponteiro. (§24.6.6, §24.6.7)
25. O resultado do sizeof operador para tipos de valor não predefinidos. (§24.6.9)
26. O comportamento da instrução se a expressão de fixed matriz for null ou se a matriz tiver zero elementos. (§24,7)
27. O comportamento da fixed instrução se a expressão de cadeia de caracteres for null. (§24,7)

B.4 Comportamento não especificado

1. O momento em que o finalizador (se houver) de um objeto é executado, uma vez que esse objeto se torna elegível para finalização (§7.9).
2. A representação de true (§8.3.9).
3. O valor do resultado ao converter valores fora do intervalo de float ou valores em um tipo integral em um double contexto (unchecked).
4. O objeto de destino exato e o método de destino do delegado produzido a partir de um anonymous_method_expression contém (§10.7.2).
5. O layout das matrizes, exceto em um contexto não seguro (§12.8.17.4).
6. Se há alguma maneira de executar o bloco de uma função anônima diferente da avaliação e invocação do lambda_expression ou anonymous_method expressão (§12.21.3).
7. O tempo exato da inicialização do campo estático (§15.5.6.2).
8. O resultado da invocação MoveNext quando um objeto enumerador está em execução (§15.15.5.2).
9. O resultado do acesso Current quando um objeto enumerador está nos estados antes, em execução ou após (§15.15.5.3).
10. O resultado da invocação Dispose quando um objeto enumerador está no estado em execução (§15.15.5.4).
11. Os atributos de um tipo declarado em várias partes são determinados combinando, em uma ordem não especificada, os atributos de cada uma de suas partes (§23.3).
12. A ordem na qual os membros são empacotados em um struct (§24.6.9).
13. Uma exceção ocorre durante a execução do finalizador e essa exceção não é capturada (§22.4).
14. Se mais de um membro corresponder, qual membro será a implementação de I.M (§19.6.5).

B.5 Outras questões

1. Os resultados exatos da avaliação de expressão de ponto flutuante podem variar de uma implementação para outra, pois uma implementação tem permissão para avaliar essas expressões usando um intervalo e/ou precisão maior do que o necessário (§8.3.7).
2. Determinadas assinaturas são reservadas para compatibilidade com outras linguagens de programação (§15.3.10).

Fim do texto informativo.