Differenza tra C # e l'operatore ternario di Java (? :)

Sono un principiante di C # e ho appena riscontrato un problema. C'è una differenza tra C # e Java quando si ha a che fare con l'operatore ternario ( ? :).

Nel seguente segmento di codice, perché la quarta riga non funziona? Il compilatore mostra un messaggio di errore di there is no implicit conversion between 'int' and 'string'. Anche la quinta riga non funziona. Entrambi Listsono oggetti, non è vero?

int two = 2;
double six = 6.0;
Write(two > six ? two : six); //param: double
Write(two > six ? two : "6"); //param: not object
Write(two > six ? new List<int>() : new List<string>()); //param: not object

Tuttavia, lo stesso codice funziona in Java:

int two = 2;
double six = 6.0;
System.out.println(two > six ? two : six); //param: double
System.out.println(two > six ? two : "6"); //param: Object
System.out.println(two > six ? new ArrayList<Integer>()
                   : new ArrayList<String>()); //param: Object

Quale caratteristica del linguaggio in C # manca? Se esiste, perché non viene aggiunto?

Esaminando la sezione 7.14 delle specifiche del linguaggio C # 5: Operatore condizionale possiamo vedere quanto segue:

• Se x ha il tipo X e y ha il tipo Y, allora

  • Se esiste una conversione implicita (§6.1) da X a Y, ma non da Y a X, allora Y è il tipo di espressione condizionale.

  • Se esiste una conversione implicita (§6.1) da Y a X, ma non da X a Y, allora X è il tipo di espressione condizionale.

  • In caso contrario, non è possibile determinare il tipo di espressione e si verifica un errore in fase di compilazione

In altre parole: si cerca di trovare se xey possono essere convertiti in vicenda e, se non, si verifica un errore di compilazione. Nel nostro caso inte stringnon hanno conversioni esplicite o implicite, quindi non verranno compilate.

Confrontalo con la sezione 15.25 delle specifiche del linguaggio Java 7: Operatore condizionale :

• Se il secondo e il terzo operando hanno lo stesso tipo (che può essere il tipo null), allora quello è il tipo di espressione condizionale. ( NO )
• Se uno del secondo e terzo operando è di tipo primitivo T e il tipo dell'altro è il risultato dell'applicazione della conversione di boxe (§5.1.7) a T, il tipo di espressione condizionale è T. ( NO )
• Se uno del secondo e del terzo operando è di tipo null e il tipo dell'altro è un tipo di riferimento, il tipo di espressione condizionale è quel tipo di riferimento. ( NO )
• Altrimenti, se il secondo e il terzo operando hanno tipi convertibili (§5.1.8) in tipi numerici, allora ci sono diversi casi: ( NO )
• Altrimenti, il secondo e il terzo operando sono rispettivamente di tipo S1 e S2. Sia T1 il tipo che risulta dall'applicazione della conversione di boxe a S1 e che T2 sia il tipo che risulta dall'applicazione della conversione di boxe a S2.
  Il tipo di espressione condizionale è il risultato dell'applicazione della conversione di cattura (§5.1.10) a lub (T1, T2) (§15.12.2.7). ( SI )

E, guardando la sezione 15.12.2.7. Inferendo gli argomenti di tipo in base agli argomenti effettivi , possiamo vedere che cerca di trovare un antenato comune che fungerà da tipo utilizzato per la chiamata con cui lo atterra Object. Object è un argomento accettabile, quindi la chiamata funzionerà.

Le risposte fornite sono buone; Aggiungerei a loro che questa regola di C # è una conseguenza di una linea guida di progettazione più generale. Quando viene chiesto di dedurre il tipo di un'espressione da una delle diverse scelte, C # sceglie il migliore unico di esse . Cioè, se dai a C # alcune scelte come "Giraffe, Mammal, Animal", potrebbe scegliere la più generale - Animal - o potrebbe scegliere la più specifica - Giraffe - a seconda delle circostanze. Ma deve scegliere una delle scelte che le sono state effettivamente date . C # non dice mai "le mie scelte sono tra cane e gatto, quindi deduco che Animal è la scelta migliore". Non era una scelta data, quindi C # non può sceglierla.

Nel caso dell'operatore ternario C # cerca di scegliere il tipo più generale di int e stringa, ma nessuno dei due è il tipo più generale. Invece di scegliere un tipo che non era una scelta in primo luogo, come object, C # decide che nessun tipo può essere dedotto.

Noto anche che questo è in linea con un altro principio di progettazione di C #: se qualcosa sembra storto, dillo allo sviluppatore. La lingua non dice "Ho intenzione di indovinare cosa intendevi e se posso cavarmela". La lingua dice "Penso che tu abbia scritto qualcosa di confuso qui, e te ne parlerò".

Inoltre, noto che C # non ragiona dalla variabile al valore assegnato , ma piuttosto dall'altra direzione. C # non dice "stai assegnando a una variabile oggetto quindi l'espressione deve essere convertibile in oggetto, quindi mi assicurerò che lo sia". Piuttosto, C # dice "questa espressione deve avere un tipo e devo essere in grado di dedurre che il tipo è compatibile con l'oggetto". Poiché l'espressione non ha un tipo, viene prodotto un errore.

Per quanto riguarda la parte dei generici:

two > six ? new List<int>() : new List<string>()

In C #, il compilatore tenta di convertire le parti di espressione a destra in un tipo comune; poiché List<int>e List<string>sono due tipi costruiti distinti, uno non può essere convertito nell'altro.

In Java, il compilatore cerca di trovare un supertipo comune invece di convertire, quindi la compilazione del codice implica l'uso implicito di caratteri jolly e la cancellazione del tipo ;

two > six ? new ArrayList<Integer>() : new ArrayList<String>()

ha il tipo di compilazione di ArrayList<?>(in realtà, può essere anche ArrayList<? extends Serializable>o ArrayList<? extends Comparable<?>>, a seconda del contesto d'uso, poiché sono entrambi supertipi generici comuni) e il tipo di runtime di raw ArrayList(poiché è il supertipo raw comune).

Ad esempio (provalo tu stesso) ,

void test( List<?> list ) {
    System.out.println("foo");
}

void test( ArrayList<Integer> list ) { // note: can't use List<Integer> here
                                 // since both test() methods would clash after the erasure
    System.out.println("bar");
}

void test() {
    test( true ? new ArrayList<Object>() : new ArrayList<Object>() ); // foo
    test( true ? new ArrayList<Integer>() : new ArrayList<Object>() ); // foo 
    test( true ? new ArrayList<Integer>() : new ArrayList<Integer>() ); // bar
} // compiler automagically binds the correct generic QED

Sia in Java che in C # (e nella maggior parte degli altri linguaggi), il risultato di un'espressione ha un tipo. Nel caso dell'operatore ternario, ci sono due possibili sottoespressioni valutate per il risultato ed entrambe devono avere lo stesso tipo. Nel caso di Java, una intvariabile può essere convertita in un Integerautoboxing. Ora poiché entrambi Integere Stringereditano da Object, possono essere convertiti nello stesso tipo con una semplice conversione di restringimento.

D'altra parte, in C #, an intè una primitiva e non c'è conversione implicita in stringo qualsiasi altro object.

Questo è piuttosto semplice. Non c'è conversione implicita tra string e int. l'operatore ternario necessita che gli ultimi due operandi abbiano lo stesso tipo.

Provare:

Write(two > six ? two.ToString() : "6");