È C# 6?. (Elvis op) thread safe? Se é cosi, come?

Question

Scuse in anticipo: questa domanda proviene da uno sviluppatore C++ hard-core e non modificato che sta cercando di imparare C# avanzato. Considera quanto segue:

if (myUserDefinedObject != null) 
{ 
    myUserDefinedObject.ToString(); 
} 

Questo ovviamente non è thread-safe. D'altra parte, ho visto due tutorial che dicono? (Il condizionale operatore Null o 'Elvis Operatore'), per esempio,

myUserDefinedObject?.ToString(); 

IS thread-safe. A meno che il compilatore non avvolga un blocco [mutex?] Attorno ad esso sotto le coperte (brividi), non capisco come possa essere vero. Se questo idioma è infallibile, qualcuno può indicarmi una descrizione tecnica di come è stata realizzata? Se non è thread-safe, qualcuno ha un riferimento che in realtà dice che non lo è?

Answer 1

Da MSDN (sottolineatura mia):

Un altro uso per l'accesso dell'utente nullo condizione invoca delegati in modo thread-safe con molto meno codice. Il vecchio modo richiede codice come il seguente:

var handler = this.PropertyChanged; 
if (handler != null) 
    handler(…) 

Il nuovo modo è molto più semplice:

PropertyChanged?.Invoke(e) 

Il nuovo modo è thread-safe perché il compilatore genera il codice di valutare solo PropertyChanged una volta, mantenendo il risultato in variabile temporanea.

Quindi non c'è alcun blocco coinvolto qui - la sicurezza del thread viene applicata creando una variabile temporanea locale, che impedisce a un thread diverso di modificare quella variabile tra il controllo Null e qualche altra operazione.

Answer 2

Desidero chiarire la risposta (corretta) di BJ Myers.

In C# un evento può essere pensato come un campo di tipo delegato - proprio come una proprietà può essere pensata come un campo del tipo di proprietà - e il valore di quel "campo" può essere nullo. Se siete nella spiacevole situazione di dover un gestore di eventi in corso di modifica su un thread mentre un altro thread sta tentando di invocarlo, è possibile ottenere in una situazione in cui:

if (this.SomeEvent != null) 
    this.SomeEvent(...); 

non è threadsafe. Il valore potrebbe essere mutato in modo tale che non sia nullo prima del controllo, nullo dopo il controllo e il programma si blocchi.

Il modo usuale per rendere questo "thread-safe", e io uso il termine consigliato, è quello di copiare il valore su un locale e quindi testare il locale per null. Questo ha il vantaggio di non bloccarsi con un dereferenziamento nullo. Tuttavia, lo sviluppatore intelligente noterà che c'è ancora una gara!La sequenza può essere

gestore di eventi

• non nullo nella cache sul thread A
• gestore di eventi impostato nulla sul filo B
• Stato necessaria per gestore di eventi viene distrutto sul filo B
• gestore di eventi viene eseguito su thread A e dies orribly

Quindi, in questo senso, questo modello non è "thread safe". Se sei in questa sfortunata posizione , sei responsabile di assicurare che la logica di threading appropriata sia implementata in modo che ciò non avvenga. Puoi farlo come vuoi. Se vuoi i (discutibili) vantaggi di poter chiamare un gestore di eventi su un thread mentre muti l'evento su un altro thread, devi pagare per renderlo sicuro, o gestire bug di race condition.

Personalmente eviterei questa situazione come la peste, ma non sono abbastanza intelligente per scrivere il codice multithread corretto.

Ora, come per la domanda effettiva:

some_expression ?. ToString(); 

è lo stesso di

temp = some_expression 
temp == null ? null : temp.ToString() 

è il secondo codice "threadsafe" secondo te?