Perché era la dichiarazione (j ++); vietato?

Il codice seguente è errato (vederlo su ideone ):

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

errore CS0201: Solo un'assegnazione, una chiamata, un incremento, un decremento, un attesa e nuove espressioni oggetto possono essere utilizzate come un'istruzione

1. Perché il codice viene compilato quando rimuoviamo le parentesi?
2. Perché non si compila con le parentesi?
3. Perché C # è stato progettato in questo modo?

Approfondimenti approfonditi apprezzati.

Farò del mio meglio.

Come hanno notato altre risposte, quello che sta succedendo qui è che il compilatore sta rilevando che un'espressione viene utilizzata come un'istruzione . In molte lingue - C, JavaScript e molte altre - è perfettamente legale usare un'espressione come una dichiarazione. 2 + 2;è legale in queste lingue, anche se questa è un'affermazione che non ha alcun effetto. Alcune espressioni sono utili solo per i loro valori, alcune espressioni sono utili solo per i loro effetti collaterali (come una chiamata a un metodo di ritorno vuoto) e alcune espressioni, purtroppo, sono utili per entrambi. (Come incremento.)

Punto centrale: le affermazioni che consistono solo di espressioni sono quasi certamente errori a meno che quelle espressioni non siano in genere considerate più utili per i loro effetti collaterali rispetto ai loro valori . I progettisti di C # desideravano trovare una via di mezzo, consentendo espressioni che erano generalmente pensate come effetti collaterali, mentre non consentivano quelle che sono anche generalmente considerate utili per i loro valori. L'insieme di espressioni che hanno identificato in C # 1.0 erano incrementi, decrementi, chiamate a metodi, assegnazioni e in qualche modo controverse invocazioni di costruttori.

A PARTIRE: normalmente si pensa a una costruzione di oggetti utilizzata per il valore che produce, non per l'effetto collaterale della costruzione; a mio avviso, consentire new Foo();è un po 'un malfunzionamento. In particolare, ho visto questo modello nel codice del mondo reale che ha causato un difetto di sicurezza:

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

Può essere sorprendentemente difficile individuare questo difetto se il codice è complicato.

Il compilatore quindi lavora per rilevare tutte le istruzioni che consistono in espressioni che non sono in quell'elenco. In particolare, le espressioni tra parentesi sono identificate proprio come espressioni tra parentesi. Non sono nell'elenco di "consentiti come espressioni di istruzione", quindi non sono consentiti.

Tutto ciò è al servizio di un principio progettuale del linguaggio C #. Se hai digitato (x++);probabilmente stavi facendo qualcosa di sbagliato . Questo è probabilmente un refuso per M(x++);o qualche cosa giusta. Ricorda, l'atteggiamento del team del compilatore C # non è " possiamo capire in che modo farlo funzionare? " L'atteggiamento del team del compilatore C # è " se il codice plausibile sembra un probabile errore, informiamo lo sviluppatore ". Agli sviluppatori C # piace questo atteggiamento.

Ora, tutto ciò che ha detto, in realtà ci sono alcuni casi in cui il dispari # specifica C non implicano o statali e tondo che tra parentesi non sono consentiti, ma il compilatore C # li permette comunque. In quasi tutti quei casi la piccola discrepanza tra il comportamento specificato e il comportamento consentito è completamente innocua, quindi gli autori del compilatore non hanno mai risolto questi piccoli bug. Puoi leggere su quelli qui:

C'è una differenza tra return myVar e return (myVar)?

Nelle specifiche del linguaggio C #

Le dichiarazioni di espressione vengono utilizzate per valutare le espressioni. Le espressioni che possono essere usate come istruzioni includono invocazioni di metodi, allocazioni di oggetti usando il nuovo operatore, assegnazioni usando = e gli operatori di assegnazione composti, operazioni di incremento e decremento usando gli operatori ++ e - e attendo espressioni.

Mettere le parentesi attorno a un'istruzione crea una nuova cosiddetta espressione tra parentesi. Dalla specifica:

Un'espressione tra parentesi è costituita da un'espressione racchiusa tra parentesi. ... Un'espressione tra parentesi viene valutata valutando l'espressione tra parentesi. Se l'espressione tra parentesi indica uno spazio dei nomi o un tipo, si verifica un errore in fase di compilazione. Altrimenti, il risultato dell'espressione tra parentesi è il risultato della valutazione dell'espressione contenuta.

Poiché le espressioni tra parentesi non sono elencate come una dichiarazione di espressione valida, non è una dichiarazione valida secondo la specifica. Il motivo per cui i progettisti hanno scelto di farlo in questo modo è un'ipotesi di chiunque, ma la mia scommessa è perché le parentesi non fanno un lavoro utile se l'intera affermazione è racchiusa tra parentesi: stmte (stmt)sono esattamente le stesse.

perché le parentesi attorno a i++stanno creando / definendo un'espressione .. come dice il messaggio di errore .. una semplice espressione non può essere usata come un'istruzione.

perché la lingua è stata progettata per essere così? per prevenire i bug, che hanno espressioni fuorvianti come istruzioni, che non producono alcun effetto collaterale come avere il codice

int j = 5;
j+1; 

la seconda riga non ha alcun effetto (ma potresti non averlo notato). Ma invece di rimuoverlo dal compilatore (perché il codice non è necessario) .it ti chiede esplicitamente di rimuoverlo (quindi sarai a conoscenza o l'errore) O correggilo nel caso in cui ti sei dimenticato di digitare qualcosa.

modifica :

per rendere più chiara la parte relativa alle parentesi quadre .. le parentesi quadre in c # (oltre ad altri usi, come cast e call di funzione), vengono utilizzate per raggruppare espressioni e restituire una singola espressione (creare espressioni secondarie).

a quel livello di codice sono ammessi solo gli stament .. così

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

ma usando il bracketing lo stai trasformando in espressione

myTempExpression = (j++)

e questo

myTempExpression;

non è valido perché il compilatore non può garantire che l'espressione come effetto collaterale (non senza incorrere nel problema di arresto).