Por que a declaração (j ++); proibido?

O código a seguir está errado (veja no ideone ):

public class Test
{
    public static void Main()
    {
        int j = 5;
        (j++);      // if we remove the "(" and ")" then this compiles fine.
    }
}

erro CS0201: Apenas designação, chamada, incremento, decremento, espera e novas expressões de objeto podem ser usadas como uma instrução

1. Por que o código é compilado quando removemos os parênteses?
2. Por que não compila com parênteses?
3. Por que o C # foi projetado dessa maneira?

Apreciação profunda.

Eu farei o meu melhor.

Como outras respostas observaram, o que está acontecendo aqui é que o compilador está detectando que uma expressão está sendo usada como uma declaração . Em muitos idiomas - C, JavaScript e muitos outros - é perfeitamente legal usar uma expressão como uma declaração. 2 + 2;é legal nesses idiomas, mesmo que essa seja uma declaração que não tem efeito. Algumas expressões são úteis apenas para seus valores, algumas expressões são úteis apenas para seus efeitos colaterais (como uma chamada para um método de retorno nulo) e algumas expressões, infelizmente, são úteis para ambos. (Como incremento.)

A questão é: declarações que consistem apenas em expressões são quase certamente erros, a menos que essas expressões sejam consideradas mais úteis para seus efeitos colaterais do que seus valores . Os designers de C # desejavam encontrar um meio termo, permitindo expressões que geralmente eram consideradas como efeito colateral, enquanto não permitiam aquelas que também são geralmente consideradas úteis para seus valores. O conjunto de expressões que eles identificaram no C # 1.0 foram incrementos, decréscimos, chamadas de método, atribuições e, de certa forma controversa, invocações de construtores.

À parte: Normalmente, considera-se uma construção de objeto como sendo usada pelo valor que produz, não pelo efeito colateral da construção; na minha opinião, permitir new Foo();é um pouco incorreto. Em particular, eu vi esse padrão no código do mundo real que causou um defeito de segurança:

catch(FooException ex) { new BarException(ex); } 

Pode ser surpreendentemente difícil detectar esse defeito se o código for complicado.

O compilador, portanto, trabalha para detectar todas as instruções que consistem em expressões que não estão nessa lista. Em particular, expressões entre parênteses são identificadas como exatamente isso - expressões entre parênteses. Eles não estão na lista de "permitido como expressões de instrução", portanto, não são permitidos.

Tudo isso está em serviço de um princípio de design da linguagem C #. Se você digitou (x++);, provavelmente estava fazendo algo errado . Este é provavelmente um erro de digitação M(x++);ou algo justo. Lembre-se, a atitude da equipe do compilador C # não é " podemos descobrir uma maneira de fazer isso funcionar? " A atitude da equipe do compilador C # é " se um código plausível parecer um provável erro, vamos informar o desenvolvedor ". Desenvolvedores de C # gostam dessa atitude.

Agora, tudo o que disse, realmente existem alguns casos estranhos onde o # especificação C não implicam ou estaduais abertamente que parênteses são permitidos, mas o compilador C # permite que eles de qualquer maneira. Em quase todos esses casos, a menor discrepância entre o comportamento especificado e o permitido é totalmente inofensiva, portanto, os escritores do compilador nunca corrigiram esses pequenos bugs. Você pode ler sobre aqueles aqui:

Existe uma diferença entre return myVar vs. return (myVar)?

Na especificação da linguagem C #

Instruções de expressão são usadas para avaliar expressões. Expressões que podem ser usadas como instruções incluem invocações de métodos, alocações de objetos usando o novo operador, atribuições usando = e operadores de atribuição composta, operações de incremento e decremento usando os operadores ++ e - e aguardam expressões.

Colocar parênteses em torno de uma instrução cria uma nova expressão chamada parênteses. A partir da especificação:

Uma expressão entre parênteses consiste em uma expressão entre parênteses. ... Uma expressão entre parênteses é avaliada avaliando a expressão entre parênteses. Se a expressão entre parênteses indicar um espaço para nome ou tipo, ocorrerá um erro em tempo de compilação. Caso contrário, o resultado da expressão entre parênteses é o resultado da avaliação da expressão contida.

Como expressões entre parênteses não são listadas como uma declaração de expressão válida, não é uma declaração válida de acordo com a especificação. Por que os designers optaram por fazê-lo dessa maneira é uma incógnita, mas minha aposta é que parênteses não funcionam de maneira útil se toda a declaração estiver entre parênteses: stmte (stmt)são exatamente os mesmos.

porque os colchetes ao redor do i++estão criando / definindo uma expressão .. como a mensagem de erro diz .. uma expressão simples não pode ser usada como uma declaração.

por que a linguagem foi projetada para ser assim? para evitar bugs, tendo expressões enganosas como instruções, que não produzem efeitos colaterais como ter o código

int j = 5;
j+1; 

a segunda linha não tem efeito (mas você pode não ter percebido). Mas, em vez de o compilador removê-lo (porque o código não é necessário), ele solicita explicitamente que você o remova (para que você fique ciente ou com o erro) OU corrija-o caso se esqueça de digitar algo.

editar :

para tornar a parte sobre bracked mais clara .. colchetes em c # (além de outros usos, como conversão de funções e chamada de função), são usados ​​para agrupar expressões e retornar uma única expressão (marca das subexpressões).

nesse nível de código, apenas staments são permitidos.

j++; is a valid statement because it produces side effects

mas usando o colchete você o transforma como expressão

myTempExpression = (j++)

e isto

myTempExpression;

não é válido porque o compilador não pode garantir que a expressão seja efeito colateral. (não sem incorrer no problema de parada) ..