?: ?? Operatori invece di IF | ELSE

public string Source
{
    get
    {
        /*
        if ( Source == null ){
            return string . Empty;
        } else {
            return Source;
        }
        */
        return Source ?? string.Empty;
    }
    set
    {
        /*
        if ( Source == null ) {
            Source = string . Empty;
        } else {
            if ( Source == value ) {
                Source = Source;
            } else {
                Source = value;
            }
        }
        */
        Source == value ? Source : value ?? string.Empty;
        RaisePropertyChanged ( "Source" );
    }
}

Posso usare gli ?: ??operatori ESATTAMENTE come If / Else?

La mia domanda:
come scrivere quanto segue con?: ?? operatori

[1]

if ( Source == null ){
    // Return Nothing
} else {
    return Source;
}

[2]

if ( Source == value ){
    // Do Nothing
} else {
    Source = value;
    RaisePropertyChanged ( "Source" );
} 

In breve : come non fare nulla, non restituire nulla e eseguire più istruzioni con l' ?: ??operatore?

Per [1], non puoi: questi operatori sono fatti per restituire un valore, non per eseguire operazioni.

L'espressione

a ? b : c

restituisce bse aè vero e restituisce cse aè falso.

L'espressione

b ?? c

restituisce bif bnon è null e restituisce cif bè null.

Se scrivi

return a ? b : c;

o

return b ?? c;

essi saranno sempre restituire qualcosa.

Per [2], puoi scrivere una funzione che restituisce il valore corretto che esegue le tue "operazioni multiple", ma probabilmente è peggio del semplice utilizzo if/else.

L'operatore ternario ( ?:) non è progettato per il flusso di controllo , è progettato solo per l' assegnazione condizionale . Se hai bisogno di controllare il flusso del tuo programma, usa una struttura di controllo, come if/ else.

Riferimento a ?: Operatore (riferimenti per C #)

L'operatore condizionale (? :) restituisce uno dei due valori a seconda del valore di un'espressione booleana. Di seguito è riportata la sintassi per l'operatore condizionale.

Riferendosi a ?? Operatore (riferimenti per C #)

Il ?? L'operatore viene chiamato operatore di coalescenza null e viene utilizzato per definire un valore predefinito per i tipi di valore nullable e per i tipi di riferimento. Restituisce l'operando di sinistra se non è nullo; altrimenti restituisce l'operando di destra.

Questo significa:

[Parte 1]

return source ?? String.Empty;

[Parte 2] non è applicabile ...

Il "non fare niente" non funziona davvero?

se per // Return Nothing intendi effettivamente restituire null allora scrivi

return Source;

se intendi, ignora il codepath e poi scrivi

 if ( Source != null )
            {
                return Source;
            }
// source is null so continue on.

E per ultimo

 if ( Source != value )
            { Source = value;
                RaisePropertyChanged ( "Source" );
            }

// nothing done.

L'operatore ternario RESTITUISCE uno di due valori. Oppure può eseguire una delle due istruzioni in base alle sue condizioni, ma in genere non è una buona idea, poiché può portare a effetti collaterali indesiderati.

bar ? () : baz();

In questo caso, () non fa nulla, mentre baz fa qualcosa. Ma hai solo reso il codice meno chiaro. Preferirei un codice più dettagliato che sia più chiaro e più facile da mantenere.

Inoltre, questo ha poco senso:

var foo = bar ? () : baz();

poiché () non ha alcun tipo di ritorno (è void) e baz ha un tipo di ritorno che è sconosciuto al punto di chiamata in questo esempio. Se non sono d'accordo, il compilatore si lamenterà e ad alta voce.

Se sei preoccupato per la verbosità del tuo codice, lo scriverei piuttosto che cercare di abusare delle espressioni.

if (Source == value) return;
Source = value;
RaisePropertyChanged("Source");

il?: è l'operatore dell'itinerario. (credo di averlo scritto correttamente) ed è semplice da usare. come in un predicato booleano? iftrue: ifalse; Ma devi avere un rvalue / lvalue come in rvalue = predicate? iftrue: iffalse;

ex int i = x < 7 ? x : 7;

se x fosse minore di 7, verrei assegnato x, altrimenti sarei 7.

puoi anche usarlo in un ritorno, come in return x < 7 ? x : 7;

di nuovo, come sopra, questo avrebbe lo stesso effetto.

quindi, Source = Source == value ? Source : string.Empty;credo sia quello che stai cercando di ottenere.

L' ?:operatore restituisce uno dei due valori a seconda del valore di un'espressione booleana.

Condition-Expression ? Expression1 : Expression2

Scopri di più sull'operatore ?:, noto anche come Operatore ternario:

• http://net-informations.com/csprj/statements/cs-operator.htm

Non penso che tu possa essere un operatore e si supponga di restituire l'uno o l'altro. Non è la sostituzione dell'istruzione if else, sebbene possa essere utilizzata per questo in alcuni casi.